jfl 0.8.1 → 0.9.0

package/scripts/train/v2/generate_hard_negatives.py

@@ -0,0 +1,219 @@
+"""
+Generate hard negative training examples to address benchmark gaps.
+
+Targets specific confusion patterns:
+  1. add_feature: model confuses with optimize_performance, add_tests, update_docs
+  2. fix_bug on infrastructure: model confuses with dependency_update, data_pipeline
+  3. security_hardening overfit: model incorrectly predicts security for refactor/deps/docs
+  4. refactor_code vs data_pipeline confusion
+
+Strategy: create examples that LOOK like the wrong class but ARE the right class.
+"""
+
+import json
+import os
+import random
+import argparse
+
+
+HARD_NEGATIVES = {
+    # ── add_feature: things that SOUND like optimization/testing/docs but are features ──
+    "add_feature": [
+        # These sound like optimization but are actually new features
+        ("Add caching layer for embedding lookups", "feature-builder", 0.80),
+        ("Implement connection pooling for Stratus API client", "feature-builder", 0.78),
+        ("Build batch inference mode for PolicyHead", "feature-builder", 0.82),
+        ("Create worker thread pool for parallel eval execution", "feature-builder", 0.75),
+        ("Add streaming response support to hub WebSocket API", "feature-builder", 0.80),
+        ("Implement lazy loading for heavy module imports", "feature-builder", 0.77),
+        # These sound like tests but are actually features
+        ("Build benchmark scenario runner with graded reports", "feature-builder", 0.85),
+        ("Create synthetic data generator for training pipeline", "feature-builder", 0.82),
+        ("Implement validation harness for counterfactual predictions", "feature-builder", 0.79),
+        ("Add smoke test CLI command for quick system health checks", "feature-builder", 0.81),
+        # These sound like docs but are actually features
+        ("Build interactive API documentation server", "feature-builder", 0.76),
+        ("Create changelog generator from git history", "feature-builder", 0.78),
+        ("Implement decision record template system", "feature-builder", 0.80),
+        # These are clearly features
+        ("Add planning loop that connects PolicyHead to DynamicsModel for rollout simulation", "feature-builder", 0.88),
+        ("Implement experience replay buffer for online learning with reservoir sampling", "feature-builder", 0.85),
+        ("Build counterfactual training bridge that transforms CF scenarios into v2 tuples", "feature-builder", 0.87),
+        ("Create multi-step rollout planner with beam search and pruning", "feature-builder", 0.83),
+        ("Add P2P agent communication via Subway mesh network", "feature-builder", 0.86),
+        ("Implement cost monitoring dashboard for Stratus API usage tracking", "feature-builder", 0.82),
+        ("Build agent fleet management with VM spawning and tuple collection", "feature-builder", 0.84),
+        ("Create evaluation pyramid with L1-L4 metrics tracking", "feature-builder", 0.80),
+        ("Add CRM integration via Google Sheets CLI", "feature-builder", 0.79),
+        ("Implement Linear issue sync with bidirectional updates", "feature-builder", 0.85),
+        ("Build self-driving loop with cron-triggered autoresearch", "feature-builder", 0.88),
+        ("Create agent orchestrator with model routing per role", "feature-builder", 0.87),
+        ("Add journal system with per-session JSONL files and memory indexing", "feature-builder", 0.83),
+        ("Implement TLA+ invariant monitor for runtime safety checks", "feature-builder", 0.81),
+        ("Build state capture module that snapshots system state for dynamics learning", "feature-builder", 0.82),
+        ("Create world model store with JSONL storage for transitions and predictions", "feature-builder", 0.80),
+    ],
+
+    # ── fix_bug on infrastructure crashes: NOT dependency_update or data_pipeline ──
+    "fix_bug": [
+        # Hub crashes — clearly bugs, not dependency issues
+        ("Hub process crashes with SIGSEGV when receiving malformed WebSocket frame", "hub-sentinel", 0.35),
+        ("Hub OOM killed after 6 hours — memory leak in event accumulator", "hub-sentinel", 0.30),
+        ("100% agent stranding — hub connection pool exhausted, no new connections accepted", "hub-sentinel", 0.25),
+        ("Hub crashes on startup when config.json has trailing comma", "hub-sentinel", 0.40),
+        ("Agent session lost when hub restarts — state not persisted to disk", "hub-sentinel", 0.35),
+        ("Hub WebSocket server fails to bind port — EADDRINUSE not handled", "hub-sentinel", 0.38),
+        # Infrastructure bugs — not data pipeline issues
+        ("Worktree allocation race condition — two agents get same worktree", "system-health", 0.42),
+        ("File lock not released after agent crash — blocks subsequent agents", "system-health", 0.40),
+        ("Git merge fails silently, produces empty commit with no changes", "system-health", 0.45),
+        ("Session branch not cleaned up after merge — stale branches accumulate", "system-health", 0.48),
+        ("Eval runner hangs when test script has infinite loop — no timeout enforcement", "error-fixer", 0.35),
+        ("CLI crashes with stack overflow when .jfl directory contains circular symlinks", "error-fixer", 0.42),
+        # Runtime errors — not config or dependency issues
+        ("TypeError: Cannot read properties of undefined reading 'composite'", "error-fixer", 0.50),
+        ("Unhandled promise rejection crashes Node.js process — no global handler", "error-fixer", 0.45),
+        ("ENOENT error when accessing worktree that was garbage collected", "error-fixer", 0.48),
+        ("JSON.parse fails on training buffer — corrupted entry at byte offset 34521", "error-fixer", 0.38),
+        ("PolicyHead inference subprocess exits with code 139 — segfault in PyTorch", "error-fixer", 0.32),
+        ("Race condition in concurrent file writes to training-buffer.jsonl", "error-fixer", 0.40),
+        ("Build succeeds but tests fail because dist/ has stale compiled files", "test-coverage", 0.55),
+        ("Flaky test passes 9/10 runs — timing-dependent assertion", "test-coverage", 0.60),
+        ("CORS error blocks dashboard API calls — missing header in response", "error-fixer", 0.50),
+        ("Memory allocation failure when loading 50MB checkpoint on low-RAM VM", "error-fixer", 0.35),
+        ("Agent gets stuck in infinite retry loop when hub is unreachable", "hub-sentinel", 0.30),
+        ("Graceful shutdown handler doesn't wait for in-flight requests", "hub-sentinel", 0.38),
+        ("Hot reload breaks when file change event fires before write completes", "error-fixer", 0.45),
+        ("Exit code 0 returned on failure — downstream scripts think it succeeded", "error-fixer", 0.50),
+        ("UTC/local timezone confusion causes journal entries with future timestamps", "error-fixer", 0.55),
+        ("Package.json scripts reference removed file — npm run breaks", "error-fixer", 0.52),
+        ("Checkpoint loading fails silently and uses random weights instead", "error-fixer", 0.35),
+        ("Request body parser rejects valid JSON with nested arrays > 3 levels", "error-fixer", 0.48),
+    ],
+
+    # ── NOT security_hardening — these LOOK like security but are other tools ──
+    "refactor_code": [
+        # These mention "clean up" or "restructure" which model confuses with security
+        ("Clean up error handling — 5 different try/catch patterns across codebase", "code-quality", 0.75),
+        ("Restructure authentication flow — too many layers of indirection", "code-quality", 0.72),
+        ("Simplify access control logic — nested conditionals are unreadable", "code-quality", 0.70),
+        ("Extract validation helpers — same input checking code in 8 places", "code-quality", 0.78),
+        ("Consolidate logging — mixing console.log, winston, and pino", "code-quality", 0.73),
+        ("Reduce coupling between auth module and user service", "code-quality", 0.71),
+        ("Simplify config parsing — 200 lines of manual env var handling", "code-quality", 0.76),
+        ("Break up god class that handles routing, auth, and business logic", "code-quality", 0.74),
+        ("Replace manual string concatenation for SQL with query builder", "code-quality", 0.72),
+        ("Extract shared HTTP client setup from 6 different service files", "code-quality", 0.75),
+    ],
+
+    "dependency_update": [
+        # These mention "security" or "CVE" but the action is updating deps, not hardening
+        ("npm audit shows 5 moderate vulnerabilities — update affected packages", "dependency-updater", 0.78),
+        ("CVE-2026-9999 in lodash — bump to latest patched version", "dependency-updater", 0.82),
+        ("Security advisory for express — update from 4.18 to 4.21", "dependency-updater", 0.80),
+        ("Dependabot PR waiting for review — axios security update", "dependency-updater", 0.75),
+        ("GitHub security alert on transitive dependency — update parent package", "dependency-updater", 0.77),
+    ],
+
+    "update_docs": [
+        # These mention "security" concepts but the action is writing docs
+        ("Document API authentication flow for new team members", "docs-updater", 0.80),
+        ("Write security best practices guide for the codebase", "docs-updater", 0.78),
+        ("Document secrets management process — which env vars, where stored", "docs-updater", 0.76),
+        ("Add access control section to onboarding documentation", "docs-updater", 0.82),
+        ("Write incident response playbook for hub crashes", "docs-updater", 0.79),
+    ],
+
+    # ── data_pipeline: distinguish from dependency_update and optimize_performance ──
+    "data_pipeline": [
+        ("Training buffer entries not flowing to v2 transform — pipeline stalled", "data-engineer", 0.50),
+        ("Embedding cache miss rate at 40% — precompute step skipping new texts", "data-engineer", 0.55),
+        ("Counterfactual scenarios not appearing in training buffer — bridge broken", "data-engineer", 0.48),
+        ("JSONL corruption in transitions file — entries missing closing brace", "data-engineer", 0.45),
+        ("Eval scored events not triggering training tuple creation", "data-engineer", 0.52),
+        ("Duplicate entries in training buffer after fleet tuple collection", "data-engineer", 0.50),
+        ("Data split not stratified — test set has 0 examples of fix_bug class", "data-engineer", 0.55),
+        ("Nightly pipeline step 2 fails — transform can't read new action types", "data-engineer", 0.48),
+        ("Mining journals produces tuples with empty reward fields", "data-engineer", 0.52),
+        ("Training data lineage lost — can't trace which journal entry produced which tuple", "data-engineer", 0.50),
+    ],
+}
+
+
+def generate_state(agent: str, composite: float, rng: random.Random) -> str:
+    tests_total = rng.choice([15, 20, 25, 30, 35, 40, 45])
+    tests_pass_rate = rng.uniform(0.5, 1.0) if composite > 0.5 else rng.uniform(0.3, 0.8)
+    tests_passing = int(tests_total * tests_pass_rate)
+    trajectory = rng.randint(1, 10)
+
+    dims = {}
+    dim_options = ["test_pass_rate", "build_health", "code_quality", "hub_health",
+                   "error_rate", "security_score", "observability", "pipeline_health",
+                   "doc_coverage", "maintainability", "test_coverage", "data_quality"]
+    for d in rng.sample(dim_options, rng.randint(2, 4)):
+        dims[d] = rng.uniform(0.2, 0.95)
+
+    dims_str = ", ".join(f"{k}={v:.4f}" for k, v in dims.items())
+    n_deltas = rng.randint(1, 4)
+    deltas = [rng.uniform(-0.08, 0.06) for _ in range(n_deltas)]
+    deltas_str = ", ".join(f"{'+' if d >= 0 else ''}{d:.4f}" for d in deltas)
+
+    return "\n".join([
+        f"Agent: {agent}",
+        f"Composite: {composite:.4f}",
+        f"Tests: {tests_passing}/{tests_total}",
+        f"Trajectory: {trajectory}",
+        f"Dimensions: {dims_str}",
+        f"Recent deltas: {deltas_str}",
+    ])
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate hard negative training examples")
+    parser.add_argument("--output", default=".jfl/v2-data", help="Output directory")
+    parser.add_argument("--seed", type=int, default=123, help="Random seed")
+    args = parser.parse_args()
+
+    rng = random.Random(args.seed)
+    examples = []
+
+    for tool_name, entries in HARD_NEGATIVES.items():
+        for goal, agent, composite in entries:
+            state = generate_state(agent, composite, rng)
+            examples.append({
+                "current_state": state,
+                "goal": goal,
+                "correct_tool": tool_name,
+                "source": "hard_negative",
+            })
+
+    rng.shuffle(examples)
+
+    n = len(examples)
+    train_end = int(n * 0.7)
+    val_end = int(n * 0.85)
+
+    splits = {
+        "train": examples[:train_end],
+        "val": examples[train_end:val_end],
+        "test": examples[val_end:],
+    }
+
+    os.makedirs(args.output, exist_ok=True)
+
+    for split_name, split_data in splits.items():
+        path = os.path.join(args.output, f"{split_name}.jsonl")
+        with open(path, "a") as f:
+            for ex in split_data:
+                f.write(json.dumps(ex) + "\n")
+        print(f"  {split_name}: +{len(split_data)} hard negatives → {path}")
+
+    from collections import Counter
+    tool_counts = Counter(ex["correct_tool"] for ex in examples)
+    print(f"\nGenerated {n} hard negative examples:")
+    for tool, count in tool_counts.most_common():
+        print(f"  {tool:25s} {count:4d}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/train/v2/infer.py

@@ -1,17 +1,23 @@
 """
 v2 Policy Head Inference — CLI script for action selection.
 
+Uses precomputed embedding cache for fast inference (<500ms).
+Falls back to Stratus API for cache misses only.
+
 Usage:
-  python infer.py --checkpoint .jfl/checkpoints/best_policy_head.pt --state "..." --goal "..." --top-k 3
+  python infer.py --checkpoint path/to/best_policy_head.pt --state "..." --goal "..." --top-k 3 --json
+  python infer.py --checkpoint ... --batch  (read JSONL from stdin)
 
-Also supports JSON mode for TypeScript bridge:
-  python infer.py --checkpoint ... --state "..." --goal "..." --json
+Cache:
+  Looks for embeddings_cache.npz + text_to_idx.json next to checkpoint or in --cache-dir.
+  Cache hit: <50ms total. Cache miss: ~5s per miss (Stratus API call).
 """
 
 import json
 import os
 import sys
 import argparse
+import time
 
 import torch
 import numpy as np
@@ -19,6 +25,80 @@ import numpy as np
 from model import PolicyHead
 
 
+# ============================================================================
+# Embedding Cache
+# ============================================================================
+
+class EmbeddingCache:
+    """Fast embedding lookup from precomputed cache, with Stratus fallback."""
+
+    def __init__(self, cache_dir: str = None, api_url: str = None, api_key: str = None):
+        self.embeddings = None
+        self.text_to_idx = {}
+        self.api_url = api_url or os.environ.get("STRATUS_API_URL", "https://api.stratus.run")
+        self.api_key = api_key or os.environ.get("STRATUS_API_KEY", "")
+        self.hits = 0
+        self.misses = 0
+
+        if cache_dir:
+            self._load_cache(cache_dir)
+
+    def _load_cache(self, cache_dir: str):
+        npz_path = os.path.join(cache_dir, "embeddings_cache.npz")
+        idx_path = os.path.join(cache_dir, "text_to_idx.json")
+
+        if os.path.exists(npz_path) and os.path.exists(idx_path):
+            data = np.load(npz_path)
+            self.embeddings = data["embeddings"]
+            self.text_to_idx = json.load(open(idx_path))
+            print(f"Loaded embedding cache: {len(self.text_to_idx)} texts, {self.embeddings.shape[1]}-dim", file=sys.stderr)
+        else:
+            print(f"No embedding cache at {cache_dir}", file=sys.stderr)
+
+    def get(self, text: str) -> list[float]:
+        """Get embedding for text. Cache hit = instant, miss = API call."""
+        # Try cache first
+        if self.text_to_idx and text in self.text_to_idx:
+            idx = self.text_to_idx[text]
+            self.hits += 1
+            return self.embeddings[idx].tolist()
+
+        # Cache miss — try API
+        self.misses += 1
+        if not self.api_key:
+            # No API key and no cache hit — return zero vector
+            dim = self.embeddings.shape[1] if self.embeddings is not None else 768
+            print(f"WARN: Cache miss + no API key for text: {text[:60]}...", file=sys.stderr)
+            return [0.0] * dim
+
+        return self._api_embed(text)
+
+    def _api_embed(self, text: str) -> list[float]:
+        import requests
+        response = requests.post(
+            f"{self.api_url}/v1/embeddings",
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": "stratus-x1ac-base",
+                "input": text,
+            },
+            timeout=15,
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data["data"][0]["embedding"]
+
+    def stats(self) -> dict:
+        return {"hits": self.hits, "misses": self.misses, "cache_size": len(self.text_to_idx)}
+
+
+# ============================================================================
+# Model Loading
+# ============================================================================
+
 def load_model(checkpoint_path: str, device: str = "cpu"):
     ckpt = torch.load(checkpoint_path, map_location=device, weights_only=False)
     config = ckpt["config"]
@@ -40,27 +120,39 @@ def load_model(checkpoint_path: str, device: str = "cpu"):
     return model, tool_to_index, index_to_tool, config
 
 
-def get_embedding(text: str, api_url: str, api_key: str) -> list[float]:
-    import requests
-
-    response = requests.post(
-        f"{api_url}/v1/embeddings",
-        headers={
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json",
-        },
-        json={
-            "model": "stratus-x1ac-base",
-            "input": text,
-        },
-        timeout=15,
-    )
-    response.raise_for_status()
-    data = response.json()
-    return data["data"][0]["embedding"]
+def find_cache_dir(checkpoint_path: str) -> str | None:
+    """Find embedding cache directory. Checks multiple locations."""
+    import pathlib
+    ckpt_dir = pathlib.Path(checkpoint_path).parent
+
+    # Check next to checkpoint: .jfl/checkpoints/ → .jfl/v2-data/
+    candidates = [
+        ckpt_dir.parent / "v2-data",                    # .jfl/v2-data/
+        ckpt_dir / "v2-data",                            # .jfl/checkpoints/v2-data/
+        pathlib.Path.cwd() / ".jfl" / "v2-data",        # cwd/.jfl/v2-data/
+    ]
+
+    # Also check EMBEDDING_CACHE_DIR env var
+    env_dir = os.environ.get("EMBEDDING_CACHE_DIR")
+    if env_dir:
+        candidates.insert(0, pathlib.Path(env_dir))
+
+    for candidate in candidates:
+        npz = candidate / "embeddings_cache.npz"
+        idx = candidate / "text_to_idx.json"
+        if npz.exists() and idx.exists():
+            return str(candidate)
+
+    return None
+
 
+# ============================================================================
+# Inference
+# ============================================================================
 
 def infer(args):
+    t0 = time.time()
+
     if torch.cuda.is_available():
         device = "cuda"
     elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
@@ -69,16 +161,21 @@ def infer(args):
         device = "cpu"
 
     model, tool_to_index, index_to_tool, config = load_model(args.checkpoint, device)
+    t_model = time.time()
+
+    # Load embedding cache
+    cache_dir = args.cache_dir or find_cache_dir(args.checkpoint)
+    cache = EmbeddingCache(
+        cache_dir=cache_dir,
+        api_url=os.environ.get("STRATUS_API_URL", "https://api.stratus.run"),
+        api_key=os.environ.get("STRATUS_API_KEY", ""),
+    )
+    t_cache = time.time()
 
-    api_url = os.environ.get("STRATUS_API_URL", "https://api.stratus.run")
-    api_key = os.environ.get("STRATUS_API_KEY", "")
-
-    if not api_key:
-        print("STRATUS_API_KEY not set", file=sys.stderr)
-        sys.exit(1)
-
-    state_emb = get_embedding(args.state, api_url, api_key)
-    goal_emb = get_embedding(args.goal, api_url, api_key)
+    # Get embeddings (cache hit = instant, miss = API call)
+    state_emb = cache.get(args.state)
+    goal_emb = cache.get(args.goal)
+    t_embed = time.time()
 
     state_tensor = torch.tensor([state_emb], dtype=torch.float32).to(device)
     goal_tensor = torch.tensor([goal_emb], dtype=torch.float32).to(device)
@@ -87,6 +184,7 @@ def infer(args):
 
     top_indices = result["top_k_indices"][0].cpu().tolist()
     top_probs = result["top_k_probs"][0].cpu().tolist()
+    t_infer = time.time()
 
     predictions = []
     for idx, prob in zip(top_indices, top_probs):
@@ -101,10 +199,16 @@ def infer(args):
             "confidence": predictions[0]["confidence"],
             "alternatives": predictions[1:],
         }
+        # Include timing in stderr for debugging
+        stats = cache.stats()
+        timing = f"model={t_model-t0:.1f}s cache={t_cache-t_model:.1f}s embed={t_embed-t_cache:.1f}s infer={t_infer-t_embed:.1f}s total={t_infer-t0:.1f}s hits={stats['hits']} misses={stats['misses']}"
+        print(f"timing: {timing}", file=sys.stderr)
         print(json.dumps(output))
     else:
-        print(f"\nv2 Policy Head Prediction")
-        print(f"{'─' * 40}")
+        t_total = t_infer - t0
+        stats = cache.stats()
+        print(f"\nv2 Policy Head Prediction ({t_total:.2f}s, {stats['hits']} cache hits, {stats['misses']} misses)")
+        print(f"{'─' * 50}")
         print(f"State: {args.state[:80]}...")
         print(f"Goal:  {args.goal[:80]}...")
         print(f"\nTop {args.top_k} actions:")
@@ -125,8 +229,13 @@ def batch_infer(args):
 
     model, tool_to_index, index_to_tool, config = load_model(args.checkpoint, device)
 
-    api_url = os.environ.get("STRATUS_API_URL", "https://api.stratus.run")
-    api_key = os.environ.get("STRATUS_API_KEY", "")
+    # Load embedding cache
+    cache_dir = args.cache_dir or find_cache_dir(args.checkpoint)
+    cache = EmbeddingCache(
+        cache_dir=cache_dir,
+        api_url=os.environ.get("STRATUS_API_URL", "https://api.stratus.run"),
+        api_key=os.environ.get("STRATUS_API_KEY", ""),
+    )
 
     for line in sys.stdin:
         line = line.strip()
@@ -135,8 +244,8 @@ def batch_infer(args):
 
         try:
             req = json.loads(line)
-            state_emb = get_embedding(req["state"], api_url, api_key)
-            goal_emb = get_embedding(req["goal"], api_url, api_key)
+            state_emb = cache.get(req["state"])
+            goal_emb = cache.get(req["goal"])
 
             state_tensor = torch.tensor([state_emb], dtype=torch.float32).to(device)
             goal_tensor = torch.tensor([goal_emb], dtype=torch.float32).to(device)
@@ -164,6 +273,9 @@ def batch_infer(args):
             print(json.dumps({"error": str(e)}))
             sys.stdout.flush()
 
+    stats = cache.stats()
+    print(f"Batch complete: {stats['hits']} hits, {stats['misses']} misses", file=sys.stderr)
+
 
 def main():
     parser = argparse.ArgumentParser(description="v2 policy head inference")
@@ -173,6 +285,7 @@ def main():
     parser.add_argument("--top-k", type=int, default=3, help="Number of top actions")
     parser.add_argument("--json", action="store_true", help="JSON output for TypeScript bridge")
     parser.add_argument("--batch", action="store_true", help="Batch mode: read JSONL from stdin")
+    parser.add_argument("--cache-dir", default=None, help="Directory with embeddings_cache.npz + text_to_idx.json")
     args = parser.parse_args()
 
     if args.batch: