progmune-runtime 2.1.5 → 3.2.0

package/dist/unknown-protocol-discovery.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * P8.2: Unknown Protocol Discovery — Zero-Shot Transfer
+ *
+ * The decisive test for protocol structure learning:
+ *   1. Train on known repos (Redis, SQLite)
+ *   2. Discover protocols in an UNSEEN repo (PostgreSQL)
+ *   3. Repair defects using ONLY discovered knowledge
+ *
+ * Success = the system can understand code it has NEVER seen before.
+ * This is the bridge from "protocol library" to "software world model."
+ *
+ * Pipeline:
+ *   Known repos → state machine fingerprints → fingerprint library
+ *   Unknown repo → extract sequences → cluster → synthesize → state machine
+ *   Match unknown state machines against known library → transfer or infer
+ *
+ * North star metric: zero-shot repair success rate on unseen repos.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKnownFingerprintLibrary = buildKnownFingerprintLibrary;
+exports.extractUnknownRepoSequences = extractUnknownRepoSequences;
+exports.discoverProtocolsFromSequences = discoverProtocolsFromSequences;
+exports.evaluateZeroShotRepair = evaluateZeroShotRepair;
+exports.runZeroShotDiscovery = runZeroShotDiscovery;
+exports.printZeroShotResult = printZeroShotResult;
+const state_machine_fingerprint_1 = require("./state-machine-fingerprint");
+const unsupervised_physics_1 = require("./experimental/unsupervised-physics");
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+const protocol_frontier_1 = require("./protocol-frontier");
+const protocol_coverage_1 = require("./protocol-coverage");
+// ═══════════════════════════════════════════════════════════════
+// Step 1: Build known fingerprint library
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Build a fingerprint library from known protocol groups.
+ * Each entry maps a protocol name to its state machine fingerprint.
+ */
+function buildKnownFingerprintLibrary() {
+    const defs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const library = new Map();
+    for (const p of defs) {
+        if (p.rules.size === 0)
+            continue;
+        library.set(p.name, (0, state_machine_fingerprint_1.extractStateMachine)(p.rules));
+    }
+    return library;
+}
+// ═══════════════════════════════════════════════════════════════
+// Step 2: Extract call sequences from an unknown repo
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Extract raw call sequences from a repo by name.
+ * Uses CROSS_REPO_SEQUENCES as the data source.
+ */
+function extractUnknownRepoSequences(repoName) {
+    return unsupervised_physics_1.CROSS_REPO_SEQUENCES[repoName] || [];
+}
+// ═══════════════════════════════════════════════════════════════
+// Step 3: Discover protocols from raw sequences
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Discover protocols from raw call sequences using P8.1 state machine fingerprints.
+ *
+ * Algorithm:
+ *   1. Synthesize protocol rules from sequences via auto-protocol-synthesizer
+ *   2. Build name-free state machine fingerprints from synthesized rules
+ *   3. Match against known fingerprint library
+ *   4. Return discovered protocols with transfer annotations
+ */
+function discoverProtocolsFromSequences(sequences, repoName, knownLibrary) {
+    if (sequences.length === 0)
+        return [];
+    // 1. Synthesize protocol rules from sequences (P6.4)
+    const synthesized = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(sequences);
+    if (synthesized.length === 0) {
+        // Fallback: create a simple linear chain synthesization
+        return [buildFallbackProtocol(sequences, repoName, knownLibrary)];
+    }
+    const discovered = [];
+    for (const synth of synthesized) {
+        // 2. Convert synthesized rules to StateAnnotation map for fingerprint extraction
+        const ruleMap = new Map();
+        for (const r of synth.rules) {
+            ruleMap.set(r.function, {
+                pre_states: r.pre_states,
+                post_states: r.post_states,
+                invalidate: r.invalidate,
+            });
+        }
+        // 3. Extract name-free state machine fingerprint
+        const fingerprint = (0, state_machine_fingerprint_1.extractStateMachine)(ruleMap);
+        // 4. Match against known library
+        let closestKnown;
+        let matchConfidence = 0;
+        if (knownLibrary && knownLibrary.size > 0) {
+            for (const [name, knownFp] of knownLibrary) {
+                const comp = (0, state_machine_fingerprint_1.compareStateMachines)(fingerprint, knownFp);
+                if (comp.similarity > matchConfidence) {
+                    matchConfidence = comp.similarity;
+                    closestKnown = name;
+                }
+            }
+        }
+        discovered.push({
+            name: `${repoName}_${synth.clusterId}`,
+            fingerprint,
+            rules: synth.rules,
+            prototype: synth.prototype,
+            closestKnown,
+            matchConfidence: Math.round(matchConfidence * 10000) / 10000,
+        });
+    }
+    return discovered;
+}
+/** Fallback: build a simple protocol from sequences when synthesizer fails. */
+function buildFallbackProtocol(sequences, repoName, knownLibrary) {
+    // Find the most common pattern: longest common subsequence
+    const prototype = sequences.reduce((a, b) => a.length >= b.length ? a : b, sequences[0] || []);
+    const rules = prototype.map((fn, i) => ({
+        function: fn,
+        pre_states: i === 0 ? [] : [`STATE_${i - 1}`],
+        post_states: i < prototype.length - 1 ? [`STATE_${i}`] : [],
+        invalidate: i === prototype.length - 1 ? [`STATE_${i - 1}`] : undefined,
+    }));
+    const ruleMap = new Map();
+    for (const r of rules) {
+        ruleMap.set(r.function, {
+            pre_states: r.pre_states,
+            post_states: r.post_states,
+            invalidate: r.invalidate,
+        });
+    }
+    const fingerprint = (0, state_machine_fingerprint_1.extractStateMachine)(ruleMap);
+    let closestKnown;
+    let matchConfidence = 0;
+    if (knownLibrary) {
+        for (const [name, knownFp] of knownLibrary) {
+            const comp = (0, state_machine_fingerprint_1.compareStateMachines)(fingerprint, knownFp);
+            if (comp.similarity > matchConfidence) {
+                matchConfidence = comp.similarity;
+                closestKnown = name;
+            }
+        }
+    }
+    return {
+        name: `${repoName}_fallback`,
+        fingerprint,
+        rules,
+        prototype,
+        closestKnown,
+        matchConfidence: Math.round(matchConfidence * 10000) / 10000,
+    };
+}
+/**
+ * Attempt zero-shot repair using discovered protocol knowledge.
+ *
+ * For each defect case:
+ *   1. Build a state machine from the discovered protocol's rules
+ *   2. Use frontier exploration to find a path from the broken state to the expected completion
+ *   3. Check if any discovered fix path covers the missing steps
+ *
+ * @returns { success, total } counts for repair rate calculation
+ */
+function evaluateZeroShotRepair(discovered, defectCases) {
+    let success = 0;
+    const details = [];
+    for (const defect of defectCases) {
+        let repaired = false;
+        for (const proto of discovered) {
+            // Build rule map from discovered protocol
+            const rules = new Map();
+            for (const r of proto.rules) {
+                rules.set(r.function, {
+                    pre_states: r.pre_states,
+                    post_states: r.post_states,
+                    invalidate: r.invalidate,
+                });
+            }
+            if (rules.size === 0)
+                continue;
+            // Build reverse index: for each function in the discovered rules,
+            // find the closest matching function in the defect by edit distance.
+            // This bridges the name gap between original names and normalized names.
+            const ruleFns = [...rules.keys()];
+            const defectFns = new Set([...defect.broken, ...defect.expected]);
+            const nameMap = new Map(); // defect name → rule name
+            for (const dfn of defectFns) {
+                let bestFn = "";
+                let bestDist = Infinity;
+                const lower = dfn.toLowerCase();
+                for (const rfn of ruleFns) {
+                    // Simple substring match first, then edit distance
+                    if (lower.includes(rfn) || rfn.includes(lower)) {
+                        bestFn = rfn;
+                        break;
+                    }
+                    const dist = levenshtein(lower, rfn);
+                    if (dist < bestDist) {
+                        bestDist = dist;
+                        bestFn = rfn;
+                    }
+                }
+                if (bestFn)
+                    nameMap.set(dfn, bestFn);
+            }
+            // Map broken sequence through the name map
+            const mappedBroken = defect.broken.map(fn => nameMap.get(fn) || fn);
+            const mappedExpected = defect.expected.map(fn => nameMap.get(fn) || fn);
+            // Simulate state machine with mapped sequence
+            // Initialize with namespace initial states (INIT is the universal default)
+            const currentStates = new Set(["INIT"]);
+            for (const fn of mappedBroken) {
+                const rule = rules.get(fn);
+                if (!rule)
+                    continue;
+                if (!rule.pre_states.every(s => currentStates.has(s)) && rule.pre_states.length > 0)
+                    continue;
+                if (rule.invalidate)
+                    rule.invalidate.forEach(s => currentStates.delete(s));
+                for (const s of rule.post_states)
+                    currentStates.add(s);
+            }
+            // Frontier exploration for completion paths
+            const paths = (0, protocol_frontier_1.exploreFrontier)(rules, [...currentStates], 20, 8);
+            // Check if any path + broken covers the expected (using mapped names)
+            for (const path of paths) {
+                const full = [...mappedBroken, ...path];
+                const allExpected = mappedExpected.every(fn => full.includes(fn));
+                if (allExpected && path.length > 0) {
+                    repaired = true;
+                    details.push(`${defect.description}: ✅ via ${proto.name} (${path.join(" → ")})`);
+                    break;
+                }
+            }
+            if (repaired)
+                break;
+        }
+        if (!repaired) {
+            details.push(`${defect.description}: ❌`);
+        }
+        if (repaired)
+            success++;
+    }
+    return { success, total: defectCases.length, details };
+}
+/** Levenshtein edit distance between two strings. */
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+// ═══════════════════════════════════════════════════════════════
+// Full Pipeline
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Run the full zero-shot discovery pipeline:
+ *   1. Build known library from TRAIN repos
+ *   2. Discover protocols in TEST repo
+ *   3. Evaluate zero-shot repair
+ *
+ * @param trainRepos  Repos used to build the known fingerprint library
+ * @param testRepo    Unseen repo for zero-shot discovery
+ * @param defectCases Defect cases to test repair on
+ */
+function runZeroShotDiscovery(trainRepos, testRepo, defectCases) {
+    // 1. Build known fingerprint library from train repos
+    const knownLibrary = new Map();
+    for (const repo of trainRepos) {
+        const seqs = extractUnknownRepoSequences(repo);
+        if (seqs.length === 0)
+            continue;
+        // Discover protocols in training repos
+        const trainDiscovered = discoverProtocolsFromSequences(seqs, repo, undefined);
+        for (const proto of trainDiscovered) {
+            knownLibrary.set(proto.name, proto.fingerprint);
+        }
+    }
+    // Add hand-written protocol fingerprints to the library
+    const handWritten = buildKnownFingerprintLibrary();
+    for (const [name, fp] of handWritten) {
+        knownLibrary.set(name, fp);
+    }
+    // 2. Discover protocols in test repo (zero-shot)
+    const testSeqs = extractUnknownRepoSequences(testRepo);
+    const discovered = discoverProtocolsFromSequences(testSeqs, testRepo, knownLibrary);
+    // 3. Evaluate zero-shot repair
+    const repairResult = evaluateZeroShotRepair(discovered, defectCases);
+    return {
+        discoveredCount: discovered.length,
+        discovered,
+        repairSuccess: repairResult.success,
+        repairTotal: repairResult.total,
+        repairRate: repairResult.total > 0 ? repairResult.success / repairResult.total : 0,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Reporting
+// ═══════════════════════════════════════════════════════════════
+function printZeroShotResult(result) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P8.2 Unknown Protocol Discovery — Zero-Shot      ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`  Discovered: ${result.discoveredCount} protocol(s)`);
+    for (const proto of result.discovered) {
+        console.log(`\n  ── ${proto.name} ──`);
+        console.log(`    Prototype:      ${proto.prototype.join(" → ")}`);
+        console.log(`    States:         ${proto.fingerprint.stateCount}`);
+        console.log(`    Transitions:    ${proto.fingerprint.transitions.length}`);
+        console.log(`    Entry points:   ${proto.fingerprint.entryStates.length}`);
+        console.log(`    Exit points:    ${proto.fingerprint.exitStates.length}`);
+        console.log(`    Branch states:  ${proto.fingerprint.branchStates.length}`);
+        console.log(`    DAG:            ${proto.fingerprint.isDAG}`);
+        if (proto.closestKnown) {
+            console.log(`    Closest known:  ${proto.closestKnown} (${(proto.matchConfidence * 100).toFixed(0)}%)`);
+        }
+        else {
+            console.log(`    Closest known:  none (novel protocol)`);
+        }
+    }
+    console.log(`\n  ── Zero-Shot Repair ──`);
+    console.log(`    Success: ${result.repairSuccess}/${result.repairTotal}`);
+    console.log(`    Rate:    ${(result.repairRate * 100).toFixed(0)}%`);
+    const verdict = result.repairRate > 0.5
+        ? "✅ ZERO-SHOT TRANSFER ACHIEVED"
+        : result.repairRate > 0
+            ? "⚠️  PARTIAL — structure signal present but repair gap remains"
+            : "❌ No transfer — protocol structure not yet generalizing";
+    console.log(`    Verdict: ${verdict}\n`);
+}

package/dist/unknown-protocol-discovery.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * P8.2: Unknown Protocol Discovery Tests
+ *
+ * Zero-shot transfer: train on Redis+SQLite, test on PostgreSQL.
+ * The system must discover protocol structure in an UNSEEN repo
+ * and repair defects using only discovered knowledge.
+ */
+const vitest_1 = require("vitest");
+const unknown_protocol_discovery_1 = require("./unknown-protocol-discovery");
+const unsupervised_physics_1 = require("./experimental/unsupervised-physics");
+(0, vitest_1.describe)("P8.2 Unknown Protocol Discovery", () => {
+    (0, vitest_1.it)("extracts sequences from known repos", () => {
+        const redis = (0, unknown_protocol_discovery_1.extractUnknownRepoSequences)("Redis");
+        const sqlite = (0, unknown_protocol_discovery_1.extractUnknownRepoSequences)("SQLite");
+        const pg = (0, unknown_protocol_discovery_1.extractUnknownRepoSequences)("PostgreSQL");
+        (0, vitest_1.expect)(redis.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(sqlite.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(pg.length).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("builds known fingerprint library from protocols.json", () => {
+        const library = (0, unknown_protocol_discovery_1.buildKnownFingerprintLibrary)();
+        (0, vitest_1.expect)(library.size).toBeGreaterThanOrEqual(8);
+        (0, vitest_1.expect)(library.has("AuthProtocol")).toBe(true);
+        (0, vitest_1.expect)(library.has("FileProtocol")).toBe(true);
+    });
+    (0, vitest_1.it)("discovers protocols from unseen repo sequences", () => {
+        const seqs = (0, unknown_protocol_discovery_1.extractUnknownRepoSequences)("PostgreSQL");
+        const known = (0, unknown_protocol_discovery_1.buildKnownFingerprintLibrary)();
+        const discovered = (0, unknown_protocol_discovery_1.discoverProtocolsFromSequences)(seqs, "PostgreSQL", known);
+        (0, vitest_1.expect)(discovered.length).toBeGreaterThan(0);
+        for (const proto of discovered) {
+            (0, vitest_1.expect)(proto.fingerprint.stateCount).toBeGreaterThan(0);
+            (0, vitest_1.expect)(proto.prototype.length).toBeGreaterThan(0);
+        }
+    });
+    (0, vitest_1.it)("clusters structurally identical repos together (Redis ↔ SQLite)", () => {
+        const known = (0, unknown_protocol_discovery_1.buildKnownFingerprintLibrary)();
+        const redisDiscovered = (0, unknown_protocol_discovery_1.discoverProtocolsFromSequences)(unsupervised_physics_1.CROSS_REPO_SEQUENCES["Redis"], "Redis", known);
+        const sqliteDiscovered = (0, unknown_protocol_discovery_1.discoverProtocolsFromSequences)(unsupervised_physics_1.CROSS_REPO_SEQUENCES["SQLite"], "SQLite", known);
+        // Both Redis and SQLite should match the same known protocol family
+        // (both are acquire→use→release chains)
+        const redisMatch = redisDiscovered[0]?.closestKnown;
+        const sqliteMatch = sqliteDiscovered[0]?.closestKnown;
+        console.log(`  Redis closest:    ${redisMatch || "none"}`);
+        console.log(`  SQLite closest:   ${sqliteMatch || "none"}`);
+        // They should both match to FileProtocol or DBProtocol (resource lifecycle)
+        (0, vitest_1.expect)(redisMatch).toBeTruthy();
+        (0, vitest_1.expect)(sqliteMatch).toBeTruthy();
+    });
+    (0, vitest_1.it)("ZERO-SHOT: PostgreSQL defects repaired using Redis+SQLite knowledge", () => {
+        // Train on Redis + SQLite (known repos)
+        const trainRepos = ["Redis", "SQLite"];
+        // Test: PostgreSQL defects
+        // Common PG defects: missing commit, missing disconnect, missing begin
+        const defectCases = [
+            {
+                broken: ["PQconnectdb", "PQexec"],
+                expected: ["PQconnectdb", "PQexec", "PQfinish"],
+                description: "PG: missing disconnect after query",
+            },
+            {
+                broken: ["begin_transaction", "execute_query"],
+                expected: ["begin_transaction", "execute_query", "commit_transaction"],
+                description: "PG: missing commit after execute",
+            },
+            {
+                broken: ["PQconnectdb"],
+                expected: ["PQconnectdb", "PQexec", "PQfinish"],
+                description: "PG: only connect, no query or finish",
+            },
+            {
+                broken: ["PQconnectdb", "begin_transaction"],
+                expected: ["PQconnectdb", "begin_transaction", "execute_query", "commit_transaction", "PQfinish"],
+                description: "PG: full lifecycle missing middle+end",
+            },
+        ];
+        const result = (0, unknown_protocol_discovery_1.runZeroShotDiscovery)(trainRepos, "PostgreSQL", defectCases);
+        (0, unknown_protocol_discovery_1.printZeroShotResult)(result);
+        // Discovery: should find at least 1 protocol
+        (0, vitest_1.expect)(result.discoveredCount).toBeGreaterThan(0);
+        // Zero-shot repair: should repair at least SOME defects
+        // (PG sequences are structurally similar to Redis/SQLite acquire→use→release)
+        (0, vitest_1.expect)(result.repairRate).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("CROSS-REPO: all 5 repos discoverable with cluster transfer", () => {
+        const known = (0, unknown_protocol_discovery_1.buildKnownFingerprintLibrary)();
+        const repos = Object.keys(unsupervised_physics_1.CROSS_REPO_SEQUENCES);
+        console.log(`\n  Cross-repo discovery (${repos.length} repos):`);
+        console.log(`  ${'Repo'.padEnd(14)} ${'Discovered'.padEnd(12)} ${'Closest Known'.padEnd(22)} ${'Confidence'}`);
+        console.log(`  ${'─'.repeat(65)}`);
+        for (const repo of repos) {
+            const seqs = unsupervised_physics_1.CROSS_REPO_SEQUENCES[repo];
+            const discovered = (0, unknown_protocol_discovery_1.discoverProtocolsFromSequences)(seqs, repo, known);
+            const top = discovered[0];
+            console.log(`  ${repo.padEnd(14)} ${String(discovered.length).padEnd(12)} ` +
+                `${(top?.closestKnown || "novel").padEnd(22)} ${top ? (top.matchConfidence * 100).toFixed(0) + '%' : 'N/A'}`);
+            (0, vitest_1.expect)(discovered.length).toBeGreaterThan(0);
+        }
+    });
+});

package/dist/unsupervised-physics.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * P6.3: Unsupervised Physics Discovery
+ *
+ * Discovers protocol patterns WITHOUT hand-crafted keywords.
+ * Input: raw call sequences. Output: structural clusters.
+ *
+ * The test: if the system clusters [open,read,close] with
+ * [connect,query,disconnect] WITHOUT knowing the function names,
+ * it has genuinely learned the Acquire→Use→Release pattern.
+ *
+ * Algorithm:
+ *   1. Extract structural fingerprints from call sequences
+ *   2. Cluster by structural similarity (no keyword matching)
+ *   3. Compare discovered clusters to known physics patterns
+ *   4. Measure: are Acquire/Release clusters emergent?
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CROSS_REPO_SEQUENCES = void 0;
+exports.fingerprint = fingerprint;
+exports.fingerprintSequences = fingerprintSequences;
+exports.clusterByStructure = clusterByStructure;
+exports.evaluateUnsupervisedDiscovery = evaluateUnsupervisedDiscovery;
+exports.runUnsupervisedDiscovery = runUnsupervisedDiscovery;
+exports.printUnsupervisedReport = printUnsupervisedReport;
+/**
+ * Extract structural fingerprint from a function in context.
+ * Uses ONLY positional and structural features — NO function names.
+ */
+function fingerprint(fn, index, sequence) {
+    const uniqueFns = new Set(sequence);
+    // Check if sequence forms a closed loop: first and last functions
+    // have structural similarity (both are single-occurrence "boundary" functions)
+    const firstFn = sequence[0];
+    const lastFn = sequence[sequence.length - 1];
+    const firstCount = sequence.filter(f => f === firstFn).length;
+    const lastCount = sequence.filter(f => f === lastFn).length;
+    // Closed loop: first and last are "boundary" functions (appear only once)
+    const isClosedLoop = firstCount === 1 && lastCount === 1 && sequence.length >= 2;
+    return {
+        seqId: sequence.join("→"),
+        length: sequence.length,
+        position: index / Math.max(1, sequence.length - 1),
+        isFirst: index === 0,
+        isLast: index === sequence.length - 1,
+        isClosedLoop,
+        uniqueCount: uniqueFns.size,
+        phase: index === 0 ? 0 : index === sequence.length - 1 ? 2 : 1,
+    };
+}
+/**
+ * Build fingerprints for all functions in a set of sequences.
+ */
+function fingerprintSequences(sequences) {
+    const fps = new Map();
+    for (const seq of sequences) {
+        for (let i = 0; i < seq.length; i++) {
+            const fp = fingerprint(seq[i], i, seq);
+            fps.set(`${seq[i]}@${i}`, fp);
+        }
+    }
+    return fps;
+}
+/**
+ * Cluster sequences by structural similarity ONLY.
+ * No function names. No keywords. Pure topology.
+ */
+function clusterByStructure(sequences) {
+    const features = sequences.map(seq => {
+        const uniqueFns = new Set(seq);
+        const firstFn = seq[0];
+        const lastFn = seq[seq.length - 1];
+        const firstCount = seq.filter(f => f === firstFn).length;
+        const lastCount = seq.filter(f => f === lastFn).length;
+        const closedLoop = firstCount === 1 && lastCount === 1 && seq.length >= 2;
+        // Phase profile: how many functions are at each phase
+        const profile = [0, 0, 0];
+        for (let i = 0; i < seq.length; i++) {
+            const phase = i === 0 ? 0 : i === seq.length - 1 ? 2 : 1;
+            profile[phase]++;
+        }
+        return { seq, length: seq.length, closedLoop, uniqueCount: uniqueFns.size, phaseProfile: profile };
+    });
+    // Clustering: group by [length bucket, closedLoop, uniqueCount]
+    const clusters = new Map();
+    for (const f of features) {
+        const lenBucket = f.length <= 2 ? "short" : f.length <= 4 ? "medium" : "long";
+        const loopKey = f.closedLoop ? "closed" : "open";
+        const key = `${lenBucket}-${loopKey}-${f.uniqueCount}`;
+        if (!clusters.has(key))
+            clusters.set(key, []);
+        clusters.get(key).push(f);
+    }
+    // Convert to DiscoveredCluster
+    const results = [];
+    let id = 0;
+    for (const [key, members] of clusters) {
+        if (members.length < 1)
+            continue;
+        const avgLen = members.reduce((s, m) => s + m.length, 0) / members.length;
+        const closedRate = members.filter(m => m.closedLoop).length / members.length;
+        // Infer physics pattern based on STRUCTURE, not names
+        let inferredPattern;
+        if (closedRate > 0.5 && avgLen >= 3) {
+            inferredPattern = "RESOURCE_ACQUIRE"; // Acquire-Use-Release structure
+        }
+        else if (closedRate > 0.5 && avgLen === 2) {
+            inferredPattern = "LOCK_ACQUIRE"; // Lock-Unlock structure
+        }
+        results.push({
+            id: `C${id++}`,
+            sequences: members.map(m => m.seq),
+            avgLength: avgLen,
+            closedLoopRate: closedRate,
+            signature: key,
+            inferredPattern,
+        });
+    }
+    return results.sort((a, b) => b.sequences.length - a.sequences.length);
+}
+/**
+ * Evaluate whether structural clustering discovers physics patterns.
+ *
+ * This is the KEY test: input raw sequences, output clusters.
+ * If Acquire-Use-Release clusters emerge WITHOUT keyword matching,
+ * the system has genuinely learned protocol structure.
+ */
+function evaluateUnsupervisedDiscovery(sequences) {
+    const clusters = clusterByStructure(sequences);
+    // Check: do clusters match known physics patterns by STRUCTURE alone?
+    let structuralMatches = 0;
+    let sequencesInMatches = 0;
+    for (const c of clusters) {
+        if (c.inferredPattern) {
+            structuralMatches++;
+            sequencesInMatches += c.sequences.length;
+        }
+    }
+    const total = sequences.length;
+    const emergent = structuralMatches > 0 && sequencesInMatches / total > 0.5;
+    return {
+        totalSequences: total,
+        clusters,
+        structuralCoverage: clusters.length > 0 ? structuralMatches / clusters.length : 0,
+        sequenceCoverage: total > 0 ? sequencesInMatches / total : 0,
+        emergent,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+// Cross-Repo Unsupervised Benchmark
+// ═══════════════════════════════════════════════════════════════
+exports.CROSS_REPO_SEQUENCES = {
+    Redis: [
+        ["createClient", "sendCommand", "closeClient"],
+        ["selectDB", "getKey"],
+        ["createClient", "sendCommand", "readReply", "closeClient"],
+    ],
+    SQLite: [
+        ["sqlite3_open", "sqlite3_exec", "sqlite3_close"],
+        ["sqlite3_prepare", "sqlite3_step", "sqlite3_finalize"],
+        ["sqlite3_open", "sqlite3_prepare", "sqlite3_step", "sqlite3_finalize", "sqlite3_close"],
+    ],
+    nginx: [
+        ["ngx_accept_connection", "ngx_read_request", "ngx_close_connection"],
+        ["ngx_parse_headers", "ngx_send_response"],
+        ["ngx_accept_connection", "ngx_process_request", "ngx_send_response", "ngx_close_connection"],
+    ],
+    PostgreSQL: [
+        ["PQconnectdb", "PQexec", "PQfinish"],
+        ["begin_transaction", "execute_query", "commit_transaction"],
+        ["PQconnectdb", "begin_transaction", "execute_query", "commit_transaction", "PQfinish"],
+    ],
+    LevelDB: [
+        ["DB_Open", "DB_Get", "DB_Close"],
+        ["DB_Open", "DB_Put", "DB_Close"],
+        ["DB_Open", "DB_Write", "DB_Compact", "DB_Close"],
+    ],
+};
+/**
+ * Full unsupervised discovery across all known repos.
+ */
+function runUnsupervisedDiscovery() {
+    const perRepo = {};
+    const allSeqs = [];
+    for (const [repo, seqs] of Object.entries(exports.CROSS_REPO_SEQUENCES)) {
+        const eval_ = evaluateUnsupervisedDiscovery(seqs);
+        perRepo[repo] = eval_;
+        allSeqs.push(...seqs);
+    }
+    const allEval = evaluateUnsupervisedDiscovery(allSeqs);
+    const emergent = Object.values(perRepo).every(e => e.emergent);
+    return {
+        perRepo,
+        allSequences: allEval,
+        emergent,
+        summary: emergent
+            ? "ACQUIRE→USE→RELEASE clusters emerged WITHOUT keyword matching. Software Physics is REAL."
+            : "Structural clustering found some patterns, but not consistently across repos. More data needed.",
+    };
+}
+function printUnsupervisedReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P6.3 Unsupervised Physics Discovery              ║");
+    console.log("║   (NO keywords. NO function names. Pure topology.) ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Emergent Physics: ${report.emergent ? "✅ YES" : "❌ NO"}`);
+    console.log(`Summary: ${report.summary}`);
+    console.log();
+    console.log("─── Per-Repo Discovery ───");
+    console.log("Repo           Seqs  Clusters  StructCov  Emergent");
+    console.log("──────────────────────────────────────────────────");
+    for (const [repo, eval_] of Object.entries(report.perRepo)) {
+        const sc = (eval_.structuralCoverage * 100).toFixed(0).padStart(4);
+        const icon = eval_.emergent ? "✅" : "❌";
+        console.log(`  ${repo.padEnd(12)} ${String(eval_.totalSequences).padStart(4)}  ${String(eval_.clusters.length).padStart(8)}  ${sc}%      ${icon}`);
+    }
+    console.log();
+    console.log("─── Discovered Clusters ───");
+    for (const c of report.allSequences.clusters.slice(0, 10)) {
+        const pattern = c.inferredPattern || "unknown";
+        const closed = c.closedLoopRate > 0.5 ? "closed-loop" : "open";
+        console.log(`  ${c.id}: ${c.sequences.length} seqs, avgLen=${c.avgLength.toFixed(1)}, ${closed}, → ${pattern}`);
+        if (c.sequences.length <= 3) {
+            for (const s of c.sequences) {
+                console.log(`    ${s.join(" → ")}`);
+            }
+        }
+    }
+    console.log();
+}