@cstack-protocol/pingala 1.0.0

package/src/core/governor.ts

@@ -0,0 +1,522 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import process from "node:process";
+import { Rule531, type ToolInstance } from "./531-rule.js";
+
+export interface MaturityState {
+    level: number;
+    level_name: string;
+    stability_days: number;
+    last_changed_at: string; // ISO date
+    readonly?: boolean; // If true, state cannot be persisted (e.g. cloud/stateless mode)
+    definition?: string;
+    primary_action?: string;
+    telemetry?: {
+        attention_depth: number; // 0-100
+        dependency_exposure: number; // 0-100
+        last_updated: string;
+    };
+    decision_stats?: {
+        total_validations: number;
+        justified_validations: number;
+    };
+    csi_baseline?: number;
+    csi_latest?: number;
+}
+
+export interface ProposedChange {
+    type: 'add_tool' | 'remove_tool' | 'change_role' | 'change_anchor' | 'audit';
+    tool_name: string;
+    proposed_role?: 'Anchor' | 'Active' | 'Supporting';
+    functionId?: string; // Horizon 1.5: Functional Slot/Room ID
+    contexts?: string[]; // Horizon 1.5: System contexts
+    isAdapter?: boolean; // Horizon 1.5: Bridge Coefficient flag
+    replaces_existing?: boolean;
+    replaced_tool?: string;
+    justification?: string;
+}
+
+export interface GovernanceContext {
+    current_stack: {
+        anchor: ToolInstance | null;
+        active: ToolInstance[];
+        supporting: ToolInstance[];
+    };
+    functional_nodes: {
+        id: string;
+        role: string;
+        tools: string[];
+    }[];
+    maturity_level: number;
+    maturity_name: string;
+    stability_days: number;
+    csi_latest: number;
+    allowed_actions: string[];
+    blocked_actions: string[];
+    progression: {
+        can_level_up: boolean;
+        next_level: number | null;
+        days_remaining: number;
+        csi_delta: number;
+        is_l2_eligible: boolean;
+    };
+}
+
+export class Governor {
+    private static dataDir: string = (() => {
+        if (process.env.CSTACK_DATA_DIR) return process.env.CSTACK_DATA_DIR;
+        if (process.env.VERCEL) return "/tmp";
+        return path.join(os.homedir(), ".cstack-data");
+    })();
+
+    private static getFilePath(filename: string): string {
+        try {
+            if (!fs.existsSync(this.dataDir)) {
+                fs.mkdirSync(this.dataDir, { recursive: true });
+            }
+        } catch (e) {
+            console.error(`[Governor] Warning: Could not create data directory ${this.dataDir}. Using /tmp fallback.`);
+            this.dataDir = "/tmp";
+        }
+        return path.join(this.dataDir, filename);
+    }
+
+    private static DEFAULT_STACK: ToolInstance[] = [
+        { name: "Pingala", role: "Anchor", functionId: "Core-Governance", category: "Core" },
+        { name: "Claude", role: "Active", functionId: "Interaction-Edge", category: "AI" },
+        { name: "Vercel", role: "Active", functionId: "Cloud-Compute", category: "Infrastructure" },
+        { name: "Cursor", role: "Active", functionId: "Development-Lattice", category: "IDE" },
+        { name: "Express", role: "Supporting", functionId: "Transport-Node", category: "Web" },
+        { name: "MCP-SDK", role: "Supporting", functionId: "Protocol-Core", category: "Library" },
+        { name: "Zod", role: "Supporting", functionId: "Schema-Guardian", category: "Validation" },
+        { name: "TypeScript", role: "Supporting", functionId: "Logic-Lattice", category: "Logic" },
+        { name: "Git", role: "Supporting", functionId: "Source-History", category: "VCS" }
+    ];
+
+    static getStack(): ToolInstance[] {
+        const filePath = this.getFilePath("stack-map.json");
+        // If we are in fallback /tmp, check if we have persistence
+        if (this.dataDir === "/tmp" && !process.env.VERCEL) {
+            // Local fallback without permissions = readonly default
+        }
+
+        if (fs.existsSync(filePath)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+                return data.tools || this.DEFAULT_STACK;
+            } catch (e) {
+                console.error("[Governor] Error reading stack-map.json:", e);
+                return this.DEFAULT_STACK;
+            }
+        }
+        return this.DEFAULT_STACK;
+    }
+
+    static saveStack(tools: ToolInstance[]): void {
+        const state = this.getMaturityState();
+        if (state.readonly) return; // Skip persistence in stateless mode
+
+        const filePath = this.getFilePath("stack-map.json");
+        try {
+            fs.writeFileSync(filePath, JSON.stringify({ tools }, null, 2));
+
+            // Update stability
+            state.last_changed_at = new Date().toISOString();
+            this.saveMaturityState(state);
+        } catch (e) {
+            console.error("[Governor] Warning: Could not save stack-map.json", e);
+        }
+    }
+
+    static getMaturityState(): MaturityState {
+        const filePath = this.getFilePath("maturity-state.json");
+        const defaultState: MaturityState = {
+            level: 1,
+            level_name: "Fragmented",
+            stability_days: 0,
+            last_changed_at: new Date().toISOString(),
+            readonly: this.dataDir === "/tmp" && process.env.NODE_ENV === "production"
+        };
+
+        if (fs.existsSync(filePath)) {
+            try {
+                const state = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+
+                // Calculate actual stability days
+                const lastChanged = new Date(state.last_changed_at);
+                const now = new Date();
+                const diffTime = Math.abs(now.getTime() - lastChanged.getTime());
+                state.stability_days = Math.floor(diffTime / (1000 * 60 * 60 * 24));
+
+                return state;
+            } catch (e) {
+                console.error("[Governor] Error reading maturity-state.json:", e);
+                return defaultState;
+            }
+        }
+        return defaultState;
+    }
+
+    static saveMaturityState(state: MaturityState): void {
+        if (state.readonly) return; // Skip persistence in stateless mode
+
+        const filePath = this.getFilePath("maturity-state.json");
+        try {
+            fs.writeFileSync(filePath, JSON.stringify(state, null, 2));
+        } catch (e) {
+            console.error("[Governor] Warning: Could not save maturity state", e);
+        }
+    }
+
+    static recordTelemetry(data: { attention_depth?: number; dependency_exposure?: number }): void {
+        const state = this.getMaturityState();
+        if (state.readonly) return;
+
+        state.telemetry = {
+            attention_depth: data.attention_depth ?? state.telemetry?.attention_depth ?? 50,
+            dependency_exposure: data.dependency_exposure ?? state.telemetry?.dependency_exposure ?? 50,
+            last_updated: new Date().toISOString()
+        };
+        this.saveMaturityState(state);
+    }
+
+    static recordValidation(justified: boolean): void {
+        const state = this.getMaturityState();
+        if (state.readonly) return;
+
+        if (!state.decision_stats) {
+            state.decision_stats = { total_validations: 0, justified_validations: 0 };
+        }
+        state.decision_stats.total_validations++;
+        if (justified) state.decision_stats.justified_validations++;
+        this.saveMaturityState(state);
+    }
+
+    static updateCsi(score: number): void {
+        const state = this.getMaturityState();
+        if (state.readonly) return;
+
+        if (state.csi_baseline === undefined) {
+            state.csi_baseline = score;
+        }
+        state.csi_latest = score;
+        this.saveMaturityState(state);
+    }
+
+    static getDecisionProvenanceScore(): number {
+        const state = this.getMaturityState();
+        if (!state.decision_stats || state.decision_stats.total_validations === 0) return 50;
+        return Math.round((state.decision_stats.justified_validations / state.decision_stats.total_validations) * 100);
+    }
+
+    static getStackDriftScore(): { score: number; signals: string[]; summary: string } {
+        const tools = this.getStack();
+        const state = this.getMaturityState();
+        const validation = Rule531.validate({ tools });
+
+        let score = validation.score;
+        const signals = [...validation.violations];
+
+        // Temporal deductions
+        const lastChanged = new Date(state.last_changed_at);
+        const now = new Date();
+        const diffDays = Math.floor(Math.abs(now.getTime() - lastChanged.getTime()) / (1000 * 60 * 60 * 24));
+
+        if (diffDays > 0) {
+            const temporalPenalty = Math.min(20, diffDays * 5);
+            score -= temporalPenalty;
+            if (temporalPenalty > 0) {
+                signals.push(`Attention Erosion: ${diffDays} days since last protocol synthesis (-${temporalPenalty} points)`);
+            }
+        }
+
+        // Anchor check (specifically for drift signal)
+        if (!tools.some(t => t.role === 'Anchor')) {
+            // Rule531 might already have this in recommendations, but let's ensure it impacts score/signals
+            if (!signals.some(s => s.includes("Anchor"))) {
+                score -= 10;
+                signals.push("Anchor Void: No center of truth established (-10 points)");
+            }
+        }
+
+        score = Math.max(0, score);
+
+        let summary = "Maintaining Crystalline Geometry.";
+        if (score < 85) summary = "Minor drift detected. Review Supporting nodes.";
+        if (score < 70) summary = "Significant architectural erosion. Audit required.";
+        if (score < 50) summary = "Systemic collapse risk. Execute rapid reversal.";
+
+        return { score, signals, summary };
+    }
+
+    static validateStackChange(change: ProposedChange, stackOverride?: ToolInstance[]) {
+        const currentStack = stackOverride || this.getStack();
+        const state = this.getMaturityState();
+
+        // Rule 1: 5:3:1 Enforcement
+        const validation = this.check531Rules(currentStack, change);
+        if (!validation.allowed) return validation;
+
+        // Rule 3: Maturity Gates
+        const gate = this.enforceMaturityGates(state, change);
+        if (!gate.allowed) return gate;
+
+        return {
+            allowed: true,
+            reason: "Compliant with the Conscious Stack Protocol (CSP) and Maturity Gates",
+            impact: {
+                stability_reset: true,
+                new_stability_days: 0
+            }
+        };
+    }
+
+    private static check531Rules(currentStack: ToolInstance[], change: ProposedChange) {
+        const getRoleNodeCount = (tools: ToolInstance[], role: string) => {
+            const roleTools = tools.filter(t => t.role === role);
+            // In Fractal logic, a core role is only counted if it represents a UNIQUE slot
+            // UNLESS it's an anchor of a sub-stack that is being promoted to a higher stack.
+            const slots = new Set(roleTools.filter(t => t.functionId).map(t => t.functionId));
+            const unclassifiedCount = roleTools.filter(t => !t.functionId).length;
+            return slots.size + unclassifiedCount;
+        };
+
+        const counts = {
+            anchor: getRoleNodeCount(currentStack, 'Anchor'),
+            active: getRoleNodeCount(currentStack, 'Active'),
+            supporting: getRoleNodeCount(currentStack, 'Supporting')
+        };
+
+        if (change.type === 'add_tool' || change.type === 'change_role') {
+            const role = change.proposed_role;
+            const targetFunctionId = change.functionId;
+
+            // Check if this tool is being added to an EXISTING functional node (Fractal Slot)
+            const existingNodeTools = targetFunctionId ? currentStack.filter(t => t.functionId === targetFunctionId) : [];
+            const isSubstack = existingNodeTools.length > 0;
+
+            if (isSubstack) {
+                // FRACTAL RULE: If adding to a sub-stack, check if we are creating a Sub-stack Anchor conflict
+                if (role === 'Anchor' && existingNodeTools.some(t => t.role === 'Anchor')) {
+                    const currentSubAnchor = existingNodeTools.find(t => t.role === 'Anchor');
+                    return {
+                        allowed: false,
+                        reason: `Fractal Violation: Sub-stack '${targetFunctionId}' already has an Anchor (${currentSubAnchor?.name}). Only one tool can be the 'Visible' gateway for this slot.`,
+                        alternatives: [
+                            `Demote ${change.tool_name} to Supporting within the ${targetFunctionId} sub-stack`,
+                            `Replace ${currentSubAnchor?.name} as the primary gateway for this slot`
+                        ]
+                    };
+                }
+
+                // If the sub-stack currently HAS NO anchor, and we are adding a non-anchor, warn but allow (will trigger audit violation)
+                return { allowed: true };
+            }
+
+            // CORE STACK LIMITS (Slot-based)
+            if (role === 'Anchor') {
+                if (counts.anchor >= 1 && !change.replaces_existing) {
+                    const currentAnchor = currentStack.find(t => t.role === 'Anchor');
+                    return {
+                        allowed: false,
+                        reason: `Protocol violation: Only 1 Anchor Node permitted in the Core Stack. Current anchor: ${currentAnchor?.name}`,
+                        alternatives: [
+                            `Cluster ${change.tool_name} into the existing Anchor slot (building a sub-stack)`,
+                            `Replace ${currentAnchor?.name} with ${change.tool_name}`,
+                            `Assign ${change.tool_name} as Active instead`
+                        ]
+                    };
+                }
+            } else if (role === 'Active') {
+                if (counts.active >= 3 && !change.replaces_existing) {
+                    return {
+                        allowed: false,
+                        reason: `Protocol violation: Max 3 Active Slots permitted. Your Core Stack is congested.`,
+                        alternatives: [
+                            `Cluster ${change.tool_name} into an existing Active slot (e.g., as a supporting tool in a sub-stack)`,
+                            "Archive least-used Active node",
+                            `Move ${change.tool_name} to Supporting tier`
+                        ]
+                    };
+                }
+            } else if (role === 'Supporting') {
+                if (counts.supporting >= 5 && !change.replaces_existing) {
+                    return {
+                        allowed: false,
+                        reason: `Protocol violation: Max 5 Supporting Slots permitted in the Core Stack.`,
+                        alternatives: [
+                            `Nest ${change.tool_name} inside an existing Supporting sub-stack`,
+                            "Archive least-used Supporting node",
+                            "Promote this to Active if critical (requires archiving an Active slot)"
+                        ]
+                    };
+                }
+            }
+        }
+
+        return { allowed: true };
+    }
+
+    private static enforceMaturityGates(state: MaturityState, change: ProposedChange) {
+        const GATES: Record<number, any> = {
+            1: {
+                level_name: "Fragmented",
+                min_stability_days: 7, // Stability required to REACH Level 2
+                allowed_changes: ["remove_tool", "audit", "emergency_subtract"],
+                blocked_changes: ["add_tool", "change_anchor"],
+                definition: "Tools and processes are random, chaotic, and uncoordinated.",
+                primary_action: "Audit & Eliminate. Reduce tool count by 30%.",
+                message: "Level 1: Focus on subtraction and stabilization only"
+            },
+            2: {
+                level_name: "Siloed",
+                min_stability_days: 14, // Stability required to REACH Level 3
+                allowed_changes: ["remove_tool", "audit", "change_role"],
+                blocked_changes: ["add_tool", "change_anchor"],
+                definition: "Structure exists, but systems operate in isolation.",
+                primary_action: "Standardize. Create specific 'Anchors' for each workflow.",
+                message: "Level 2: Maintain 14 days stability before additions"
+            },
+            3: {
+                level_name: "Integrated",
+                min_stability_days: 30, // Stability required to REACH Level 4
+                allowed_changes: ["remove_tool", "audit", "add_tool", "change_role"],
+                blocked_changes: ["change_anchor"],
+                definition: "Data flows between systems; reduced friction.",
+                primary_action: "Automate. Use APIs to connect Edges.",
+                message: "Level 3: Can adjust Active/Supporting after 30 days stability"
+            },
+            4: {
+                level_name: "Aligned",
+                min_stability_days: 90, // Stability required to REACH Level 5
+                allowed_changes: ["remove_tool", "audit", "add_tool", "change_role", "change_anchor"],
+                blocked_changes: [],
+                definition: "Stack reflects values, strategy, and purpose.",
+                primary_action: "Refine. Align rituals with tool usage.",
+                message: "Level 4: All changes permitted with 90+ days stability"
+            },
+            5: {
+                level_name: "Resonant",
+                min_stability_days: 180,
+                allowed_changes: ["all"],
+                blocked_changes: [],
+                definition: "Tech amplifies unique human value and signal.",
+                primary_action: "Transcend. The stack becomes invisible.",
+                message: "Level 5: Mature stack, trust your judgment"
+            }
+        };
+
+        const gate = GATES[state.level];
+
+        // Update state with metadata if missing
+        if (!state.level_name || state.level_name !== gate.level_name) {
+            state.level_name = gate.level_name;
+            state.definition = gate.definition;
+            state.primary_action = gate.primary_action;
+        }
+
+        // Action check (Subtraction is ALWAYS allowed regardless of stability)
+        if (change.type === 'remove_tool' || change.type === 'audit') {
+            return { allowed: true };
+        }
+
+        // Stability check for ADDITIONS/CHANGES
+        // Rules are based on the NEXT gate. If we are L2, we are subject to the L2 "maintenance" rules.
+        const currentStability = state.stability_days;
+
+        // Block additions if current level stability requirement isn't met or action is generally blocked
+        if (gate.blocked_changes.includes(change.type)) {
+            return {
+                allowed: false,
+                reason: `${gate.message}. Action '${change.type}' is unauthorized at the ${gate.level_name} stage.`,
+                gate_requirements: gate
+            };
+        }
+
+        // Special rule: Stability threshold for any "positive" change (adding/moving)
+        const isExpansion = change.type === 'add_tool' || change.type === 'change_role' || change.type === 'change_anchor';
+        const prevGateStability = state.level > 1 ? GATES[state.level - 1].min_stability_days : 0;
+
+        if (currentStability < prevGateStability && isExpansion) {
+            return {
+                allowed: false,
+                reason: `Stability gate: Reach ${prevGateStability} days of stability in the ${gate.level_name} stage before expanding. Current: ${currentStability} days.`,
+                gate_requirements: {
+                    required_days: prevGateStability,
+                    current_days: currentStability
+                }
+            };
+        }
+
+        return { allowed: true };
+    }
+
+    static getGovernanceContext(): GovernanceContext {
+        const tools = this.getStack();
+        const state = this.getMaturityState();
+
+        // Group into Functional Nodes for the context
+        const nodeMap: Record<string, { role: string, tools: string[] }> = {};
+        const unclassified: any[] = [];
+
+        tools.forEach(t => {
+            if (t.functionId) {
+                if (!nodeMap[t.functionId]) nodeMap[t.functionId] = { role: t.role, tools: [] };
+                nodeMap[t.functionId].tools.push(t.name);
+            } else {
+                unclassified.push({ id: t.name, role: t.role, tools: [t.name] });
+            }
+        });
+
+        const functionalNodes = [
+            ...Object.entries(nodeMap).map(([id, data]) => ({ id, ...data })),
+            ...unclassified
+        ];
+
+        // Determine allowed/blocked actions for UI/Context
+        const allActions: Array<'add_tool' | 'remove_tool' | 'change_role' | 'change_anchor'> = ["add_tool", "remove_tool", "change_role", "change_anchor"];
+        const blocked = allActions.filter(a => {
+            const res = this.validateStackChange({ type: a, tool_name: '' });
+            return !res.allowed;
+        });
+        const allowed = allActions.filter(a => !blocked.includes(a));
+
+        // Progression check
+        const nextLevel = state.level < 5 ? state.level + 1 : null;
+        const canLevelUp = nextLevel && state.stability_days >= this.getNextGateRequiredDays(state.level);
+        const csiDelta = (state.csi_latest || 0) - (state.csi_baseline || state.csi_latest || 0);
+
+        return {
+            current_stack: {
+                anchor: tools.find(t => t.role === 'Anchor') || null,
+                active: tools.filter(t => t.role === 'Active'),
+                supporting: tools.filter(t => t.role === 'Supporting')
+            },
+            functional_nodes: functionalNodes,
+            maturity_level: state.level,
+            maturity_name: state.level_name || "Unknown",
+            stability_days: state.stability_days,
+            csi_latest: state.csi_latest || 0,
+            allowed_actions: allowed,
+            blocked_actions: blocked, progression: {
+                can_level_up: !!canLevelUp,
+                next_level: nextLevel,
+                days_remaining: Math.max(0, this.getNextGateRequiredDays(state.level) - state.stability_days),
+                csi_delta: csiDelta,
+                is_l2_eligible: csiDelta >= 10
+            }
+        };
+    }
+
+    private static getNextGateRequiredDays(level: number): number {
+        const GATES_DAYS: Record<number, number> = {
+            1: 7,
+            2: 14,
+            3: 30,
+            4: 90,
+            5: 180
+        };
+        return GATES_DAYS[level] || 0;
+    }
+}

package/src/core/life-area-mapper.ts

@@ -0,0 +1,138 @@
+import { ToolInstance } from "./531-rule.js";
+import { MethodologyLoader, BaguaCategory, InnerDiamondCategory } from "./methodology.js";
+
+/**
+ * LifeAreaAnalysis: The result of mapping a stack to life areas.
+ */
+export interface LifeAreaAnalysis {
+    areas: {
+        id: string;
+        label: string;
+        tools: string[];
+        description: string;
+    }[];
+    gaps: string[];
+    overIndexed: string[];
+}
+
+/**
+ * InnerDiamondAnalysis: The result of mapping a stack to deep identity patterns (L3).
+ */
+export interface InnerDiamondAnalysis {
+    reflections: {
+        id: string;
+        label: string;
+        observation: string;
+        prompt: string;
+    }[];
+    forecast: {
+        sovereignty_score: number;
+        primary_risk: string;
+        evolution_path: string;
+    };
+}
+
+/**
+ * LifeAreaMapper: Interface for mapping tools to life areas/domains.
+ */
+export interface LifeAreaMapper {
+    mapToolsToAreas(tools: ToolInstance[], practitionerMode?: boolean): LifeAreaAnalysis;
+}
+
+/**
+ * BaguaMapper: The default implementation using the 9-room Bagua system.
+ */
+export class BaguaMapper implements LifeAreaMapper {
+    private categories: BaguaCategory[];
+
+    constructor() {
+        this.categories = MethodologyLoader.loadBaguaCategories();
+    }
+
+    /**
+     * Maps tools to Bagua rooms and returns sanitized labels.
+     */
+    mapToolsToAreas(tools: ToolInstance[], practitionerMode: boolean = false): LifeAreaAnalysis {
+        const mapping = this.categories.map(cat => ({
+            id: cat.name, // Internal ID (e.g., Li, Kun)
+            label: practitionerMode ? cat.name : (cat.userFacingLabel || cat.description),
+            tools: tools.filter(t => t.functionId === cat.name).map(t => t.name),
+            description: cat.description
+        }));
+
+        const gaps = mapping.filter(m => m.tools.length === 0).map(m => m.label);
+        const overIndexed = mapping.filter(m => m.tools.length > 2).map(m => m.label);
+
+        return {
+            areas: mapping,
+            gaps,
+            overIndexed
+        };
+    }
+}
+
+/**
+ * DiamondMapper: L3 Identity and Purpose mapping.
+ */
+export class DiamondMapper {
+    private categories: InnerDiamondCategory[];
+
+    constructor() {
+        this.categories = MethodologyLoader.loadInnerDiamondCategories();
+    }
+
+    /**
+     * Generates L3 reflection points based on the tool stack.
+     */
+    mapToDiamond(tools: ToolInstance[], practitionerMode: boolean = false): InnerDiamondAnalysis {
+        // Logic for L3 is more qualitative and pattern-based
+        const prompts = MethodologyLoader.loadConsentPrompts(); // Not exactly what we need, but we can have specific prompts
+
+        const reflections = this.categories.map(cat => ({
+            id: cat.name,
+            label: practitionerMode ? cat.name : (cat.userFacingLabel || cat.name),
+            observation: this.getObservationForCategory(cat.name, tools),
+            prompt: this.getPromptForCategory(cat.name, tools)
+        }));
+
+        // Calculate a proxy sovereignty score based on variety of functions and tool count
+        const uniqueFunctions = new Set(tools.map(t => t.functionId).filter(Boolean)).size;
+        const sovScore = Math.min(100, Math.round((uniqueFunctions / 9) * 100));
+
+        return {
+            reflections,
+            forecast: {
+                sovereignty_score: sovScore,
+                primary_risk: tools.length > 9 ? "Conscious Fragmentation" : "Dependency Lock-in",
+                evolution_path: "Move from 'tool-centric' to 'process-centric' autonomy."
+            }
+        };
+    }
+
+    private getObservationForCategory(cat: string, tools: ToolInstance[]): string {
+        switch (cat) {
+            case 'Identity':
+                return tools.length > 0 ? `Your choices in ${tools[0].name} suggest a focus on efficiency.` : "No clear identity pattern detected.";
+            case 'Purpose':
+                const anchors = tools.filter(t => t.role === 'Anchor');
+                return anchors.length > 0 ? `Your Anchor (${anchors[0].name}) is the seat of your daily purpose.` : "Your purpose lacks a central digital anchor.";
+            case 'Sovereignty':
+                return `You are currently balancing ${tools.length} nodes of external dependencies.`;
+            default:
+                return "Reflecting on pattern...";
+        }
+    }
+
+    private getPromptForCategory(cat: string, tools: ToolInstance[]): string {
+        switch (cat) {
+            case 'Identity':
+                return "Who would you be if this stack was reset tomorrow?";
+            case 'Purpose':
+                return "Does this stack serve your mission, or does it define it?";
+            case 'Sovereignty':
+                return "Where are you choosing not to see a dependency?";
+            default:
+                return "What is ready to evolve?";
+        }
+    }
+}