progmune-runtime 2.1.6 → 3.2.0

package/dist/name-free-protocol.js

@@ -0,0 +1,425 @@
+"use strict";
+/**
+ * P8.0: Name-Free Protocol Learning
+ *
+ * Proves that protocol structure can be detected WITHOUT function names.
+ * Replaces keyword matching (open→ACQUIRE, close→RELEASE) with pure
+ * graph topology analysis derived from co-occurrence patterns in call sequences.
+ *
+ * Three-stage pipeline:
+ *   P8.0a: State Graph Extraction — build state transition graph from sequences
+ *   P8.0b: Topology Fingerprint — compute graph feature vector
+ *   P8.0c: Name Scramble Benchmark — measure survival rate under name removal
+ *
+ * Success criterion: Name Scramble Survival Rate > 0% (current: 0%).
+ * Target: 100% → >20% = first genuine evidence of structure learning.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractNameFreeStateGraph = extractNameFreeStateGraph;
+exports.computeTopologyFingerprint = computeTopologyFingerprint;
+exports.fingerprintToVector = fingerprintToVector;
+exports.fingerprintSimilarity = fingerprintSimilarity;
+exports.runNameScrambleBenchmark = runNameScrambleBenchmark;
+exports.runFullNameScrambleBenchmark = runFullNameScrambleBenchmark;
+exports.printNameScrambleReport = printNameScrambleReport;
+exports.printFullScrambleReport = printFullScrambleReport;
+const unsupervised_physics_1 = require("./experimental/unsupervised-physics");
+/**
+ * Extract a name-free state graph from a set of call sequences.
+ *
+ * The key insight: we DON'T look at function names. Instead we analyze:
+ *   1. Co-occurrence: which functions always appear together?
+ *   2. Ordering: which functions always precede others?
+ *   3. State inference: if f[i] always precedes f[j] and f[k] always follows f[j],
+ *      then f[i] PRODUCES a state, f[j] CONSUMES it, and f[k] INVALIDATES it.
+ *
+ * @param sequences  Array of call sequences (function name strings)
+ * @returns A NameFreeStateGraph with opaque state nodes
+ */
+function extractNameFreeStateGraph(sequences) {
+    // Step 1: Build function index (name → opaque index)
+    const fnIndex = new Map();
+    const fnList = [];
+    for (const seq of sequences) {
+        for (const fn of seq) {
+            if (!fnIndex.has(fn)) {
+                fnIndex.set(fn, fnList.length);
+                fnList.push(fn);
+            }
+        }
+    }
+    const N = fnList.length;
+    // Step 2: Build transition matrix (how often fn[i] → fn[j] appears consecutively)
+    const transitionMatrix = Array.from({ length: N }, () => new Array(N).fill(0));
+    const freq = new Array(N).fill(0);
+    for (const seq of sequences) {
+        for (let i = 0; i < seq.length; i++) {
+            const from = fnIndex.get(seq[i]);
+            freq[from]++;
+            if (i < seq.length - 1) {
+                const to = fnIndex.get(seq[i + 1]);
+                transitionMatrix[from][to]++;
+            }
+        }
+    }
+    // Step 3: Per-function stats (purely structural)
+    const fnStats = fnList.map((_, i) => {
+        const inDegree = transitionMatrix.reduce((s, row) => s + (row[i] > 0 ? 1 : 0), 0);
+        const outDegree = transitionMatrix[i].reduce((s, v) => s + (v > 0 ? 1 : 0), 0);
+        return { inDegree, outDegree, frequency: freq[i] };
+    });
+    // Step 4: Infer states from co-occurrence patterns
+    //
+    // A "state" is identified when:
+    //   - Producer P: has high out-degree (connects to many things)
+    //   - Consumer C: has in-degree > 0 (something precedes it)
+    //   - Invalidator I: has in-degree > 0 but out-degree = 0 (terminal)
+    //
+    // States are defined by the TRANSITION PATTERN, not by function names.
+    const states = [];
+    const stateIdCounter = { value: 0 };
+    // Strategy: for each function that acts as a "bridge" (both in and out edges),
+    // it participates in a state. Group functions that form densely-connected clusters.
+    const visited = new Set();
+    const stateGroups = [];
+    // Simple clustering: functions that share the same predecessor form a "use group"
+    const predGroups = new Map();
+    for (let i = 0; i < N; i++) {
+        const preds = [];
+        for (let j = 0; j < N; j++) {
+            if (transitionMatrix[j][i] > 0)
+                preds.push(j);
+        }
+        const key = preds.sort().join(",");
+        if (key) {
+            if (!predGroups.has(key))
+                predGroups.set(key, []);
+            predGroups.get(key).push(i);
+        }
+    }
+    // Also: functions with no predecessors are "entry points" (producers)
+    const entryPoints = [];
+    for (let i = 0; i < N; i++) {
+        let hasPred = false;
+        for (let j = 0; j < N; j++) {
+            if (transitionMatrix[j][i] > 0) {
+                hasPred = true;
+                break;
+            }
+        }
+        if (!hasPred)
+            entryPoints.push(i);
+    }
+    // Functions with no successors are "exit points" (invalidators)
+    const exitPoints = [];
+    for (let i = 0; i < N; i++) {
+        let hasSucc = false;
+        for (let j = 0; j < N; j++) {
+            if (transitionMatrix[i][j] > 0) {
+                hasSucc = true;
+                break;
+            }
+        }
+        if (!hasSucc)
+            exitPoints.push(i);
+    }
+    // Build states from entry→middle→exit patterns
+    // Each entry point that connects to ≥1 middle function creates a state
+    for (const ep of entryPoints) {
+        const consumers = [];
+        for (let j = 0; j < N; j++) {
+            if (transitionMatrix[ep][j] > 0)
+                consumers.push(j);
+        }
+        if (consumers.length === 0)
+            continue;
+        // Find invalidators: exit points that are reachable from this entry
+        const invalidators = [];
+        for (const ex of exitPoints) {
+            // Simple reachability: is there a path from consumers through the graph to ex?
+            let reachable = false;
+            for (const c of consumers) {
+                if (transitionMatrix[c][ex] > 0) {
+                    reachable = true;
+                    break;
+                }
+                // Also check 2-hop
+                for (let k = 0; k < N; k++) {
+                    if (transitionMatrix[c][k] > 0 && transitionMatrix[k][ex] > 0) {
+                        reachable = true;
+                        break;
+                    }
+                }
+                if (reachable)
+                    break;
+            }
+            if (reachable)
+                invalidators.push(ex);
+        }
+        states.push({
+            id: `S${stateIdCounter.value++}`,
+            producers: [ep],
+            consumers,
+            invalidators,
+        });
+    }
+    return { fnCount: N, states, transitionMatrix, fnStats };
+}
+/**
+ * Compute a topology fingerprint from a NameFreeStateGraph.
+ *
+ * All features are derived purely from graph structure — zero dependence on
+ * function names. The fingerprint is a fixed-size vector suitable for
+ * cross-repo similarity comparison.
+ */
+function computeTopologyFingerprint(graph) {
+    const N = graph.fnCount;
+    if (N === 0) {
+        return {
+            nodeCount: 0, edgeCount: 0, stateCount: 0,
+            avgInDegree: 0, avgOutDegree: 0, maxInDegree: 0, maxOutDegree: 0,
+            entryPointCount: 0, exitPointCount: 0, bridgeCount: 0,
+            entryRatio: 0, exitRatio: 0, componentCount: 0, avgStateSize: 0,
+            isDAG: true, longestChain: 0,
+        };
+    }
+    const stats = graph.fnStats;
+    let edgeCount = 0;
+    for (let i = 0; i < N; i++) {
+        for (let j = 0; j < N; j++) {
+            if (graph.transitionMatrix[i][j] > 0)
+                edgeCount++;
+        }
+    }
+    const inDegrees = stats.map(s => s.inDegree);
+    const outDegrees = stats.map(s => s.outDegree);
+    const avgInDegree = inDegrees.reduce((a, b) => a + b, 0) / N;
+    const avgOutDegree = outDegrees.reduce((a, b) => a + b, 0) / N;
+    const maxInDegree = Math.max(...inDegrees);
+    const maxOutDegree = Math.max(...outDegrees);
+    const entryPointCount = stats.filter(s => s.inDegree === 0 && s.outDegree > 0).length;
+    const exitPointCount = stats.filter(s => s.outDegree === 0 && s.inDegree > 0).length;
+    const bridgeCount = stats.filter(s => s.inDegree > 0 && s.outDegree > 0).length;
+    // DAG check: Kahn's algorithm
+    const tempInDegree = [...inDegrees];
+    const queue = [];
+    for (let i = 0; i < N; i++) {
+        if (tempInDegree[i] === 0)
+            queue.push(i);
+    }
+    let visitedCount = 0;
+    while (queue.length > 0) {
+        const node = queue.shift();
+        visitedCount++;
+        for (let j = 0; j < N; j++) {
+            if (graph.transitionMatrix[node][j] > 0) {
+                tempInDegree[j]--;
+                if (tempInDegree[j] === 0)
+                    queue.push(j);
+            }
+        }
+    }
+    const isDAG = visitedCount === N;
+    // Longest chain: BFS from each entry point
+    let longestChain = 0;
+    for (const ep of [...Array(N).keys()].filter(i => stats[i].inDegree === 0)) {
+        const chainQ = [{ node: ep, depth: 1 }];
+        const chainVisited = new Set([ep]);
+        while (chainQ.length > 0) {
+            const { node, depth } = chainQ.shift();
+            longestChain = Math.max(longestChain, depth);
+            for (let j = 0; j < N; j++) {
+                if (graph.transitionMatrix[node][j] > 0 && !chainVisited.has(j)) {
+                    chainVisited.add(j);
+                    chainQ.push({ node: j, depth: depth + 1 });
+                }
+            }
+        }
+    }
+    // Component count: simple DFS on undirected version
+    const undirectedAdj = Array.from({ length: N }, () => []);
+    for (let i = 0; i < N; i++) {
+        for (let j = 0; j < N; j++) {
+            if (graph.transitionMatrix[i][j] > 0 || graph.transitionMatrix[j][i] > 0) {
+                undirectedAdj[i].push(j);
+            }
+        }
+    }
+    const compVisited = new Set();
+    let componentCount = 0;
+    for (let i = 0; i < N; i++) {
+        if (!compVisited.has(i)) {
+            componentCount++;
+            const compQ = [i];
+            compVisited.add(i);
+            while (compQ.length > 0) {
+                const node = compQ.shift();
+                for (const neighbor of undirectedAdj[node]) {
+                    if (!compVisited.has(neighbor)) {
+                        compVisited.add(neighbor);
+                        compQ.push(neighbor);
+                    }
+                }
+            }
+        }
+    }
+    const totalFnInStates = graph.states.reduce((s, st) => s + st.producers.length + st.consumers.length + st.invalidators.length, 0);
+    const avgStateSize = graph.states.length > 0 ? totalFnInStates / graph.states.length : 0;
+    return {
+        nodeCount: N,
+        edgeCount,
+        stateCount: graph.states.length,
+        avgInDegree: Math.round(avgInDegree * 100) / 100,
+        avgOutDegree: Math.round(avgOutDegree * 100) / 100,
+        maxInDegree,
+        maxOutDegree,
+        entryPointCount,
+        exitPointCount,
+        bridgeCount,
+        entryRatio: Math.round((entryPointCount / N) * 100) / 100,
+        exitRatio: Math.round((exitPointCount / N) * 100) / 100,
+        componentCount,
+        avgStateSize: Math.round(avgStateSize * 100) / 100,
+        isDAG,
+        longestChain,
+    };
+}
+/**
+ * Convert a fingerprint to a numeric vector for similarity computation.
+ */
+function fingerprintToVector(fp) {
+    return [
+        fp.nodeCount,
+        fp.edgeCount,
+        fp.stateCount,
+        fp.avgInDegree,
+        fp.avgOutDegree,
+        fp.maxInDegree,
+        fp.maxOutDegree,
+        fp.entryPointCount,
+        fp.exitPointCount,
+        fp.bridgeCount,
+        fp.entryRatio,
+        fp.exitRatio,
+        fp.componentCount,
+        fp.avgStateSize,
+        fp.isDAG ? 1 : 0,
+        fp.longestChain,
+    ];
+}
+/**
+ * Cosine similarity between two fingerprint vectors.
+ */
+function fingerprintSimilarity(a, b) {
+    const va = fingerprintToVector(a);
+    const vb = fingerprintToVector(b);
+    // Normalize by max to handle scale differences
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < va.length; i++) {
+        dot += va[i] * vb[i];
+        normA += va[i] * va[i];
+        normB += vb[i] * vb[i];
+    }
+    if (normA === 0 && normB === 0)
+        return 1;
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+/**
+ * Run the name scramble benchmark between two repos.
+ *
+ * This is THE decisive test for P8.0:
+ *   1. Compute topology fingerprint similarity with original names.
+ *   2. Scramble all function names to F_0001, F_0002...
+ *   3. Re-compute similarity with ONLY topology remaining.
+ *   4. Measure survival rate.
+ *
+ * If survivalRate > 0, the system has crossed the threshold from
+ * Verb Learning to Structure Learning.
+ *
+ * @param repoA  First repo's call sequences
+ * @param repoB  Second repo's call sequences
+ * @param repoAName  Human-readable name for repo A
+ * @param repoBName  Human-readable name for repo B
+ */
+function runNameScrambleBenchmark(repoA, repoB, repoAName = "RepoA", repoBName = "RepoB") {
+    // Baseline: original names
+    const graphA = extractNameFreeStateGraph(repoA);
+    const graphB = extractNameFreeStateGraph(repoB);
+    const fpA = computeTopologyFingerprint(graphA);
+    const fpB = computeTopologyFingerprint(graphB);
+    const baselineSim = fingerprintSimilarity(fpA, fpB);
+    // Scramble: deterministic mapping per unique function name
+    let scrambleCounter = 0;
+    const scrambleMap = new Map();
+    const scrambleName = (fn) => {
+        if (!scrambleMap.has(fn)) {
+            scrambleMap.set(fn, `F_${String(scrambleCounter++).padStart(4, "0")}`);
+        }
+        return scrambleMap.get(fn);
+    };
+    // Rebuild sequences with scrambled names
+    const scrambledA = repoA.map(seq => seq.map(scrambleName));
+    const scrambledB = repoB.map(seq => seq.map(scrambleName));
+    // Re-extract with scrambled names (same topology, different "names")
+    const scrambledGraphA = extractNameFreeStateGraph(scrambledA);
+    const scrambledGraphB = extractNameFreeStateGraph(scrambledB);
+    const scrambledFpA = computeTopologyFingerprint(scrambledGraphA);
+    const scrambledFpB = computeTopologyFingerprint(scrambledGraphB);
+    const scrambledSim = fingerprintSimilarity(scrambledFpA, scrambledFpB);
+    const survivalRate = baselineSim > 0 ? scrambledSim / baselineSim : 0;
+    return {
+        baselineSimilarity: Math.round(baselineSim * 10000) / 10000,
+        scrambledSimilarity: Math.round(scrambledSim * 10000) / 10000,
+        survivalRate: Math.round(survivalRate * 10000) / 10000,
+        repoA: { name: repoAName, fingerprint: fpA },
+        repoB: { name: repoBName, fingerprint: fpB },
+    };
+}
+/**
+ * Run the benchmark across all known repo pairs and return the average survival rate.
+ */
+function runFullNameScrambleBenchmark() {
+    const repos = Object.entries(unsupervised_physics_1.CROSS_REPO_SEQUENCES);
+    const results = [];
+    for (let i = 0; i < repos.length; i++) {
+        for (let j = i + 1; j < repos.length; j++) {
+            const [nameA, seqsA] = repos[i];
+            const [nameB, seqsB] = repos[j];
+            results.push(runNameScrambleBenchmark(seqsA, seqsB, nameA, nameB));
+        }
+    }
+    const avgSurvivalRate = results.length > 0
+        ? results.reduce((s, r) => s + r.survivalRate, 0) / results.length
+        : 0;
+    return { results, avgSurvivalRate };
+}
+function printNameScrambleReport(benchmark) {
+    console.log(`\n─── P8.0c Name Scramble Benchmark ───`);
+    console.log(`  ${benchmark.repoA.name} ↔ ${benchmark.repoB.name}`);
+    console.log(`  Baseline (original names):   ${(benchmark.baselineSimilarity * 100).toFixed(1)}%`);
+    console.log(`  Scrambled (F_0001 IDs):      ${(benchmark.scrambledSimilarity * 100).toFixed(1)}%`);
+    console.log(`  Survival Rate:               ${(benchmark.survivalRate * 100).toFixed(1)}%`);
+    console.log();
+    const verdict = benchmark.survivalRate > 0.8 ? "✅ STRUCTURE LEARNED" :
+        benchmark.survivalRate > 0 ? "⚠️  PARTIAL — structure signal detected!" :
+            "❌ VERB LEARNING — structure signal absent";
+    console.log(`  Verdict: ${verdict}`);
+    console.log();
+}
+function printFullScrambleReport(report) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P8.0c Full Name Scramble Benchmark               ║");
+    console.log("║   Cross-repo topology similarity survival           ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    for (const r of report.results) {
+        console.log(`  ${r.repoA.name.padEnd(12)} ↔ ${r.repoB.name.padEnd(12)}  baseline: ${(r.baselineSimilarity * 100).toFixed(0)}%  scrambled: ${(r.scrambledSimilarity * 100).toFixed(0)}%  survival: ${(r.survivalRate * 100).toFixed(0)}%`);
+    }
+    console.log(`\n  Average Survival Rate: ${(report.avgSurvivalRate * 100).toFixed(1)}%`);
+    const verdict = report.avgSurvivalRate > 0.8 ? "STRUCTURE LEARNED" :
+        report.avgSurvivalRate > 0 ? "PARTIAL — structure signal detected!" :
+            "VERB LEARNING";
+    console.log(`  Verdict: ${verdict}`);
+    console.log();
+}

package/dist/name-free-protocol.test.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * P8.0: Name-Free Protocol Learning Tests
+ *
+ * Three decisive experiments:
+ *   A: State graph extraction with scrambled names
+ *   B: Topology fingerprint cross-repo similarity
+ *   C: Full name scramble survival benchmark
+ */
+const vitest_1 = require("vitest");
+const name_free_protocol_1 = require("./name-free-protocol");
+// ── Test data: three structurally identical protocols with different names ──
+const ACQUIRE_USE_RELEASE_A = [
+    ["open", "read", "close"],
+    ["open", "write", "close"],
+    ["open", "read", "write", "close"],
+];
+const ACQUIRE_USE_RELEASE_B = [
+    ["sql_open", "sql_read", "sql_close"],
+    ["sql_open", "sql_write", "sql_close"],
+];
+const ACQUIRE_USE_RELEASE_C = [
+    ["create_client", "send_cmd", "close_client"],
+    ["create_client", "send_cmd", "send_cmd", "close_client"],
+];
+// ── Test data: different protocol shapes ──
+const TRANSACTION_PATTERN = [
+    ["begin_tx", "insert", "commit_tx"],
+    ["begin_tx", "update", "commit_tx"],
+    ["begin_tx", "delete", "rollback_tx"],
+];
+const LOOP_PATTERN = [
+    ["init", "fetch", "process", "next", "fetch", "process", "exit"],
+    ["init", "fetch", "process", "exit"],
+];
+(0, vitest_1.describe)("P8.0a Name-Free State Graph", () => {
+    (0, vitest_1.it)("extracts state graph from sequences without using function names", () => {
+        const graph = (0, name_free_protocol_1.extractNameFreeStateGraph)(ACQUIRE_USE_RELEASE_A);
+        // Should have function nodes
+        (0, vitest_1.expect)(graph.fnCount).toBeGreaterThan(0);
+        // Should find at least one state (entry→middle→exit pattern)
+        (0, vitest_1.expect)(graph.states.length).toBeGreaterThan(0);
+        // Each state should have producers and consumers
+        for (const state of graph.states) {
+            (0, vitest_1.expect)(state.producers.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(state.consumers.length).toBeGreaterThan(0);
+        }
+        // Transition matrix should have non-zero entries
+        let hasTransitions = false;
+        for (let i = 0; i < graph.fnCount; i++) {
+            for (let j = 0; j < graph.fnCount; j++) {
+                if (graph.transitionMatrix[i][j] > 0)
+                    hasTransitions = true;
+            }
+        }
+        (0, vitest_1.expect)(hasTransitions).toBe(true);
+        // fnStats should be computed
+        (0, vitest_1.expect)(graph.fnStats.length).toBe(graph.fnCount);
+        for (const stat of graph.fnStats) {
+            (0, vitest_1.expect)(stat.frequency).toBeGreaterThanOrEqual(0);
+        }
+    });
+    (0, vitest_1.it)("produces identical state graphs for structurally identical sequences with different names", () => {
+        // Graph A: ["open","read","close"] + variants
+        const graphA = (0, name_free_protocol_1.extractNameFreeStateGraph)(ACQUIRE_USE_RELEASE_A);
+        const fpA = (0, name_free_protocol_1.computeTopologyFingerprint)(graphA);
+        // Graph B: same structure, different names
+        const graphB = (0, name_free_protocol_1.extractNameFreeStateGraph)(ACQUIRE_USE_RELEASE_B);
+        const fpB = (0, name_free_protocol_1.computeTopologyFingerprint)(graphB);
+        // Same number of functions and states
+        (0, vitest_1.expect)(graphA.fnCount).toBe(graphB.fnCount);
+        (0, vitest_1.expect)(graphA.states.length).toBe(graphB.states.length);
+        // Fingerprints should be identical (pure structure)
+        const sim = (0, name_free_protocol_1.fingerprintSimilarity)(fpA, fpB);
+        (0, vitest_1.expect)(sim).toBeGreaterThan(0.9); // Should be nearly identical
+    });
+});
+(0, vitest_1.describe)("P8.0b Topology Fingerprint", () => {
+    (0, vitest_1.it)("computes fingerprint vector from state graph", () => {
+        const graph = (0, name_free_protocol_1.extractNameFreeStateGraph)(ACQUIRE_USE_RELEASE_A);
+        const fp = (0, name_free_protocol_1.computeTopologyFingerprint)(graph);
+        // Core features should be non-zero
+        (0, vitest_1.expect)(fp.nodeCount).toBeGreaterThan(0);
+        (0, vitest_1.expect)(fp.edgeCount).toBeGreaterThan(0);
+        (0, vitest_1.expect)(fp.entryPointCount).toBeGreaterThan(0);
+        (0, vitest_1.expect)(fp.exitPointCount).toBeGreaterThan(0);
+        // Fingerprint should be a valid vector
+        const vec = [
+            fp.nodeCount, fp.edgeCount, fp.stateCount,
+            fp.avgInDegree, fp.avgOutDegree,
+            fp.entryPointCount, fp.exitPointCount, fp.bridgeCount,
+            fp.entryRatio, fp.exitRatio, fp.componentCount,
+            fp.avgStateSize, fp.isDAG ? 1 : 0, fp.longestChain,
+        ];
+        (0, vitest_1.expect)(vec.every(v => typeof v === "number" && !isNaN(v))).toBe(true);
+    });
+    (0, vitest_1.it)("distinguishes different protocol topologies", () => {
+        const acquireFp = (0, name_free_protocol_1.computeTopologyFingerprint)((0, name_free_protocol_1.extractNameFreeStateGraph)(ACQUIRE_USE_RELEASE_A));
+        const transactionFp = (0, name_free_protocol_1.computeTopologyFingerprint)((0, name_free_protocol_1.extractNameFreeStateGraph)(TRANSACTION_PATTERN));
+        const loopFp = (0, name_free_protocol_1.computeTopologyFingerprint)((0, name_free_protocol_1.extractNameFreeStateGraph)(LOOP_PATTERN));
+        // Different topologies should have different fingerprints
+        const aqTx = (0, name_free_protocol_1.fingerprintSimilarity)(acquireFp, transactionFp);
+        const aqLp = (0, name_free_protocol_1.fingerprintSimilarity)(acquireFp, loopFp);
+        const txLp = (0, name_free_protocol_1.fingerprintSimilarity)(transactionFp, loopFp);
+        // They should not all be identical
+        const allSame = aqTx > 0.99 && aqLp > 0.99 && txLp > 0.99;
+        (0, vitest_1.expect)(allSame).toBe(false);
+        console.log(`  Acquire↔Transaction: ${(aqTx * 100).toFixed(0)}%`);
+        console.log(`  Acquire↔Loop:        ${(aqLp * 100).toFixed(0)}%`);
+        console.log(`  Transaction↔Loop:    ${(txLp * 100).toFixed(0)}%`);
+    });
+});
+(0, vitest_1.describe)("P8.0c Name Scramble Benchmark", () => {
+    (0, vitest_1.it)("survival rate > 0 for structurally identical repos", () => {
+        const result = (0, name_free_protocol_1.runNameScrambleBenchmark)(ACQUIRE_USE_RELEASE_A, ACQUIRE_USE_RELEASE_B, "RepoA", "RepoB");
+        (0, name_free_protocol_1.printNameScrambleReport)(result);
+        // Key assertion: same structure → high baseline
+        (0, vitest_1.expect)(result.baselineSimilarity).toBeGreaterThan(0.8);
+        // KEY TEST: survival rate should be non-zero!
+        // With pure topology features, scrambling shouldn't kill similarity
+        (0, vitest_1.expect)(result.survivalRate).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("survival rate > 0 for repos with same shape, different names", () => {
+        const result = (0, name_free_protocol_1.runNameScrambleBenchmark)(ACQUIRE_USE_RELEASE_A, ACQUIRE_USE_RELEASE_C, "AcquireRelease_A", "AcquireRelease_C");
+        (0, name_free_protocol_1.printNameScrambleReport)(result);
+        // These have the same topology shape but different function names
+        // The topology fingerprint should detect the structural similarity
+        (0, vitest_1.expect)(result.survivalRate).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("runs full cross-repo scatter benchmark", () => {
+        const report = (0, name_free_protocol_1.runFullNameScrambleBenchmark)();
+        (0, name_free_protocol_1.printFullScrambleReport)(report);
+        (0, vitest_1.expect)(report.results.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(report.avgSurvivalRate).toBeGreaterThanOrEqual(0);
+    });
+    (0, vitest_1.it)("THE decisive test: structurally identical repos survive scrambling", () => {
+        // This is P8.0's north star: two repos with identical topology
+        // but different names must show positive survival rate.
+        //
+        // AcquireUse_A: ["open","read","close"], ["open","write","close"]
+        // AcquireUse_B: ["sql_open","sql_read","sql_close"], ["sql_open","sql_write","sql_close"]
+        //
+        // These have the SAME topology (entry→middle→exit) but different names.
+        // The topology fingerprint must capture this structural identity.
+        const result = (0, name_free_protocol_1.runNameScrambleBenchmark)(ACQUIRE_USE_RELEASE_A, ACQUIRE_USE_RELEASE_B, "AcquireUse_A", "AcquireUse_B");
+        console.log(`\n  ═══ P8.0 NORTH STAR METRIC ═══`);
+        console.log(`  Baseline:  ${(result.baselineSimilarity * 100).toFixed(1)}%`);
+        console.log(`  Scrambled: ${(result.scrambledSimilarity * 100).toFixed(1)}%`);
+        console.log(`  Survival:  ${(result.survivalRate * 100).toFixed(1)}%`);
+        console.log(`  Target:    > 0%`);
+        const verdict = result.survivalRate > 0
+            ? "✅ BREAKTHROUGH: Name-free structure signal detected!"
+            : "❌ No structure signal yet — keep iterating on fingerprint features.";
+        console.log(`  ${verdict}\n`);
+        (0, vitest_1.expect)(result.survivalRate).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)("DISCRIMINATION: star vs chain topology differ meaningfully", () => {
+        const STAR = [["hub", "leaf_a"], ["hub", "leaf_b"], ["hub", "leaf_c"], ["hub", "leaf_a", "leaf_b"]];
+        const STAR_B = [["center", "b1"], ["center", "b2"], ["center", "b3"], ["center", "b1", "b2"]];
+        const CHAIN = [["a", "b", "c", "d"], ["a", "b", "c"], ["a", "b", "c", "d", "e"]];
+        const starVsStar = (0, name_free_protocol_1.runNameScrambleBenchmark)(STAR, STAR_B, "Star", "Star_B");
+        const starVsChain = (0, name_free_protocol_1.runNameScrambleBenchmark)(STAR, CHAIN, "Star", "Chain");
+        const gap = starVsStar.baselineSimilarity - starVsChain.baselineSimilarity;
+        console.log(`  Star↔Star:  ${(starVsStar.baselineSimilarity * 100).toFixed(0)}%  surv=${(starVsStar.survivalRate * 100).toFixed(0)}%`);
+        console.log(`  Star↔Chain: ${(starVsChain.baselineSimilarity * 100).toFixed(0)}%  surv=${(starVsChain.survivalRate * 100).toFixed(0)}%`);
+        console.log(`  Discrimination gap: ${(gap * 100).toFixed(0)}%`);
+        (0, vitest_1.expect)(starVsStar.survivalRate).toBeGreaterThan(0);
+    });
+});