progmune-runtime 2.1.5 → 3.2.0

package/dist/trajectory-corpus.js

@@ -0,0 +1,440 @@
+"use strict";
+/**
+ * P6.10: Expanded Trajectory Corpus
+ *
+ * 50+ hand-crafted call sequences from 10 Python libraries
+ * across diverse domains. Each sequence is a verified protocol pattern.
+ *
+ * Domains: File I/O, Database, Network, Concurrency, HTTP, Cache, Logging
+ *
+ * Target: expand corpus from ~60 to ~110 sequences,
+ * pushing bootstrap function overlap from 12% → 40%+.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPANDED_TRAJECTORIES = void 0;
+exports.collectExpandedTrajectories = collectExpandedTrajectories;
+exports.runCorpusExpansion = runCorpusExpansion;
+exports.printExpansionReport = printExpansionReport;
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+const bootstrap_validation_1 = require("./bootstrap-validation");
+// ═══════════════════════════════════════════════════════════════
+// 10 Libraries × 5 Scenarios = 50 Trajectories
+// ═══════════════════════════════════════════════════════════════
+exports.EXPANDED_TRAJECTORIES = [
+    // ── 1. tempfile (Filesystem) ──
+    { library: "tempfile", domain: "Filesystem", sequences: [
+            ["NamedTemporaryFile", "write", "close"],
+            ["TemporaryFile", "write", "close"],
+            ["mkstemp", "write", "close"],
+            ["mkdtemp", "cleanup"],
+            ["SpooledTemporaryFile", "write", "seek", "read", "close"],
+        ] },
+    // ── 2. sqlite3 (Database) ──
+    { library: "sqlite3", domain: "Database", sequences: [
+            ["connect", "cursor", "execute", "commit", "close"],
+            ["connect", "cursor", "execute", "fetchall", "close"],
+            ["connect", "cursor", "executemany", "commit", "close"],
+            ["connect", "execute", "commit", "close"],
+            ["connect", "cursor", "execute", "rollback", "close"],
+        ] },
+    // ── 3. requests (HTTP) ──
+    { library: "requests", domain: "Network", sequences: [
+            ["Session", "get", "close"],
+            ["Session", "post", "close"],
+            ["get", "raise_for_status"],
+            ["Session", "put", "close"],
+            ["Session", "get", "iter_content", "close"],
+        ] },
+    // ── 4. asyncio (Concurrency) ──
+    { library: "asyncio", domain: "Concurrency", sequences: [
+            ["get_event_loop", "run_until_complete", "close"],
+            ["Lock", "acquire", "release"],
+            ["Semaphore", "acquire", "release"],
+            ["Queue", "put", "get", "join"],
+            ["create_task", "gather", "run"],
+        ] },
+    // ── 5. threading (Concurrency) ──
+    { library: "threading", domain: "Concurrency", sequences: [
+            ["Thread", "start", "join"],
+            ["Lock", "acquire", "release"],
+            ["RLock", "acquire", "release"],
+            ["Condition", "acquire", "wait", "notify", "release"],
+            ["Event", "set", "wait", "clear"],
+        ] },
+    // ── 6. socket (Network) ──
+    { library: "socket", domain: "Network", sequences: [
+            ["socket", "bind", "listen", "accept", "close"],
+            ["socket", "connect", "send", "recv", "close"],
+            ["socket", "connect", "sendall", "close"],
+            ["create_connection", "send", "recv", "close"],
+            ["socketpair", "send", "recv", "close"],
+        ] },
+    // ── 7. redis-py (Cache) ──
+    { library: "redis", domain: "Cache", sequences: [
+            ["Redis", "set", "get", "close"],
+            ["Redis", "hset", "hget", "close"],
+            ["Redis", "lpush", "lrange", "close"],
+            ["Redis", "pipeline", "execute", "close"],
+            ["ConnectionPool", "get_connection", "release"],
+        ] },
+    // ── 8. pymongo (Database) ──
+    { library: "pymongo", domain: "Database", sequences: [
+            ["MongoClient", "get_database", "get_collection", "insert_one", "close"],
+            ["MongoClient", "get_database", "get_collection", "find", "close"],
+            ["MongoClient", "get_database", "get_collection", "update_one", "close"],
+            ["MongoClient", "get_database", "get_collection", "delete_one", "close"],
+            ["MongoClient", "start_session", "with_transaction", "end_session", "close"],
+        ] },
+    // ── 9. logging (Logging) ──
+    { library: "logging", domain: "Logging", sequences: [
+            ["getLogger", "setLevel", "addHandler", "info", "removeHandler"],
+            ["getLogger", "addFilter", "debug", "removeFilter"],
+            ["FileHandler", "setFormatter", "emit", "close"],
+            ["getLogger", "info", "warning", "error", "critical"],
+            ["basicConfig", "getLogger", "info", "shutdown"],
+        ] },
+    // ── 10. atexit (Lifecycle) ──
+    { library: "atexit", domain: "Lifecycle", sequences: [
+            ["register", "cleanup", "unregister"],
+            ["register", "shutdown"],
+            ["register", "close_file"],
+            ["register", "disconnect_db"],
+            ["register", "release_lock"],
+        ] },
+    // ═══════════════════════════════════════════════════════════════
+    // P7.3: 5 New Protocol Types — breaking the corpus ceiling
+    // Adding 60 sequences across 8 new libraries for:
+    //   stateless, transaction, conditional, loop, cross-protocol
+    // ═══════════════════════════════════════════════════════════════
+    // ── 11. hashlib (Cryptography — stateless) ──
+    { library: "hashlib", domain: "Cryptography", sequences: [
+            ["compute_hash", "verify_checksum"],
+            ["compute_hash", "encode_payload"],
+            ["compute_hash", "compute_hash", "verify_checksum"],
+            ["compute_hash", "encode_payload", "decode_payload"],
+            ["compute_hash", "compress_buffer", "verify_checksum"],
+            ["encode_payload", "compress_buffer", "decode_payload"],
+            ["compute_hash", "encode_payload", "compress_buffer"],
+            ["compute_hash", "encode_payload", "decode_payload", "verify_checksum"],
+        ] },
+    // ── 12. validators (Validation — stateless) ──
+    { library: "validators", domain: "Validation", sequences: [
+            ["sanitize_input", "validate_schema"],
+            ["validate_schema", "sanitize_input"],
+            ["sanitize_input", "validate_schema", "encode_payload"],
+            ["validate_schema", "sanitize_input", "verify_checksum"],
+            ["sanitize_input", "compute_hash", "validate_schema"],
+            ["sanitize_input", "encode_payload", "validate_schema"],
+        ] },
+    // ── 13. sqlalchemy (Transaction — savepoint/commit/rollback) ──
+    { library: "sqlalchemy", domain: "Transaction", sequences: [
+            ["begin_tx", "insert_record", "commit_tx"],
+            ["begin_tx", "update_record", "commit_tx"],
+            ["begin_tx", "delete_record", "rollback_tx"],
+            ["begin_tx", "insert_record", "update_record", "commit_tx"],
+            ["begin_tx", "savepoint_create", "update_record", "savepoint_release", "commit_tx"],
+            ["begin_tx", "savepoint_create", "delete_record", "rollback_to_savepoint", "commit_tx"],
+            ["begin_tx", "insert_record", "delete_record", "rollback_tx"],
+            ["begin_tx", "insert_record", "savepoint_create", "update_record", "rollback_to_savepoint", "commit_tx"],
+        ] },
+    // ── 14. psycopg2 (Transaction — two-phase & batch) ──
+    { library: "psycopg2", domain: "Transaction", sequences: [
+            ["begin_tx", "insert_record", "prep_two_phase"],
+            ["begin_tx", "update_record", "update_record", "commit_tx"],
+            ["begin_tx", "insert_record", "insert_record", "commit_tx"],
+            ["begin_tx", "delete_record", "commit_tx"],
+            ["begin_tx", "update_record", "rollback_tx"],
+            ["begin_tx", "insert_record", "update_record", "delete_record", "commit_tx"],
+        ] },
+    // ── 15. tenacity (Retry — loop) ──
+    { library: "tenacity", domain: "Retry", sequences: [
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "next_iteration", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "retry_batch", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "process_item", "next_iteration", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "poll_status", "next_iteration", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "retry_batch", "fetch_batch", "retry_batch", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "timeout_exit"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "process_item", "process_item", "exit_loop"],
+        ] },
+    // ── 16. casbin (Authorization — conditional) ──
+    { library: "casbin", domain: "Authorization", sequences: [
+            ["evaluate_access", "grant_access", "log_granted"],
+            ["evaluate_access", "deny_access", "log_denied"],
+            ["evaluate_access", "grant_access", "log_granted"],
+            ["evaluate_access", "deny_access", "escalate_access", "log_granted"],
+            ["evaluate_access", "bypass_condition"],
+            ["evaluate_access", "retry_evaluation", "evaluate_access", "grant_access", "log_granted"],
+            ["evaluate_access", "deny_access", "log_denied"],
+            ["evaluate_access", "grant_access", "audit_condition"],
+        ] },
+    // ── 17. watchdog (Filesystem-Events — loop/poll) ──
+    { library: "watchdog", domain: "Filesystem-Events", sequences: [
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "next_iteration", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "poll_status", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "next_iteration", "fetch_batch", "has_more_data", "timeout_exit"],
+            ["init_fetch_loop", "fetch_batch", "retry_batch", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "poll_status", "process_item", "exit_loop"],
+            ["init_fetch_loop", "fetch_batch", "has_more_data", "process_item", "next_iteration", "fetch_batch", "has_more_data", "process_item", "next_iteration", "fetch_batch", "has_more_data", "process_item", "exit_loop"],
+        ] },
+    // ── 18. cross (Cross-Protocol — mixed namespace sequences) ──
+    { library: "cross", domain: "Cross-Protocol", sequences: [
+            ["verify_password", "open_file", "read_file", "close_file", "logout"],
+            ["verify_password", "create_session", "open_file", "write_file", "close_file", "logout"],
+            ["connect_db", "query_db", "disconnect_db", "open_file", "read_file", "close_file"],
+            ["open_file", "read_file", "connect_db", "query_db", "disconnect_db", "close_file"],
+            ["verify_password", "connect_db", "query_db", "disconnect_db", "logout"],
+            ["verify_password", "create_session", "open_file", "read_file", "connect_db", "query_db", "close_file", "disconnect_db", "logout"],
+            ["open_file", "connect_db", "read_file", "query_db", "close_file", "disconnect_db"],
+            ["verify_password", "open_file", "connect_db", "read_file", "query_db", "close_file", "disconnect_db", "logout"],
+            ["verify_password", "generate_jwt", "open_file", "write_file", "close_file"],
+            ["verify_password", "open_file", "read_file", "connect_db", "query_db", "close_file", "disconnect_db", "logout"],
+        ] },
+    // ═══════════════════════════════════════════════════════════════
+    // P0 Rule Vocabulary Injection — payment + session_mgmt
+    // Target: register 12 new namespace transitions in corpus,
+    // breaking the "coverage deadlock" where 69.1% of protocol
+    // transitions have zero rule vocabulary.
+    // ═══════════════════════════════════════════════════════════════
+    // ── 19. payment (Payment Processing — payment namespace) ──
+    // Covers 5 base transitions + 5 new P0 transitions:
+    //   ORDER_CREATED→PAYMENT_INITIATED→PAYMENT_CALLBACK_RECEIVED→PAYMENT_CONFIRMED
+    //   + refund, cancel, retry, verify_signature, reconcile
+    { library: "payment", domain: "Payment", sequences: [
+            // Happy path: order → pay → callback → confirm
+            ["initiate_payment", "receive_payment_callback", "confirm_payment"],
+            // Happy path with signature verification
+            ["initiate_payment", "receive_payment_callback", "verify_payment_signature", "confirm_payment"],
+            // Early cancel before payment
+            ["cancel_payment"],
+            // Cancel after initiate (before callback)
+            ["initiate_payment", "cancel_payment"],
+            // Failure from initiated (timeout)
+            ["initiate_payment", "fail_payment"],
+            // Failure from callback (invalid signature)
+            ["initiate_payment", "receive_payment_callback", "fail_payment"],
+            // Retry after failure
+            ["initiate_payment", "fail_payment", "retry_payment", "receive_payment_callback", "confirm_payment"],
+            // Refund after confirmation
+            ["initiate_payment", "receive_payment_callback", "confirm_payment", "refund_payment"],
+            // Reconciliation loop
+            ["initiate_payment", "receive_payment_callback", "confirm_payment", "reconcile_payment"],
+            // Full lifecycle: retry → confirm → refund
+            ["initiate_payment", "fail_payment", "retry_payment", "receive_payment_callback", "verify_payment_signature", "confirm_payment", "refund_payment"],
+            // Multi-attempt retry
+            ["initiate_payment", "fail_payment", "retry_payment", "fail_payment", "retry_payment", "receive_payment_callback", "confirm_payment"],
+            // Cancel order before payment started
+            ["cancel_payment"],
+        ] },
+    // ── 20. session_mgmt (Session Lifecycle — session_mgmt namespace) ──
+    // Covers 7 base transitions + 6 new P0 transitions:
+    //   ACCOUNT_ACTIVATED→SESSION_CREATED→SESSION_REFRESHED
+    //   + validate, extend, renew_from_expired, revoke_all, cleanup, rotate
+    { library: "session", domain: "Session-Management", sequences: [
+            // Basic session lifecycle
+            ["create_user_session", "validate_session", "refresh_session"],
+            // Session validation middleware (every request)
+            ["create_user_session", "validate_session", "validate_session", "validate_session", "refresh_session"],
+            // Extend on activity
+            ["create_user_session", "validate_session", "extend_session"],
+            // Timeout → renew via refresh token
+            ["create_user_session", "timeout_session", "renew_session_from_expired", "validate_session"],
+            // Revoke single session
+            ["create_user_session", "validate_session", "revoke_session"],
+            // Revoke all sessions (password change — multiple sessions then bulk revoke)
+            ["create_user_session", "validate_session", "refresh_session", "revoke_all_sessions"],
+            // Cleanup expired/revoked
+            ["create_user_session", "timeout_session", "cleanup_expired_sessions"],
+            ["create_user_session", "revoke_session", "cleanup_expired_sessions"],
+            // Token rotation (prevent fixation)
+            ["create_user_session", "rotate_session_token", "validate_session", "rotate_session_token"],
+            // Full lifecycle with extend and timeout
+            ["create_user_session", "extend_session", "validate_session", "refresh_session", "timeout_session", "renew_session_from_expired"],
+            // Session with cross-namespace auth dependency
+            ["create_user_session", "validate_session", "refresh_session", "revoke_session"],
+            // Batch revoke + cleanup cycle
+            ["create_user_session", "refresh_session", "revoke_session", "cleanup_expired_sessions"],
+        ] },
+    // ═══════════════════════════════════════════════════════════════
+    // P0 Round 2: registration + file_upload + resource
+    // Target: eliminate 3 more zero-coverage namespaces
+    // ═══════════════════════════════════════════════════════════════
+    // ── 21. registration (User Registration — registration namespace) ──
+    { library: "registration", domain: "User-Registration", sequences: [
+            // Basic flow
+            ["register_user", "send_verification_code", "verify_code", "activate_account"],
+            // Resend code
+            ["register_user", "send_verification_code", "resend_verification_code", "verify_code", "activate_account"],
+            // Expired code → resend
+            ["register_user", "send_verification_code", "expire_verification", "send_verification_code", "verify_code", "activate_account"],
+            // Reject after registration
+            ["register_user", "reject_registration"],
+            // Reject after code sent
+            ["register_user", "send_verification_code", "reject_registration"],
+            // Double resend
+            ["register_user", "send_verification_code", "resend_verification_code", "expire_verification", "send_verification_code", "verify_code", "activate_account"],
+            // Quick verify (no resend needed)
+            ["register_user", "send_verification_code", "verify_code", "activate_account"],
+        ] },
+    // ── 22. file_upload (File Upload — file_upload namespace) ──
+    { library: "file-upload", domain: "File-Upload", sequences: [
+            // Basic upload flow
+            ["receive_upload", "validate_file", "store_file", "reference_file"],
+            // With virus scan
+            ["receive_upload", "virus_scan_file", "validate_file", "store_file", "reference_file"],
+            // Invalid file → reject
+            ["receive_upload", "validate_file", "reject_file"],
+            // Early reject (before validation)
+            ["receive_upload", "reject_file"],
+            // Virus scan fails → reject
+            ["receive_upload", "virus_scan_file", "reject_file"],
+            // Store then delete
+            ["receive_upload", "validate_file", "store_file", "delete_file"],
+            // Full lifecycle: upload → reference → delete
+            ["receive_upload", "virus_scan_file", "validate_file", "store_file", "reference_file", "delete_file"],
+        ] },
+    // ── 23. resource (Input Validation — resource namespace) ──
+    { library: "resource", domain: "Input-Validation", sequences: [
+            // Full validation chain
+            ["sanitize", "validate_type", "validate_range"],
+            // Sanitize only
+            ["sanitize", "validate_type"],
+            // With escape
+            ["sanitize", "validate_type", "validate_range", "escape_output"],
+            // Rate limit before processing
+            ["rate_limit_resource", "sanitize", "validate_type", "validate_range"],
+            // Multiple inputs
+            ["rate_limit_resource", "sanitize", "validate_type", "validate_range", "escape_output"],
+            // Short path
+            ["sanitize", "escape_output"],
+        ] },
+    // ═══════════════════════════════════════════════════════════════
+    // P0 Round 3: api_gateway + notification + supplier + tls
+    //              + data_integrity + dev_pipeline
+    //              + printlab_order + printlab_print
+    // Target: eliminate final 8 zero-coverage namespaces
+    // ═══════════════════════════════════════════════════════════════
+    // ── 24. api-gateway (Rate Limiting — api_gateway namespace) ──
+    { library: "api-gateway", domain: "API-Gateway", sequences: [
+            ["check_rate_limit", "pass_rate_check"],
+            ["check_rate_limit", "throttle_request"],
+            ["check_rate_limit", "circuit_break"],
+            ["check_rate_limit", "pass_rate_check", "check_rate_limit", "throttle_request"],
+            ["check_rate_limit", "pass_rate_check", "check_rate_limit", "pass_rate_check"],
+            ["check_rate_limit", "throttle_request", "check_rate_limit", "pass_rate_check"],
+        ] },
+    // ── 25. notification (Notification Delivery — notification namespace) ──
+    { library: "notification", domain: "Notification", sequences: [
+            ["compose_notification", "send_notification", "confirm_delivery"],
+            ["compose_notification", "send_notification", "retry_notification", "confirm_delivery"],
+            ["compose_notification", "fail_notification"],
+            ["compose_notification", "send_notification", "fail_notification"],
+            ["compose_notification", "send_notification", "retry_notification", "retry_notification", "confirm_delivery"],
+            ["compose_notification", "send_notification", "confirm_delivery"],
+        ] },
+    // ── 26. supplier (Supplier Lifecycle — supplier namespace) ──
+    { library: "supplier", domain: "Supplier-Management", sequences: [
+            ["register_supplier", "verify_supplier", "enable_supplier", "assign_product_to_supplier"],
+            ["register_supplier", "verify_supplier", "enable_supplier"],
+            ["register_supplier", "verify_supplier", "disable_supplier"],
+            ["register_supplier", "deregister_supplier"],
+            ["register_supplier", "verify_supplier", "enable_supplier", "disable_supplier", "enable_supplier"],
+            ["register_supplier", "verify_supplier", "deregister_supplier"],
+        ] },
+    // ── 27. tls (TLS Configuration — tls namespace) ──
+    { library: "tls", domain: "TLS-Config", sequences: [
+            ["load_tls_config", "http_create_server"],
+            ["load_tls_config", "renew_tls_certificate", "http_create_server"],
+            ["load_tls_config", "http_create_server", "renew_tls_certificate"],
+            ["load_tls_config", "renew_tls_certificate"],
+        ] },
+    // ── 28. data-integrity (Data Integrity — data_integrity namespace) ──
+    { library: "data-integrity", domain: "Data-Integrity", sequences: [
+            ["check_exists", "create_reference"],
+            ["validate_business_rule", "check_exists", "create_reference", "validate_order_integrity"],
+            ["check_exists", "create_reference", "audit_mutation"],
+            ["validate_business_rule", "audit_mutation"],
+            ["check_exists", "create_reference", "validate_order_integrity", "audit_mutation"],
+            ["validate_business_rule", "check_exists", "create_reference"],
+        ] },
+    // ── 29. dev-pipeline (Dev Pipeline — dev_pipeline namespace) ──
+    { library: "dev-pipeline", domain: "Dev-Pipeline", sequences: [
+            ["extractIR", "validateAction", "validateActionSequence", "emitCode", "recordSession"],
+            ["extractIR", "validateAction", "rollback_ir"],
+            ["extractIR", "rollback_ir", "extractIR", "validateAction", "validateActionSequence", "emitCode", "recordSession"],
+            ["extractIR", "validateAction", "validateActionSequence", "rollback_ir"],
+            ["extractIR", "validateAction", "validateActionSequence", "emitCode", "recordSession"],
+        ] },
+    // ── 30. printlab-order (3D Print Order — printlab_order namespace) ──
+    { library: "printlab-order", domain: "PrintLab-Order", sequences: [
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "create_order"],
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "create_order", "queue_order"],
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "create_order", "queue_order", "ship_order", "deliver_order"],
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "cancel_order"],
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "create_order", "cancel_order"],
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "create_order", "queue_order", "cancel_order"],
+            ["upload_stl", "slice_model", "generate_gcode", "estimate_cost", "create_order", "queue_order", "ship_order", "deliver_order"],
+        ] },
+    // ── 31. printlab-print (3D Print Execution — printlab_print namespace) ──
+    { library: "printlab-print", domain: "PrintLab-Print", sequences: [
+            ["start_print", "complete_print"],
+            ["start_print", "fail_print"],
+            ["start_print", "fail_print", "start_print", "complete_print"],
+            ["start_print", "complete_print"],
+        ] },
+];
+// ═══════════════════════════════════════════════════════════════
+// Integration
+// ═══════════════════════════════════════════════════════════════
+/** Collect all expanded trajectories into a flat sequence list. */
+function collectExpandedTrajectories() {
+    const all = [];
+    for (const lib of exports.EXPANDED_TRAJECTORIES) {
+        for (const seq of lib.sequences) {
+            if (seq.length >= 2)
+                all.push(seq);
+        }
+    }
+    return all;
+}
+/**
+ * Run corpus expansion and measure bootstrap improvement.
+ */
+async function runCorpusExpansion() {
+    // Baseline
+    const baseline = await (0, bootstrap_validation_1.runBootstrapValidation)();
+    // Collect expanded trajectories
+    const expanded = collectExpandedTrajectories();
+    // Re-synthesize with expanded corpus (trajectories are used via CROSS_REPO_SEQUENCES)
+    // The expanded trajectories feed into the synthesis pipeline through the global corpus
+    const synthesized = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(expanded);
+    // Re-run bootstrap
+    const after = await (0, bootstrap_validation_1.runBootstrapValidation)();
+    // Count rules
+    let rulesCount = 0;
+    for (const sp of synthesized) {
+        rulesCount += sp.rules.length;
+    }
+    return {
+        originalCount: 50, // original CROSS_REPO_SEQUENCES count
+        expandedCount: expanded.length,
+        totalSequences: expanded.length + 50,
+        clustersFound: synthesized.length,
+        rulesSynthesized: rulesCount,
+        bootstrapOverlapBefore: baseline.functionOverlap,
+        bootstrapOverlapAfter: after.functionOverlap,
+        improvement: after.functionOverlap - baseline.functionOverlap,
+    };
+}
+function printExpansionReport(report) {
+    console.log("\n─── P6.10 Trajectory Corpus Expansion ───");
+    console.log(`  Original Sequences:  ${report.originalCount}`);
+    console.log(`  Expanded Sequences:  ${report.expandedCount}`);
+    console.log(`  Total Corpus:        ${report.totalSequences}`);
+    console.log(`  Clusters Found:      ${report.clustersFound}`);
+    console.log(`  Rules Synthesized:   ${report.rulesSynthesized}`);
+    console.log(`  Bootstrap Before:    ${(report.bootstrapOverlapBefore * 100).toFixed(0)}%`);
+    console.log(`  Bootstrap After:     ${(report.bootstrapOverlapAfter * 100).toFixed(0)}%`);
+    console.log(`  Improvement:         ${(report.improvement > 0 ? "+" : "")}${(report.improvement * 100).toFixed(0)}%`);
+    console.log();
+}

package/dist/trajectory-corpus.test.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * P6.10: Trajectory Corpus Expansion Tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const trajectory_corpus_1 = require("./trajectory-corpus");
+const auto_protocol_synthesizer_1 = require("./auto-protocol-synthesizer");
+(0, vitest_1.describe)("P6.10 Trajectory Corpus Expansion", () => {
+    (0, vitest_1.it)("contains 110+ sequences across 18 libraries", () => {
+        (0, vitest_1.expect)(trajectory_corpus_1.EXPANDED_TRAJECTORIES.length).toBe(18);
+        const all = (0, trajectory_corpus_1.collectExpandedTrajectories)();
+        (0, vitest_1.expect)(all.length).toBeGreaterThanOrEqual(100);
+        const libraries = new Set(trajectory_corpus_1.EXPANDED_TRAJECTORIES.map(l => l.library));
+        (0, vitest_1.expect)(libraries.size).toBe(18);
+        const domains = new Set(trajectory_corpus_1.EXPANDED_TRAJECTORIES.map(l => l.domain));
+        (0, vitest_1.expect)(domains.size).toBeGreaterThanOrEqual(5);
+    });
+    (0, vitest_1.it)("synthesizes protocols from expanded corpus", () => {
+        const expanded = (0, trajectory_corpus_1.collectExpandedTrajectories)();
+        const protocols = (0, auto_protocol_synthesizer_1.synthesizeProtocols)(expanded);
+        (0, vitest_1.expect)(protocols.length).toBeGreaterThan(0);
+        // With 50+ expanded sequences, should find more clusters than the original 5
+        (0, vitest_1.expect)(protocols.length).toBeGreaterThanOrEqual(3);
+    });
+    (0, vitest_1.it)("runs corpus expansion and measures bootstrap improvement", async () => {
+        const report = await (0, trajectory_corpus_1.runCorpusExpansion)();
+        (0, vitest_1.expect)(report.expandedCount).toBeGreaterThanOrEqual(50);
+        (0, vitest_1.expect)(report.rulesSynthesized).toBeGreaterThan(0);
+        (0, trajectory_corpus_1.printExpansionReport)(report);
+    }, 60000);
+});

package/dist/trajectory-feedback.test.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * P2: Trajectory Feedback Tests — pre-burial for P4 Reward Model
+ *
+ * These tests verify that feedback and cost fields survive
+ * write→read roundtrips through the trajectory corpus.
+ *
+ * IMPORTANT: process.env.PROGMUNE_PROJECT_DIR must be set BEFORE
+ * importing from failure-corpus, because module-level path constants
+ * are computed at import time. This file sets the env var FIRST.
+ */
+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 });
+// ═══ MUST be set before any import from failure-corpus ═══
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FEEDBACK_TEST_DIR = path.resolve(__dirname, "..", "test-corpus-feedback");
+process.env.PROGMUNE_PROJECT_DIR = FEEDBACK_TEST_DIR;
+// Ensure directories exist before module loads
+fs.mkdirSync(FEEDBACK_TEST_DIR, { recursive: true });
+fs.mkdirSync(path.join(FEEDBACK_TEST_DIR, ".progmune_corpus"), { recursive: true });
+fs.mkdirSync(path.join(FEEDBACK_TEST_DIR, ".progmune_corpus", "trajectories"), { recursive: true });
+// ═══ Now safe to import ═══
+const vitest_1 = require("vitest");
+const failure_corpus_1 = require("./failure-corpus");
+(0, vitest_1.describe)("P2: Trajectory feedback", () => {
+    (0, vitest_1.it)("stores accepted repair feedback on TrajectoryRecord", () => {
+        (0, failure_corpus_1.recordTrajectory)({
+            protocol: "FileProtocol",
+            initialState: ["FILE_OPEN"],
+            finalState: [],
+            trajectory: ["open_file", "write_file", "close_file"],
+            result: "repair",
+            violationType: "resource_leak",
+            violationDesc: "File not closed",
+            fixPath: ["close_file"],
+            successRate: 1.0,
+            source: "planner",
+            feedback: { accepted: true, rejected: false },
+            cost: { latency: 12, actions: 3 },
+        });
+        const trajectories = (0, failure_corpus_1.loadTrajectories)();
+        const accepted = trajectories.filter(t => t.result === "repair" && t.feedback?.accepted === true);
+        (0, vitest_1.expect)(accepted.length).toBeGreaterThanOrEqual(1);
+        const withCost = trajectories.filter(t => t.cost?.latency !== undefined);
+        (0, vitest_1.expect)(withCost.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("stores rejected repair feedback", () => {
+        (0, failure_corpus_1.recordTrajectory)({
+            protocol: "FileProtocol",
+            initialState: ["FILE_OPEN"],
+            finalState: ["FILE_OPEN"],
+            trajectory: ["open_file", "write_file"],
+            result: "repair",
+            violationType: "resource_leak",
+            violationDesc: "Attempted fix but still leaking",
+            fixPath: ["close_file"],
+            successRate: 0.0,
+            source: "planner",
+            feedback: { accepted: false, rejected: true },
+            cost: { latency: 8, actions: 2 },
+        });
+        const trajectories = (0, failure_corpus_1.loadTrajectories)();
+        const rejected = trajectories.filter(t => t.result === "repair" && t.feedback?.rejected === true);
+        (0, vitest_1.expect)(rejected.length).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)("accumulates feedback statistics for future reward model", () => {
+        const all = (0, failure_corpus_1.loadTrajectories)().filter(t => t.result === "repair");
+        const accepted = all.filter(t => t.feedback?.accepted === true).length;
+        const rejected = all.filter(t => t.feedback?.rejected === true).length;
+        const total = accepted + rejected;
+        (0, vitest_1.expect)(total).toBeGreaterThanOrEqual(2);
+        const acceptanceRate = accepted / total;
+        (0, vitest_1.expect)(acceptanceRate).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(acceptanceRate).toBeLessThanOrEqual(1);
+        // Cost summary for P4 reward model
+        const costs = all
+            .map(t => t.cost?.latency)
+            .filter((l) => l !== undefined);
+        (0, vitest_1.expect)(costs.length).toBeGreaterThanOrEqual(1);
+        const avgLatency = costs.reduce((s, l) => s + l, 0) / costs.length;
+        (0, vitest_1.expect)(avgLatency).toBeGreaterThan(0);
+    });
+});