progmune-runtime 2.1.5 → 3.2.0

package/dist/state-miner.js

@@ -0,0 +1,386 @@
+"use strict";
+/**
+ * Progmune V3.3 — State Mining Engine
+ * ====================================
+ * 从代码中恢复业务状态机，而非函数调用序列。
+ *
+ * 核心理念:
+ *   Policy 真正约束的是 State Transition（状态变化），不是 Function Order（函数顺序）。
+ *   "Created → Paid → Shipped" 合法，"Created → Shipped" 非法。
+ *   这不是函数顺序问题，是状态机问题。
+ *
+ * 三层挖掘:
+ *   L1: State Discovery — 从枚举、常量、类型定义中提取状态值
+ *   L2: State Transition Recovery — 从行为图中恢复状态转换
+ *   L3: State Machine Assembly — 将状态和转换组装成完整状态机
+ *
+ * 输入: Behavior Graph (V3.2) + 项目路径
+ * 输出: State Machines — 每个业务实体的完整生命周期
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mineStates = mineStates;
+const ts_morph_1 = require("ts-morph");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// ══════════════════════════════════════════════
+// L1: STATE DISCOVERY
+// ══════════════════════════════════════════════
+/**
+ * Extract all state-like definitions from the codebase.
+ * States come from:
+ *   1. TypeScript enums with Status/State/Stage/Type names
+ *   2. Drizzle mysqlEnum column definitions
+ *   3. String literal union types (type Status = "active" | "inactive")
+ */
+function discoverStates(projectPath) {
+    const states = [];
+    // ── Direct regex extraction from Drizzle/Prisma schema files ──
+    // ts-morph can fail parsing runtime imports. Regex is more robust.
+    for (const schemaDir of ["drizzle", "prisma", "db", "database"]) {
+        const schemaPath = path.join(projectPath, schemaDir);
+        if (!fs.existsSync(schemaPath))
+            continue;
+        for (const entry of fs.readdirSync(schemaPath, { recursive: true })) {
+            const fullPath = path.join(schemaPath, entry);
+            if (!fullPath.endsWith(".ts"))
+                continue;
+            const content = fs.readFileSync(fullPath, "utf-8");
+            const fileName = path.relative(projectPath, fullPath);
+            // Extract: mysqlTable("tableName", { ... status: mysqlEnum("status", ["a","b"]) ... })
+            // Pattern: mysqlTable("name", { ... colName: mysqlEnum("col", [...values]) ... })
+            const tableRegex = /mysqlTable\s*\(\s*["']([^"']+)["']\s*,\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}\s*\)/gs;
+            let tableMatch;
+            while ((tableMatch = tableRegex.exec(content)) !== null) {
+                const tableName = tableMatch[1];
+                const columnsBlock = tableMatch[2];
+                // Extract: colName: mysqlEnum("col", ["val1", "val2", ...])
+                const enumRegex = /(\w+)\s*:\s*mysqlEnum\s*\(\s*["'][^"']*["']\s*,\s*\[([^\]]+)\]/g;
+                let enumMatch;
+                while ((enumMatch = enumRegex.exec(columnsBlock)) !== null) {
+                    const colName = enumMatch[1];
+                    const valuesStr = enumMatch[2];
+                    const values = valuesStr.match(/["']([^"']+)["']/g)?.map(v => v.replace(/["']/g, "")) || [];
+                    const isStateColumn = ["status", "state", "type", "stage", "phase", "role", "paymentMethod"].includes(colName);
+                    if (isStateColumn && values.length >= 2) {
+                        for (const val of values) {
+                            states.push({
+                                name: val,
+                                entity: tableName,
+                                source: "enum",
+                                file: fileName,
+                                lineNumber: 0,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // ── TypeScript enums from server source files ──
+    if (fs.existsSync(path.join(projectPath, "server"))) {
+        for (const entry of fs.readdirSync(path.join(projectPath, "server"), { recursive: true })) {
+            const fullPath = path.join(projectPath, "server", entry);
+            if (!fullPath.endsWith(".ts"))
+                continue;
+            const content = fs.readFileSync(fullPath, "utf-8");
+            const fileName = path.relative(projectPath, fullPath);
+            // Extract: enum OrderStatus { CREATED = "created", ... }
+            const enumRegex = /enum\s+(\w+)\s*\{([^}]+)\}/g;
+            let enumMatch;
+            while ((enumMatch = enumRegex.exec(content)) !== null) {
+                const enumName = enumMatch[1];
+                const body = enumMatch[2];
+                const isStateEnum = /status|state|stage|type|step|phase/i.test(enumName);
+                if (isStateEnum) {
+                    const entityName = enumName.replace(/status|state|stage|type|step|phase/gi, "").trim() || enumName;
+                    const members = body.match(/(\w+)\s*(?:=\s*["']?(\w+)["']?)?/g) || [];
+                    for (const m of members) {
+                        const name = m.split("=")[0].trim();
+                        if (name && !name.startsWith("//")) {
+                            states.push({ name, entity: entityName, source: "enum", file: fileName, lineNumber: 0 });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return states;
+}
+// ══════════════════════════════════════════════
+// L2: STATE TRANSITION RECOVERY
+// ══════════════════════════════════════════════
+/**
+ * Map function names to state transitions using heuristics.
+ * e.g. "updateOrderStatus" + args containing "SHIPPED" → transition to SHIPPED
+ * e.g. "createOrder" → transition to CREATED
+ * e.g. "payOrder" → transition to PAID
+ */
+function recoverTransitions(projectPath, states, behaviorEdges) {
+    const project = new ts_morph_1.Project({
+        tsConfigFilePath: path.join(projectPath, "tsconfig.json"),
+        skipAddingFilesFromTsConfig: false,
+    });
+    // Also add drizzle/prisma schema files (often excluded from tsconfig includes)
+    for (const schemaDir of ["drizzle", "prisma", "db", "database"]) {
+        const schemaPath = path.join(projectPath, schemaDir);
+        if (fs.existsSync(schemaPath)) {
+            project.addSourceFilesAtPaths(path.join(schemaPath, "**/*.ts"));
+        }
+    }
+    const transitions = [];
+    const stateNamesByEntity = new Map();
+    for (const s of states) {
+        if (!stateNamesByEntity.has(s.entity)) {
+            stateNamesByEntity.set(s.entity, new Set());
+        }
+        stateNamesByEntity.get(s.entity).add(s.name);
+    }
+    for (const sourceFile of project.getSourceFiles()) {
+        const filePath = sourceFile.getFilePath().replace(projectPath + "/", "");
+        if (filePath.includes("node_modules") || filePath.includes(".test."))
+            continue;
+        // Walk all function calls
+        sourceFile.forEachDescendant((node) => {
+            if (!ts_morph_1.Node.isCallExpression(node))
+                return;
+            const callText = node.getExpression().getText().toLowerCase();
+            // Heuristic: if a function call contains a state name + verb,
+            // it's likely a state transition
+            for (const [entity, stateNames] of stateNamesByEntity) {
+                const entityLower = entity.toLowerCase();
+                // Check if this call is related to the entity
+                if (!callText.includes(entityLower) && !callText.includes("status") && !callText.includes("state")) {
+                    continue;
+                }
+                // Look for state values in the function call or its arguments
+                for (const stateName of stateNames) {
+                    const stateLower = stateName.toLowerCase();
+                    const args = node.getArguments().map(a => a.getText().toLowerCase()).join(" ");
+                    // Does this call set or transition to this state?
+                    const isTransition = callText.includes(stateLower) ||
+                        args.includes(stateLower) ||
+                        args.includes(`"${stateLower}"`) ||
+                        args.includes(`'${stateLower}'`);
+                    if (isTransition) {
+                        // Determine the transition direction:
+                        // - "create" or "insert" → entering this state
+                        // - "update" or "set" → transitioning TO this state (from unknown previous state)
+                        // - "delete" or "remove" → leaving this state
+                        const isCreation = callText.includes("create") || callText.includes("insert") || callText.includes("init");
+                        const isMutation = callText.includes("update") || callText.includes("set") || callText.includes("change");
+                        // Try to find the previous state from the call context
+                        // Look at enclosing function for "if (status === X)" patterns
+                        let fromState = "UNKNOWN";
+                        const parent = node.getParent();
+                        if (parent) {
+                            const parentText = parent.getText().toLowerCase();
+                            for (const prevState of stateNames) {
+                                if (parentText.includes(`"${prevState.toLowerCase()}"`) ||
+                                    parentText.includes(`'${prevState.toLowerCase()}'`) ||
+                                    parentText.includes(`=== "${prevState.toLowerCase()}"`)) {
+                                    fromState = prevState;
+                                    break;
+                                }
+                            }
+                        }
+                        if (isCreation) {
+                            fromState = "INITIAL";
+                        }
+                        const existingTransition = transitions.find(t => t.from === fromState && t.to === stateName && t.entity === entity);
+                        if (existingTransition) {
+                            existingTransition.frequency++;
+                            existingTransition.confidence = Math.min(100, existingTransition.confidence + 5);
+                        }
+                        else {
+                            transitions.push({
+                                from: fromState,
+                                to: stateName,
+                                entity,
+                                viaFunction: callText,
+                                frequency: 1,
+                                topologyConfirmed: isMutation || isCreation,
+                                confidence: isCreation ? 70 : 40,
+                            });
+                        }
+                    }
+                }
+            }
+        });
+    }
+    return transitions;
+}
+// ══════════════════════════════════════════════
+// L3: STATE MACHINE ASSEMBLY
+// ══════════════════════════════════════════════
+/**
+ * From states and transitions, assemble complete business state machines.
+ */
+function assembleMachines(states, transitions) {
+    const machines = [];
+    const entities = [...new Set(states.map(s => s.entity))];
+    for (const entity of entities) {
+        const entityStates = states.filter(s => s.entity === entity);
+        const entityTransitions = transitions.filter(t => t.entity === entity);
+        if (entityStates.length < 2)
+            continue;
+        // Sort states: INITIAL first, then by transition frequency, then terminal
+        const stateNames = [...new Set(entityStates.map(s => s.name))];
+        const initialState = entityTransitions.find(t => t.from === "INITIAL")?.to || stateNames[0];
+        // Terminal states: states that appear as "to" but not as "from"
+        const fromSet = new Set(entityTransitions.map(t => t.from));
+        const toSet = new Set(entityTransitions.map(t => t.to));
+        const terminalStates = stateNames.filter(s => toSet.has(s) && !fromSet.has(s));
+        // Valid transitions: the ones we've observed
+        const validTransitions = entityTransitions.map(t => `${t.from}→${t.to}`);
+        // Invalid transitions: all other possible pairs (for validation)
+        const invalidTransitions = [];
+        for (const from of stateNames) {
+            for (const to of stateNames) {
+                if (from === to)
+                    continue;
+                const key = `${from}→${to}`;
+                if (!validTransitions.includes(key)) {
+                    invalidTransitions.push(key);
+                }
+            }
+        }
+        // Coverage: what % of possible transitions have we observed?
+        const totalPossible = stateNames.length * (stateNames.length - 1);
+        const coverage = totalPossible > 0 ? Math.round((validTransitions.length / totalPossible) * 100) : 0;
+        // Overall confidence: average of transition confidences
+        const avgConf = entityTransitions.length > 0
+            ? Math.round(entityTransitions.reduce((s, t) => s + t.confidence, 0) / entityTransitions.length)
+            : 0;
+        machines.push({
+            entity,
+            states: stateNames,
+            initialState,
+            terminalStates,
+            transitions: entityTransitions,
+            validTransitions,
+            invalidTransitions: invalidTransitions.slice(0, 20), // Don't blow up
+            coverage,
+            confidence: avgConf,
+        });
+    }
+    // Sort by confidence descending
+    machines.sort((a, b) => b.confidence - a.confidence);
+    return machines;
+}
+// ══════════════════════════════════════════════
+// MAIN PIPELINE
+// ══════════════════════════════════════════════
+function mineStates(projectPath) {
+    console.log("🔬 Progmune State Mining Engine — V3.3");
+    console.log("   Project:", projectPath);
+    // L1: State Discovery
+    console.log("\nL1 · State Discovery...");
+    const states = discoverStates(projectPath);
+    const entityCount = new Set(states.map(s => s.entity)).size;
+    console.log(`   ${states.length} states found across ${entityCount} entities`);
+    // Group by entity and show
+    const byEntity = new Map();
+    for (const s of states) {
+        if (!byEntity.has(s.entity))
+            byEntity.set(s.entity, []);
+        byEntity.get(s.entity).push(s);
+    }
+    for (const [entity, entityStates] of byEntity) {
+        const stateNames = entityStates.map(s => s.name);
+        console.log(`     ${entity}: [${stateNames.join(", ")}]`);
+    }
+    // L2: State Transition Recovery
+    console.log("\nL2 · Transition Recovery...");
+    const transitions = recoverTransitions(projectPath, states);
+    const confTransitions = transitions.filter(t => t.topologyConfirmed);
+    console.log(`   ${transitions.length} transitions (${confTransitions.length} topology-confirmed)`);
+    // L3: State Machine Assembly
+    console.log("\nL3 · State Machine Assembly...");
+    const machines = assembleMachines(states, transitions);
+    console.log(`   ${machines.length} state machines assembled`);
+    for (const m of machines) {
+        console.log(`\n   🏗️  ${m.entity} State Machine [confidence: ${m.confidence}%]`);
+        console.log(`      States: ${m.states.join(" → ")}`);
+        console.log(`      Initial: ${m.initialState} | Terminal: ${m.terminalStates.join(", ") || "(none)"}`);
+        console.log(`      Coverage: ${m.coverage}% (${m.validTransitions.length} observed / ${m.validTransitions.length + m.invalidTransitions.length} possible)`);
+        if (m.transitions.length > 0) {
+            console.log(`      Transitions:`);
+            for (const t of m.transitions.slice(0, 5)) {
+                console.log(`        ${t.from.padEnd(15)} → ${t.to.padEnd(15)} via ${t.viaFunction} [${t.confidence}%]`);
+            }
+        }
+        // Show violations this machine would catch
+        if (m.invalidTransitions.length > 0) {
+            console.log(`      Would catch these violations:`);
+            for (const inv of m.invalidTransitions.slice(0, 3)) {
+                console.log(`        ❌ ${inv} — would be blocked`);
+            }
+        }
+    }
+    const report = {
+        projectPath,
+        timestamp: new Date().toISOString(),
+        states,
+        transitions,
+        machines,
+        summary: {
+            statesFound: states.length,
+            transitionsFound: transitions.length,
+            machinesFound: machines.length,
+            completeMachines: machines.filter(m => m.coverage >= 50).length,
+        },
+    };
+    return report;
+}
+// ══════════════════════════════════════════════
+// CLI
+// ══════════════════════════════════════════════
+if (require.main === module) {
+    const targetProject = process.argv[2];
+    if (!targetProject) {
+        console.error("Usage: npx ts-node src/state-miner.ts <project-path>");
+        process.exit(1);
+    }
+    const report = mineStates(targetProject);
+    const outputPath = path.join(targetProject, ".progmune_state_machines.json");
+    fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+    console.log(`\n✅ State machines saved to: ${outputPath}`);
+    console.log("\n═══ State Mining Summary ═══");
+    console.log(`  States:       ${report.summary.statesFound}`);
+    console.log(`  Transitions:  ${report.summary.transitionsFound}`);
+    console.log(`  Machines:     ${report.summary.machinesFound} (${report.summary.completeMachines} complete)`);
+    console.log();
+}

package/dist/state-name-inference.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * P6.8: State Name Semantic Inference
+ *
+ * Maps synthesized generic state names (C0_S1, C1_S2) to
+ * hand-written semantic names (FILE_OPEN, DB_CONNECTED, etc.)
+ * using action signature matching.
+ *
+ * Approach:
+ *   1. Build a "dictionary" of hand-written states with their
+ *      action signatures (inbound + outbound function sets).
+ *   2. For each synthesized state, compute Jaccard similarity
+ *      against all hand-written state signatures.
+ *   3. Map to the best-matching semantic name.
+ *   4. Replace generic names in synthesized rules.
+ *
+ * Target: bootstrap function overlap 12% → 60%+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignSynthesizedProtocols = alignSynthesizedProtocols;
+exports.runStateAlignment = runStateAlignment;
+exports.printAlignmentReport = printAlignmentReport;
+const protocol_coverage_1 = require("./protocol-coverage");
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+const bootstrap_validation_1 = require("./bootstrap-validation");
+/** Build state signatures from protocol rules. */
+function buildStateSignatures(rules) {
+    const sigs = [];
+    const seen = new Set();
+    for (const [fn, rule] of rules) {
+        // For each post_state, record fn as inbound
+        for (const ps of rule.post_states) {
+            if (ps.length === 0 || seen.has(ps))
+                continue;
+            seen.add(ps);
+            const inbound = new Set();
+            const outbound = new Set();
+            // Find all functions that produce this state (inbound)
+            for (const [otherFn, otherRule] of rules) {
+                if (otherRule.post_states.includes(ps))
+                    inbound.add(otherFn);
+                if (otherRule.pre_states.includes(ps))
+                    outbound.add(otherFn);
+            }
+            if (inbound.size > 0 || outbound.size > 0) {
+                sigs.push({ name: ps, inbound, outbound });
+            }
+        }
+        // Also add pre_states as signatures
+        for (const ps of rule.pre_states) {
+            if (ps.length === 0 || seen.has(ps))
+                continue;
+            seen.add(ps);
+            const inbound = new Set();
+            const outbound = new Set();
+            for (const [otherFn, otherRule] of rules) {
+                if (otherRule.post_states.includes(ps))
+                    inbound.add(otherFn);
+                if (otherRule.pre_states.includes(ps))
+                    outbound.add(otherFn);
+            }
+            if (inbound.size > 0 || outbound.size > 0) {
+                sigs.push({ name: ps, inbound, outbound });
+            }
+        }
+    }
+    return sigs;
+}
+// ═══════════════════════════════════════════════════════════════
+// Jaccard Similarity
+// ═══════════════════════════════════════════════════════════════
+function jaccard(a, b) {
+    const intersection = [...a].filter(x => b.has(x)).length;
+    const union = new Set([...a, ...b]).size;
+    return union > 0 ? intersection / union : 0;
+}
+/**
+ * Find the best semantic name for a synthetic state.
+ *
+ * Computes Jaccard similarity between the synthetic state's
+ * action signature and each hand-written state's signature.
+ * Returns the name with the highest combined similarity.
+ */
+function inferStateName(syntheticState, synthRules, handSignatures) {
+    // Build action signature for this synthetic state
+    const inbound = new Set();
+    const outbound = new Set();
+    for (const sr of synthRules) {
+        if (sr.post_states.includes(syntheticState))
+            inbound.add(sr.function);
+        if (sr.pre_states.includes(syntheticState))
+            outbound.add(sr.function);
+    }
+    // Fallback: try to derive name from function names
+    if (inbound.size === 0 && outbound.size === 0) {
+        return syntheticState; // keep original
+    }
+    let bestName = syntheticState;
+    let bestScore = 0;
+    for (const hs of handSignatures) {
+        const inSim = jaccard(inbound, hs.inbound);
+        const outSim = jaccard(outbound, hs.outbound);
+        const score = inSim * 0.5 + outSim * 0.5;
+        if (score > bestScore && score > 0.1) {
+            bestScore = score;
+            bestName = hs.name;
+        }
+    }
+    // If no good match found, try name-based inference
+    if (bestName === syntheticState) {
+        const allActions = [...inbound, ...outbound];
+        const prefixes = allActions.map(fn => {
+            const parts = fn.split("_");
+            // Extract domain prefix: "DB_Open" → "DB", "open_file" → "FILE"
+            if (parts.length > 1)
+                return parts[0].toUpperCase();
+            return "";
+        }).filter(p => p.length > 0);
+        if (prefixes.length > 0) {
+            // Most common prefix becomes the state name prefix
+            const prefixCounts = new Map();
+            for (const p of prefixes) {
+                prefixCounts.set(p, (prefixCounts.get(p) || 0) + 1);
+            }
+            const topPrefix = [...prefixCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+            bestName = `${topPrefix}_${syntheticState.replace(/C\d+_/, "")}`;
+        }
+    }
+    return bestName;
+}
+// ═══════════════════════════════════════════════════════════════
+// Protocol Alignment
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Align synthesized protocol rules with hand-written state names.
+ *
+ * Replaces generic state names (C0_S1) with semantically meaningful
+ * names inferred from action context.
+ */
+function alignSynthesizedProtocols(synthesized, handRules) {
+    const handSigs = buildStateSignatures(handRules);
+    return synthesized.map(sp => {
+        const allSynthRules = sp.rules;
+        const stateMap = new Map();
+        // Map each synthetic state to its best semantic name
+        const allStates = new Set();
+        for (const sr of allSynthRules) {
+            for (const s of sr.pre_states)
+                if (s !== "INIT")
+                    allStates.add(s);
+            for (const s of sr.post_states)
+                if (s !== "INIT")
+                    allStates.add(s);
+        }
+        for (const s of allStates) {
+            stateMap.set(s, inferStateName(s, allSynthRules, handSigs));
+        }
+        // Replace state names in rules
+        const alignedRules = allSynthRules.map(sr => ({
+            ...sr,
+            pre_states: sr.pre_states.map(s => s === "INIT" ? "INIT" : (stateMap.get(s) || s)),
+            post_states: sr.post_states.map(s => (stateMap.get(s) || s)),
+            invalidate: sr.invalidate?.map(s => (stateMap.get(s) || s)),
+        }));
+        return { ...sp, rules: alignedRules };
+    });
+}
+/**
+ * Run the full state name alignment pipeline and measure bootstrap improvement.
+ */
+async function runStateAlignment() {
+    // Baseline
+    const baseline = await (0, bootstrap_validation_1.runBootstrapValidation)();
+    const beforeOverlap = baseline.functionOverlap;
+    // Get synthesized protocols
+    const synthesized = (0, auto_protocol_synthesizer_1.synthesizeAllKnownProtocols)();
+    // Get hand-written rules
+    const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const handRules = new Map();
+    for (const p of defs)
+        for (const [fn, rule] of p.rules)
+            handRules.set(fn, rule);
+    // Align
+    const aligned = alignSynthesizedProtocols(synthesized, handRules);
+    // Count state alignments
+    let statesAligned = 0;
+    for (let i = 0; i < synthesized.length; i++) {
+        const orig = synthesized[i];
+        const algn = aligned[i];
+        for (let j = 0; j < orig.rules.length; j++) {
+            if (orig.rules[j].post_states[0] !== algn.rules[j].post_states[0]) {
+                statesAligned++;
+            }
+        }
+    }
+    // Re-run bootstrap (uses the aligned rules via synthesizeAllKnownProtocols)
+    const after = await (0, bootstrap_validation_1.runBootstrapValidation)();
+    const afterOverlap = after.functionOverlap;
+    return {
+        beforeOverlap,
+        afterOverlap,
+        improvement: afterOverlap - beforeOverlap,
+        statesAligned,
+    };
+}
+function printAlignmentReport(report) {
+    console.log("\n─── P6.8 State Name Alignment ───");
+    console.log(`  States Aligned:    ${report.statesAligned}`);
+    console.log(`  Before Overlap:    ${(report.beforeOverlap * 100).toFixed(0)}%`);
+    console.log(`  After Overlap:     ${(report.afterOverlap * 100).toFixed(0)}%`);
+    console.log(`  Improvement:       ${(report.improvement > 0 ? "+" : "")}${(report.improvement * 100).toFixed(0)}%`);
+    console.log();
+}

package/dist/state-name-inference.test.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * P6.8: State Name Inference Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const state_name_inference_1 = require("./state-name-inference");
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+const protocol_coverage_1 = require("./protocol-coverage");
+(0, vitest_1.describe)("P6.8 State Name Inference", () => {
+    (0, vitest_1.it)("synthesizer generates semantic state names (integrated pipeline)", () => {
+        // Use the integrated synthesizer which now calls inferStateName internally
+        const protocols = (0, auto_protocol_synthesizer_1.synthesizeAllKnownProtocols)();
+        (0, vitest_1.expect)(protocols.length).toBeGreaterThan(0);
+        for (const sp of protocols) {
+            for (const sr of sp.rules) {
+                // Post states should NOT be generic C0_S1 format
+                for (const ps of sr.post_states) {
+                    if (ps !== "INIT" && !ps.includes("_DONE")) {
+                        // Semantic names come from inferStateName: FILE_OPEN, DB_CONNECTED, etc.
+                        // or name-derived: DB_S1 (when no hand-written match found)
+                        (0, vitest_1.expect)(ps).not.toMatch(/^C\d+_S\d+$/);
+                    }
+                }
+                // Last rule's invalidate should contain semantic state names
+                if (sr.invalidate && sr.invalidate.length > 1) {
+                    const hasSemantic = sr.invalidate.some(s => s.includes("_OPEN") || s.includes("_CLOSED") || s.includes("_CONNECTED") ||
+                        s.includes("_VERIFIED") || s.includes("_ISSUED") || s.includes("_CREATED") ||
+                        s.includes("_PRODUCED") || s.includes("_COMPLETED") || s.includes("_READY"));
+                    (0, vitest_1.expect)(hasSemantic).toBe(true);
+                }
+            }
+        }
+    });
+    (0, vitest_1.it)("aligned states use semantically meaningful names", () => {
+        const dbSynth = {
+            clusterId: "DB",
+            prototype: ["open_file", "write_file", "close_file"],
+            rules: [
+                { function: "open_file", pre_states: ["INIT"], post_states: ["DB_S1"] },
+                { function: "write_file", pre_states: ["DB_S1"], post_states: ["DB_S2"] },
+                { function: "close_file", pre_states: ["DB_S2"], post_states: ["DB_DONE"], invalidate: ["DB_S1", "DB_S2"] },
+            ],
+            stateCount: 4,
+            inferredPattern: "RESOURCE_ACQUIRE",
+            confidence: 1.0,
+        };
+        const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+        const handRules = new Map();
+        for (const p of defs)
+            for (const [fn, rule] of p.rules)
+                handRules.set(fn, rule);
+        const aligned = (0, state_name_inference_1.alignSynthesizedProtocols)([dbSynth], handRules);
+        const rules = aligned[0].rules;
+        // open_file's post_state → FILE_OPEN (matches hand-written open_file rule)
+        (0, vitest_1.expect)(rules[0].post_states[0]).toBe("FILE_OPEN");
+        // close_file: should invalidate FILE_OPEN (matches hand-written close_file invalidation)
+        const closeRule = rules[2];
+        (0, vitest_1.expect)(closeRule.invalidate).toBeDefined();
+        (0, vitest_1.expect)(closeRule.invalidate.some(s => s.includes("FILE_OPEN") || s.includes("FILE_CLOSED"))).toBe(true);
+    });
+    (0, vitest_1.it)("full alignment pipeline improves bootstrap overlap", async () => {
+        const report = await (0, state_name_inference_1.runStateAlignment)();
+        (0, vitest_1.expect)(report.statesAligned).toBeGreaterThan(0);
+        // Alignment should maintain or improve function overlap
+        (0, vitest_1.expect)(report.afterOverlap).toBeGreaterThanOrEqual(report.beforeOverlap);
+        (0, state_name_inference_1.printAlignmentReport)(report);
+    }, 30000);
+});