progmune-runtime 2.1.6 → 3.2.0

package/dist/improvement-orchestrator.js

@@ -0,0 +1,206 @@
+"use strict";
+/**
+ * P5.0: Self-Improvement Orchestrator
+ *
+ * The Automation Layer — closes the autonomous improvement loop:
+ *   Benchmark → Error Budget → Gap Mining → Priority Selection
+ *   → Knowledge Patch → Regression Test → Deploy → Benchmark
+ *
+ * This is the module that decides WHAT to improve next, replacing
+ * manual developer intuition with data-driven prioritization.
+ *
+ * Core loop: Observe → Analyze → Plan → Execute → Verify
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImprovementTasks = generateImprovementTasks;
+exports.estimatePatchValue = estimatePatchValue;
+exports.runImprovementLoop = runImprovementLoop;
+exports.printOrchestrationPlan = printOrchestrationPlan;
+const evaluation_campaign_1 = require("./evaluation-campaign");
+const coverage_dashboard_1 = require("./coverage-dashboard");
+const difficulty_map_1 = require("./difficulty-map");
+const discovery_analytics_1 = require("./discovery-analytics");
+const macro_repair_1 = require("./macro-repair");
+const protocol_gap_analyzer_1 = require("./protocol-gap-analyzer");
+const protocol_coverage_1 = require("./protocol-coverage");
+// ═══════════════════════════════════════════════════════════════
+// Task Generator
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Generate prioritized improvement tasks from all available analytics.
+ *
+ * Inputs:
+ *   - Error Budget (what's broken?)
+ *   - Coverage Gaps (what's missing?)
+ *   - Difficulty Map (what's hardest?)
+ *   - Discovery Report (where are candidates not found?)
+ *   - Macro Repairs (what patterns are accepted?)
+ *
+ * Output: ranked list of concrete improvement actions.
+ */
+function generateImprovementTasks(telemetry, attributed) {
+    const tasks = [];
+    const failures = attributed.filter(a => a.failureReason !== "success");
+    // 1. From Gap Mining: add missing transitions
+    const protoDefs = (0, protocol_coverage_1.loadDefaultProtocolDefinitions)();
+    const rules = new Map();
+    for (const p of protoDefs)
+        rules.set(p.name, new Set([...p.rules.keys()]));
+    const gapReport = (0, protocol_gap_analyzer_1.analyzeProtocolGaps)(attributed, rules);
+    // Missing transitions have highest priority (92% of gaps)
+    for (const mt of gapReport.topMissingTransitions.slice(0, 15)) {
+        const [fnA, fnB] = mt.split("→");
+        const proto = gapReport.gaps.find(g => g.item === mt)?.protocols[0] || "unknown";
+        const freq = gapReport.gaps.find(g => g.item === mt)?.frequency || 1;
+        const priority = Math.min(1, freq / Math.max(1, failures.length));
+        tasks.push({
+            id: `improve-transition-${mt.replace(/[→]/g, "-")}`,
+            type: "add_transition",
+            priority,
+            protocol: proto,
+            expectedGain: priority * 0.07, // each missing transition found = ~7% potential gain
+            evidence: gapReport.gaps.find(g => g.item === mt)?.examples?.slice(0, 3) || [],
+            detail: `Add inferred transition: ${fnA} → ${fnB} (${proto}, freq=${freq})`,
+            autoApplicable: true,
+        });
+    }
+    // 2. From Macro Mining: add high-acceptance macros as templates
+    const macros = (0, macro_repair_1.mineMacroRepairs)(telemetry, 0.7, 3);
+    for (const macro of macros.slice(0, 10)) {
+        const priority = macro.acceptanceRate * 0.8 + macro.executionSuccessRate * 0.2;
+        tasks.push({
+            id: `improve-macro-${macro.id}`,
+            type: "add_macro",
+            priority,
+            protocol: macro.protocol,
+            expectedGain: 0.03 * (macro.frequency / 10),
+            evidence: [macro.goal],
+            detail: `Add macro repair: ${macro.actions.join(" → ")} (accept=${(macro.acceptanceRate * 100).toFixed(0)}%, freq=${macro.frequency})`,
+            autoApplicable: false, // macros need human review before becoming templates
+        });
+    }
+    // 3. From Coverage: add missing protocol bridges
+    const coverage = (0, coverage_dashboard_1.generateCoverageDashboard)();
+    for (const report of coverage.reports) {
+        for (const mt of report.transitionCoverage.missingTransitions.slice(0, 5)) {
+            const priority = 0.5; // coverage gaps have moderate priority
+            tasks.push({
+                id: `improve-coverage-${report.protocol}-${mt.from}-${mt.to}`,
+                type: "expand_protocol",
+                priority,
+                protocol: report.protocol,
+                expectedGain: 0.02,
+                evidence: [`${mt.from} → ${mt.to} uncovered in ${report.protocol}`],
+                detail: `Add coverage for missing transition: ${mt.from} → ${mt.to} in ${report.protocol}`,
+                autoApplicable: false,
+            });
+        }
+    }
+    // 4. From Difficulty Map: prioritize hardest protocols
+    const statsMap = (0, difficulty_map_1.buildDifficultyMap)([], [...telemetry.all()]);
+    const ranking = (0, difficulty_map_1.rankProtocolsByDifficulty)(statsMap);
+    for (const r of ranking.filter(r => r.maxDifficulty > 0.1)) {
+        tasks.push({
+            id: `improve-difficulty-${r.protocol}`,
+            type: "expand_template",
+            priority: r.maxDifficulty,
+            protocol: r.protocol,
+            expectedGain: r.maxDifficulty * 0.05,
+            evidence: [r.hardestTransition],
+            detail: `Prioritize protocol expansion: ${r.protocol} (max difficulty=${(r.maxDifficulty * 100).toFixed(0)}%, hardest: ${r.hardestTransition})`,
+            autoApplicable: false,
+        });
+    }
+    // Sort by priority descending
+    return tasks.sort((a, b) => b.priority - a.priority);
+}
+// ═══════════════════════════════════════════════════════════════
+// Patch Value Estimation
+// ═══════════════════════════════════════════════════════════════
+/**
+ * Estimate the value of applying a knowledge patch.
+ *
+ * Uses the error budget to estimate potential improvement:
+ *   - Each missing_transition solved = ~7% of missing_candidate cases
+ *   - Each macro added = ~3% of relevant cases
+ */
+function estimatePatchValue(task, errorBudget, totalCases) {
+    const missingCases = Math.round(totalCases * errorBudget.missingPct);
+    switch (task.type) {
+        case "add_transition":
+            // Each new transition can cover ~5-10% of missing cases
+            return {
+                discoveryGain: Math.min(task.expectedGain, errorBudget.missingPct),
+                top3Gain: task.expectedGain * 0.5,
+                top1Gain: task.expectedGain * 0.2,
+            };
+        case "add_macro":
+            return {
+                discoveryGain: task.expectedGain,
+                top3Gain: task.expectedGain * 0.6,
+                top1Gain: task.expectedGain * 0.3,
+            };
+        case "add_bridge":
+            return {
+                discoveryGain: task.expectedGain,
+                top3Gain: task.expectedGain * 0.4,
+                top1Gain: task.expectedGain * 0.15,
+            };
+        default:
+            return {
+                discoveryGain: task.expectedGain,
+                top3Gain: task.expectedGain * 0.3,
+                top1Gain: task.expectedGain * 0.1,
+            };
+    }
+}
+// ═══════════════════════════════════════════════════════════════
+// Full Orchestration Loop
+// ═══════════════════════════════════════════════════════════════
+async function runImprovementLoop(telemetry) {
+    // 1. Observe: run benchmark
+    const attributed = await (0, evaluation_campaign_1.runFailureAttribution)();
+    const budget = (0, evaluation_campaign_1.computeErrorBudget)(attributed);
+    const discovery = (0, discovery_analytics_1.computeDiscoveryMetrics)(attributed);
+    // 2. Analyze: generate improvement tasks
+    const tasks = generateImprovementTasks(telemetry, attributed);
+    // 3. Estimate value of top tasks
+    const topTasks = tasks.slice(0, 5).map(t => ({
+        ...t,
+        gain: estimatePatchValue(t, { missingPct: budget.percentages.missing_candidate || 0, rankingPct: budget.percentages.bad_ranking || 0, successPct: budget.successRate }, budget.totalCases),
+    }));
+    // 4. Top recommendation
+    const top = topTasks[0];
+    const topRec = top
+        ? `#1: ${top.detail} (priority=${(top.priority * 100).toFixed(0)}%, est. discovery gain=${(top.gain.discoveryGain * 100).toFixed(1)}%)`
+        : "No improvements needed — all metrics within target range.";
+    return {
+        timestamp: new Date().toISOString(),
+        errorBudget: { missingPct: budget.percentages.missing_candidate || 0, rankingPct: budget.percentages.bad_ranking || 0, successPct: budget.successRate },
+        discoveryRate: discovery.overall,
+        tasks,
+        topRecommendation: topRec,
+    };
+}
+function printOrchestrationPlan(plan) {
+    console.log("\n╔════════════════════════════════════════════════════╗");
+    console.log("║   P5.0 Self-Improvement Orchestrator               ║");
+    console.log("╚════════════════════════════════════════════════════╝\n");
+    console.log(`Timestamp:       ${plan.timestamp}`);
+    console.log(`Discovery Rate:  ${(plan.discoveryRate * 100).toFixed(0)}%`);
+    console.log(`Error Budget:    missing=${(plan.errorBudget.missingPct * 100).toFixed(0)}%  ranking=${(plan.errorBudget.rankingPct * 100).toFixed(0)}%  success=${(plan.errorBudget.successPct * 100).toFixed(0)}%`);
+    console.log();
+    console.log(`Top Recommendation: ${plan.topRecommendation}`);
+    console.log();
+    if (plan.tasks.length > 0) {
+        console.log("─── Prioritized Improvement Tasks ───");
+        console.log("Pri    Type              Protocol        Detail");
+        console.log("─────────────────────────────────────────────────────────");
+        for (const t of plan.tasks.slice(0, 15)) {
+            const pri = (t.priority * 100).toFixed(0).padStart(4);
+            const type = t.type.replace(/_/g, " ").padEnd(16);
+            console.log(`  ${pri}%  ${type} ${t.protocol.padEnd(16)} ${t.detail.slice(0, 50)}`);
+        }
+        console.log();
+    }
+}

package/dist/inject-p0-vocabulary.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env npx ts-node
+"use strict";
+/**
+ * P0 Rule Vocabulary Injection — payment + session_mgmt
+ *
+ * Reads EXPANDED_TRAJECTORIES and writes synthetic trajectory JSON files
+ * into .progmune_corpus/trajectories/YYYY-MM-DD/, registering payment and
+ * session_mgmt namespace transitions in the coverage engine.
+ *
+ * Usage:
+ *   npx ts-node src/inject-p0-vocabulary.ts [--dry-run]
+ *
+ * This breaks the "coverage deadlock" described in the Two-Hump diagnosis:
+ *   - payment:     5→10 transitions registered (was 0, target +5)
+ *   - session_mgmt: 7→13 transitions registered (was 0, target +7)
+ */
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const trajectory_corpus_1 = require("./trajectory-corpus");
+const CORPUS_DIR = path.resolve(process.env.PROGMUNE_PROJECT_DIR || process.cwd(), ".progmune_corpus", "trajectories");
+const TARGET_DOMAINS = [
+    "Payment", "Session-Management",
+    "User-Registration", "File-Upload", "Input-Validation",
+];
+// ── Payment state machine (from protocols.json) ──
+const PAYMENT_STATES = {
+    initiate_payment: { pre: ["ORDER_CREATED"], post: ["PAYMENT_INITIATED"] },
+    receive_payment_callback: { pre: ["PAYMENT_INITIATED"], post: ["PAYMENT_CALLBACK_RECEIVED"] },
+    confirm_payment: { pre: ["PAYMENT_CALLBACK_RECEIVED"], post: ["PAYMENT_CONFIRMED"] },
+    fail_payment: { pre: ["PAYMENT_INITIATED", "PAYMENT_CALLBACK_RECEIVED"], post: ["PAYMENT_FAILED"] },
+    cancel_payment: { pre: ["ORDER_CREATED", "PAYMENT_INITIATED"], post: ["PAYMENT_FAILED"] },
+    retry_payment: { pre: ["PAYMENT_FAILED"], post: ["PAYMENT_INITIATED"] },
+    refund_payment: { pre: ["PAYMENT_CONFIRMED"], post: ["PAYMENT_FAILED"] },
+    verify_payment_signature: { pre: ["PAYMENT_CALLBACK_RECEIVED"], post: ["PAYMENT_CALLBACK_RECEIVED"] },
+    reconcile_payment: { pre: ["PAYMENT_CONFIRMED"], post: ["PAYMENT_CONFIRMED"] },
+};
+// ── Session state machine (from protocols.json) ──
+const SESSION_STATES = {
+    create_user_session: { pre: ["ACCOUNT_ACTIVATED", "AUTHENTICATED"], post: ["SESSION_CREATED"] },
+    validate_session: { pre: ["SESSION_CREATED", "SESSION_REFRESHED"], post: ["SESSION_CREATED", "SESSION_REFRESHED"] },
+    refresh_session: { pre: ["SESSION_CREATED"], post: ["SESSION_REFRESHED"] },
+    extend_session: { pre: ["SESSION_CREATED"], post: ["SESSION_REFRESHED"] },
+    timeout_session: { pre: ["SESSION_CREATED", "SESSION_REFRESHED"], post: ["SESSION_EXPIRED"] },
+    revoke_session: { pre: ["SESSION_CREATED", "SESSION_REFRESHED"], post: ["SESSION_REVOKED"] },
+    revoke_all_sessions: { pre: ["SESSION_CREATED", "SESSION_REFRESHED"], post: ["SESSION_REVOKED"] },
+    renew_session_from_expired: { pre: ["SESSION_EXPIRED"], post: ["SESSION_CREATED"] },
+    cleanup_expired_sessions: { pre: ["SESSION_EXPIRED", "SESSION_REVOKED"], post: [] },
+    rotate_session_token: { pre: ["SESSION_CREATED", "SESSION_REFRESHED"], post: ["SESSION_REFRESHED"] },
+};
+// ── Registration state machine ──
+const REG_STATES = {
+    register_user: { pre: ["UNAUTHENTICATED"], post: ["USER_REGISTERED"] },
+    send_verification_code: { pre: ["USER_REGISTERED"], post: ["VERIFICATION_CODE_SENT"] },
+    resend_verification_code: { pre: ["VERIFICATION_CODE_SENT"], post: ["VERIFICATION_CODE_SENT"] },
+    expire_verification: { pre: ["VERIFICATION_CODE_SENT"], post: ["USER_REGISTERED"] },
+    verify_code: { pre: ["VERIFICATION_CODE_SENT"], post: ["VERIFICATION_CONFIRMED"] },
+    activate_account: { pre: ["VERIFICATION_CONFIRMED"], post: ["ACCOUNT_ACTIVATED"] },
+    reject_registration: { pre: ["USER_REGISTERED", "VERIFICATION_CODE_SENT"], post: ["UNAUTHENTICATED"] },
+};
+// ── File Upload state machine ──
+const UPLOAD_STATES = {
+    receive_upload: { pre: ["AUTHENTICATED"], post: ["FILE_RECEIVED"] },
+    virus_scan_file: { pre: ["FILE_RECEIVED"], post: ["FILE_RECEIVED"] },
+    validate_file: { pre: ["FILE_RECEIVED"], post: ["FILE_VALIDATED"] },
+    store_file: { pre: ["FILE_VALIDATED"], post: ["FILE_STORED"] },
+    reference_file: { pre: ["FILE_STORED"], post: ["FILE_REFERENCED"] },
+    reject_file: { pre: ["FILE_RECEIVED", "FILE_VALIDATED"], post: [] },
+    delete_file: { pre: ["FILE_STORED", "FILE_REFERENCED"], post: [] },
+};
+// ── Resource validation state machine ──
+const RESOURCE_STATES = {
+    sanitize: { pre: [], post: ["CONTENT_SANITIZED"] },
+    validate_type: { pre: ["CONTENT_SANITIZED"], post: ["TYPE_VALIDATED"] },
+    validate_range: { pre: ["TYPE_VALIDATED"], post: ["CONTENT_VALID"] },
+    escape_output: { pre: ["CONTENT_VALID"], post: ["CONTENT_VALID"] },
+    rate_limit_resource: { pre: [], post: [] },
+};
+// ── Unified state map ──
+const ALL_STATES = {
+    payment: PAYMENT_STATES,
+    session_mgmt: SESSION_STATES,
+    registration: REG_STATES,
+    file_upload: UPLOAD_STATES,
+    resource: RESOURCE_STATES,
+};
+// ── Namespace mapping (protocol → namespace) ──
+const PROTOCOL_NAMESPACE = {
+    Payment: "payment",
+    "Session-Management": "session_mgmt",
+    "User-Registration": "registration",
+    "File-Upload": "file_upload",
+    "Input-Validation": "resource",
+};
+function getStates(ns) {
+    return ALL_STATES[ns] || {};
+}
+function getInitialStates(seq, ns) {
+    const stateMap = getStates(ns);
+    const first = seq[0];
+    const rule = stateMap[first];
+    return rule ? rule.pre : [];
+}
+function getFinalStates(seq, ns) {
+    const stateMap = getStates(ns);
+    const last = seq[seq.length - 1];
+    const rule = stateMap[last];
+    return rule ? rule.post : [];
+}
+function simulateStates(seq, ns) {
+    const stateMap = getStates(ns);
+    const currentStates = new Set(getInitialStates(seq, ns));
+    for (let i = 0; i < seq.length; i++) {
+        const fn = seq[i];
+        const rule = stateMap[fn];
+        if (!rule) {
+            // Unknown function — treat as self-loop on current states
+            continue;
+        }
+        // Check if any current state matches a pre_state
+        const matchingPre = rule.pre.length === 0 || rule.pre.some(ps => currentStates.has(ps));
+        if (!matchingPre && rule.pre.length > 0) {
+            return {
+                valid: false,
+                violation: {
+                    type: "illegal_state_transition",
+                    failingStepIndex: i,
+                    expectedStates: rule.pre,
+                    actualStates: [...currentStates],
+                    fixPath: findFixPath(currentStates, rule.pre, stateMap),
+                    description: `${fn} requires ${rule.pre.join("|")} but current state is ${[...currentStates].join("|")}`,
+                },
+            };
+        }
+        // Remove invalidated states
+        // (simplified: remove pre_states, add post_states)
+        for (const ps of rule.pre)
+            currentStates.delete(ps);
+        for (const ps of rule.post)
+            currentStates.add(ps);
+    }
+    return { valid: true };
+}
+function findFixPath(current, target, stateMap) {
+    // Simple fix: find any function whose pre_states overlap with current and post_states include target
+    for (const [fn, rule] of Object.entries(stateMap)) {
+        if (rule.pre.some(ps => current.has(ps)) && rule.post.some(ps => target.includes(ps))) {
+            return [fn];
+        }
+        // Two-step fix: find intermediate
+        for (const [fn2, rule2] of Object.entries(stateMap)) {
+            if (rule.pre.some(ps => current.has(ps)) &&
+                rule.post.some(ps => rule2.pre.includes(ps)) &&
+                rule2.post.some(ps => target.includes(ps))) {
+                return [fn, fn2];
+            }
+        }
+    }
+    return [];
+}
+function generateTrajectories(dryRun) {
+    const today = new Date().toISOString().slice(0, 10);
+    const dateDir = path.join(CORPUS_DIR, today);
+    const counts = { payment: 0, session: 0 };
+    if (!dryRun)
+        fs.mkdirSync(dateDir, { recursive: true });
+    for (const lib of trajectory_corpus_1.EXPANDED_TRAJECTORIES) {
+        if (!TARGET_DOMAINS.includes(lib.domain))
+            continue;
+        const ns = PROTOCOL_NAMESPACE[lib.domain] || "unknown";
+        const protocolName = lib.domain === "Payment" ? "PaymentProcessing" : "SessionManagement";
+        for (const seq of lib.sequences) {
+            if (seq.length < 2)
+                continue;
+            const id = `T-P0-${lib.domain}-${counts.payment + counts.session}`;
+            const initialState = getInitialStates(seq, ns);
+            const finalState = getFinalStates(seq, ns);
+            const sim = simulateStates(seq, ns);
+            const record = {
+                id,
+                timestamp: new Date().toISOString(),
+                protocol: protocolName,
+                namespace: ns,
+                initialState,
+                finalState,
+                trajectory: seq,
+                result: sim.valid ? "clean" : "repair",
+                violation: sim.violation,
+                context: {
+                    nestingDepth: 0,
+                    exceptionHandled: false,
+                    insideLoop: ns === "payment" && seq.includes("retry_payment"),
+                    branchCount: seq.includes("fail_payment") ? 1 : 0,
+                    asyncContext: ns === "payment",
+                },
+                successRate: sim.valid ? 1.0 : 0.0,
+                metadata: {
+                    source: "p0-vocabulary-injection",
+                    phase: "Phase 0 — Two-Hump Rule Vocabulary Injection",
+                    experiment: "P0-payment-session-mgmt",
+                },
+                feedback: {
+                    accepted: sim.valid,
+                    rejected: !sim.valid,
+                },
+                cost: {
+                    latency: seq.length * 2,
+                    actions: seq.length,
+                },
+            };
+            if (dryRun) {
+                console.log(`[DRY RUN] ${id}: ${seq.join(" → ")}  [${sim.valid ? "VALID" : "INVALID"}]`);
+            }
+            else {
+                const filePath = path.join(dateDir, `${id}.json`);
+                fs.writeFileSync(filePath, JSON.stringify(record, null, 2));
+            }
+            if (ns === "payment")
+                counts.payment++;
+            else
+                counts.session++;
+        }
+    }
+    return counts;
+}
+// ── Coverage estimation ──
+function estimateCoverageDelta() {
+    const current = 22; // from round 1 verification
+    const total = 90;
+    const deltas = {
+        payment: 10,
+        session_mgmt: 11,
+        registration: 4,
+        file_upload: 4,
+        resource: 2,
+    };
+    const totalNew = Object.values(deltas).reduce((a, b) => a + b, 0);
+    const newCovered = current + totalNew;
+    const newPct = ((newCovered / total) * 100).toFixed(1);
+    const oldPct = ((current / total) * 100).toFixed(1);
+    return {
+        ...deltas,
+        combined: `${oldPct}% → ${newPct}% (+${totalNew}/${total} transitions)`,
+    };
+}
+// ── Main ──
+const dryRun = process.argv.includes("--dry-run");
+const counts = generateTrajectories(dryRun);
+const delta = estimateCoverageDelta();
+console.log("\n═══ P0 Vocabulary Injection Report ═══");
+console.log(`  Mode: ${dryRun ? "DRY RUN" : "LIVE"}`);
+console.log(`  Output: ${path.join(CORPUS_DIR, new Date().toISOString().slice(0, 10))}/`);
+console.log();
+console.log(`  Payment trajectories:    ${counts.payment} generated`);
+console.log(`  Session-Mgmt trajectories: ${counts.session} generated`);
+console.log(`  Total new trajectories:  ${counts.payment + counts.session}`);
+console.log();
+console.log("  Estimated coverage delta:");
+console.log(`    payment:      0 → ${delta.payment} transitions registered`);
+console.log(`    session_mgmt: 0 → ${delta.session_mgmt} transitions registered`);
+console.log(`    total:        ${delta.combined}`);
+console.log();
+console.log("  Next steps:");
+console.log("    1. Verify: npx ts-node src/inject-p0-vocabulary.ts    (live run)");
+console.log("    2. Measure: re-run coverage experiment to confirm delta");
+console.log("    3. Validate: run C benchmark to check for Recall improvement");
+console.log("    4. Iterate: add registration, file_upload, resource next");