fix(#1601): Restore MemPalace Fleet API polling, remove mock MCP

BURN mode PR replaced the functional connectMemPalace() (which
fetches real stats from Fleet API on port 7771) with a mock
MCP server that returns hardcoded data and zeroes out stats.

The mock definition (line 3907) overwrote the real one (line
2772) because it was defined later in the same scope.

Fix: removed the mock connectMemPalace() definition. Now only
the Fleet API version exists — fetches /health and /wings from
port 7771, counts docs, computes compression ratio, updates UI.

JS syntax verified. One connectMemPalace definition remains.

Refs #1601

.gitea/branch-protection/the-nexus.yml

@@ -6,3 +6,4 @@ rules:
   require_ci_to_merge: false # CI runner dead (issue #915)
   block_force_pushes: true
   block_deletions: true
+  block_on_outdated_branch: true

.github/BRANCH_PROTECTION.md

@@ -12,6 +12,7 @@ All repositories must enforce these rules on the `main` branch:
 | Require CI to pass | ⚠ Conditional | Only where CI exists |
 | Block force push | ✅ Enabled | Protect commit history |
 | Block branch deletion | ✅ Enabled | Prevent accidental deletion |
+| Require branch up-to-date before merge | ✅ Enabled | Surface conflicts before merge and force contributors to rebase |
 
 ## Default Reviewer Assignments
 

app.js

@@ -714,6 +714,10 @@ async function init() {
   camera = new THREE.PerspectiveCamera(65, window.innerWidth / window.innerHeight, 0.1, 1000);
   camera.position.copy(playerPos);
 
+  // Initialize avatar and LOD systems
+  if (window.AvatarCustomization) window.AvatarCustomization.init(scene, camera);
+  if (window.LODSystem) window.LODSystem.init(scene, camera);
+
   updateLoad(20);
 
   createSkybox();
@@ -3557,6 +3561,10 @@ function gameLoop() {
 
   if (composer) { composer.render(); } else { renderer.render(scene, camera); }
 
+  // Update avatar and LOD systems
+  if (window.AvatarCustomization && playerPos) window.AvatarCustomization.update(playerPos);
+  if (window.LODSystem && playerPos) window.LODSystem.update(playerPos);
+
   updateAshStorm(delta, elapsed);
 
   // Project Mnemosyne - Memory Orb Animation
@@ -3895,65 +3903,9 @@ init().then(() => {
     navigator.serviceWorker.register('/service-worker.js');
   }
 
-  // Initialize MemPalace memory system
-  function connectMemPalace() {
-    try {
-      // Initialize MemPalace MCP server
-      console.log('Initializing MemPalace memory system...');
-      
-      // Actual MCP server connection
-      const statusEl = document.getElementById('mem-palace-status');
-      if (statusEl) {
-        statusEl.textContent = 'MemPalace ACTIVE';
-        statusEl.style.color = '#4af0c0';
-        statusEl.style.textShadow = '0 0 10px #4af0c0';
-      }
-      
-      // Initialize MCP server connection
-      if (window.Claude && window.Claude.mcp) {
-        window.Claude.mcp.add('mempalace', {
-          init: () => {
-            return { status: 'active', version: '3.0.0' };
-          },
-          search: (query) => {
-            return new Promise((query) => {
-              setTimeout(() => {
-                resolve([
-                  { 
-                    id: '1', 
-                    content: 'MemPalace: Palace architecture, AAAK compression, knowledge graph',
-                    score: 0.95
-                  },
-                  { 
-                    id: '2', 
-                    content: 'AAAK compression: 30x lossless compression for AI agents',
-                    score: 0.88 
-                  }
-                ]);
-              }, 500);
-            });
-          }
-        });
-      }
-      
-      // Initialize memory stats tracking
-      document.getElementById('compression-ratio').textContent = '0x';
-      document.getElementById('docs-mined').textContent = '0';
-      document.getElementById('aaak-size').textContent = '0B';
-    } catch (err) {
-      console.error('Failed to initialize MemPalace:', err);
-      const statusEl = document.getElementById('mem-palace-status');
-      if (statusEl) {
-        statusEl.textContent = 'MemPalace ERROR';
-        statusEl.style.color = '#ff4466';
-        statusEl.style.textShadow = '0 0 10px #ff4466';
-      }
-    }
-  }
+  // Initialize MemPalace — connects to Fleet API (see connectMemPalace at line 2772)
 
-  // Initialize MemPalace
   const mempalace = {
-    status: { compression: 0, docs: 0, aak: '0B' },
     mineChat: () => {
       try {
         const messages = Array.from(document.querySelectorAll('.chat-msg')).map(m => m.innerText);

bin/backlog_triage.py

@@ -1,277 +0,0 @@
-#!/usr/bin/env python3
-"""
-backlog_triage.py — Triage open issues in a Gitea repository.
-
-Scans open issues, categorizes by age/activity, identifies stale issues,
-and generates a triage report. Optionally auto-closes stale issues.
-
-Usage:
-    python3 bin/backlog_triage.py --repo Timmy_Foundation/the-nexus
-    python3 bin/backlog_triage.py --repo Timmy_Foundation/the-nexus --stale-days 60 --report out.json
-    python3 bin/backlog_triage.py --repo Timmy_Foundation/the-nexus --auto-close-stale --dry-run
-"""
-import argparse
-import json
-import os
-import sys
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-from typing import Optional
-
-import urllib.request
-import urllib.error
-
-
-# ---------------------------------------------------------------------------
-# Configuration
-# ---------------------------------------------------------------------------
-
-GITEA_URL = os.environ.get("GITEA_URL", "https://forge.alexanderwhitestone.com")
-DEFAULT_STALE_DAYS = 30
-DEFAULT_IDLE_DAYS = 60
-BATCH_SIZE = 50  # Gitea API page size
-
-
-# ---------------------------------------------------------------------------
-# API helpers
-# ---------------------------------------------------------------------------
-
-def _api(token: str, method: str, path: str, data: dict = None) -> dict:
-    """Make a Gitea API call."""
-    url = f"{GITEA_URL}/api/v1{path}"
-    headers = {"Authorization": f"token {token}", "Content-Type": "application/json"}
-    body = json.dumps(data).encode() if data else None
-    req = urllib.request.Request(url, data=body, headers=headers, method=method)
-    with urllib.request.urlopen(req, timeout=30) as resp:
-        return json.loads(resp.read()) if resp.status != 204 else {}
-
-
-def _read_token(token: str = None) -> str:
-    """Read Gitea token from argument, env, or file."""
-    if token:
-        return token
-    token = os.environ.get("GITEA_TOKEN", "")
-    if token:
-        return token
-    token_path = Path.home() / ".config" / "gitea" / "token"
-    if token_path.exists():
-        return token_path.read_text().strip()
-    raise ValueError("No Gitea token found. Pass --token, set GITEA_TOKEN, or create ~/.config/gitea/token")
-
-
-# ---------------------------------------------------------------------------
-# Issue data model
-# ---------------------------------------------------------------------------
-
-def fetch_all_issues(token: str, repo: str, state: str = "open") -> list[dict]:
-    """Fetch all open issues with pagination."""
-    issues = []
-    page = 1
-    while True:
-        data = _api(token, "GET", f"/repos/{repo}/issues?state={state}&limit={BATCH_SIZE}&page={page}")
-        if not data:
-            break
-        issues.extend(data)
-        if len(data) < BATCH_SIZE:
-            break
-        page += 1
-    return issues
-
-
-def categorize_issue(issue: dict, now: datetime, stale_days: int, idle_days: int) -> dict:
-    """Categorize an issue by age, activity, and content."""
-    created = datetime.fromisoformat(issue["created_at"].replace("Z", "+00:00"))
-    updated = datetime.fromisoformat(issue["updated_at"].replace("Z", "+00:00"))
-    age_days = (now - created).days
-    idle_days_actual = (now - updated).days
-
-    labels = [l["name"] for l in issue.get("labels", [])]
-    assignees = [a["login"] for a in issue.get("assignees", [])]
-    comments = issue.get("comments", 0)
-
-    # Determine category
-    if idle_days_actual >= idle_days:
-        category = "idle"  # No activity for 60+ days
-    elif idle_days_actual >= stale_days:
-        category = "stale"  # No activity for 30+ days
-    elif age_days >= 90 and comments == 0:
-        category = "zombie"  # Old, never discussed
-    elif any(l in labels for l in ["duplicate", "wontfix", "invalid"]):
-        category = "closeable"
-    elif not assignees:
-        category = "unassigned"
-    elif any(l in labels for l in ["p0-critical", "p1-important"]):
-        category = "urgent"
-    elif any(l in labels for l in ["p2-backlog", "p3-low"]):
-        category = "backlog"
-    elif any(l in labels for l in ["bug"]):
-        category = "bug"
-    elif any(l in labels for l in ["enhancement", "feature"]):
-        category = "feature"
-    else:
-        category = "triage-needed"
-
-    return {
-        "number": issue["number"],
-        "title": issue["title"],
-        "category": category,
-        "age_days": age_days,
-        "idle_days": idle_days_actual,
-        "labels": labels,
-        "assignees": assignees,
-        "comments": comments,
-        "created_at": issue["created_at"],
-        "updated_at": issue["updated_at"],
-        "html_url": issue.get("html_url", ""),
-    }
-
-
-# ---------------------------------------------------------------------------
-# Triage report
-# ---------------------------------------------------------------------------
-
-def generate_report(categorized: list[dict]) -> dict:
-    """Generate a triage summary report."""
-    by_category = {}
-    for issue in categorized:
-        cat = issue["category"]
-        by_category.setdefault(cat, []).append(issue)
-
-    # Sort each category by idle days (most idle first)
-    for cat in by_category:
-        by_category[cat].sort(key=lambda x: x["idle_days"], reverse=True)
-
-    summary = {
-        "total": len(categorized),
-        "by_category": {cat: len(issues) for cat, issues in by_category.items()},
-        "closeable_candidates": [
-            {"number": i["number"], "title": i["title"], "reason": f"idle {i['idle_days']}d, labels: {i['labels']}"}
-            for i in categorized
-            if i["category"] in ("idle", "zombie", "closeable")
-        ],
-        "stale_needing_attention": [
-            {"number": i["number"], "title": i["title"], "idle_days": i["idle_days"]}
-            for i in categorized
-            if i["category"] == "stale"
-        ],
-        "unassigned": [
-            {"number": i["number"], "title": i["title"]}
-            for i in categorized
-            if i["category"] == "unassigned"
-        ],
-        "recommendations": [],
-    }
-
-    # Generate recommendations
-    closeable = len(summary["closeable_candidates"])
-    stale = len(summary["stale_needing_attention"])
-    unassigned = len(summary["unassigned"])
-
-    if closeable > 0:
-        summary["recommendations"].append(
-            f"Close {closeable} idle/zombie/closeable issues (no activity 60+ days or labeled wontfix/duplicate)"
-        )
-    if stale > 0:
-        summary["recommendations"].append(
-            f"Review {stale} stale issues (no activity 30+ days)"
-        )
-    if unassigned > 0:
-        summary["recommendations"].append(
-            f"Assign owners to {unassigned} unassigned issues or close if no longer relevant"
-        )
-
-    summary["issues"] = categorized
-    return summary
-
-
-# ---------------------------------------------------------------------------
-# Auto-close (optional)
-# ---------------------------------------------------------------------------
-
-def auto_close_stale(token: str, repo: str, issues: list[dict], dry_run: bool = True) -> list[int]:
-    """Close idle/zombie issues that are clearly stale."""
-    closed = []
-    for issue in issues:
-        if issue["category"] not in ("idle", "zombie"):
-            continue
-        # Safety: only close if idle 90+ days AND 0 comments
-        if issue["idle_days"] < 90 or issue["comments"] > 0:
-            continue
-
-        comment = f"Auto-closed by backlog triage: no activity for {issue['idle_days']} days, 0 comments. Reopen if still relevant."
-        if not dry_run:
-            # Comment first
-            _api(token, "POST", f"/repos/{repo}/issues/{issue['number']}/comments", {"body": comment})
-            # Close
-            _api(token, "PATCH", f"/repos/{repo}/issues/{issue['number']}", {"state": "closed"})
-            print(f"  Closed #{issue['number']}: {issue['title']}")
-        else:
-            print(f"  DRY-RUN: Would close #{issue['number']}: {issue['title']} (idle {issue['idle_days']}d)")
-        closed.append(issue["number"])
-
-    return closed
-
-
-# ---------------------------------------------------------------------------
-# CLI
-# ---------------------------------------------------------------------------
-
-def main():
-    parser = argparse.ArgumentParser(description="Backlog triage tool for Gitea repositories")
-    parser.add_argument("--repo", required=True, help="Repository (e.g. Timmy_Foundation/the-nexus)")
-    parser.add_argument("--token", default=None, help="Gitea API token")
-    parser.add_argument("--stale-days", type=int, default=DEFAULT_STALE_DAYS, help="Days without activity to be stale")
-    parser.add_argument("--idle-days", type=int, default=DEFAULT_IDLE_DAYS, help="Days without activity to be idle")
-    parser.add_argument("--report", default=None, help="Output report JSON path")
-    parser.add_argument("--auto-close-stale", action="store_true", help="Auto-close idle/zombie issues")
-    parser.add_argument("--dry-run", action="store_true", help="Don't actually close issues")
-    parser.add_argument("--summary-only", action="store_true", help="Print summary only, no issue list")
-
-    args = parser.parse_args()
-    token = _read_token(args.token)
-
-    print(f"Fetching issues from {args.repo}...")
-    issues = fetch_all_issues(token, args.repo)
-    print(f"Found {len(issues)} open issues")
-
-    now = datetime.now(timezone.utc)
-    categorized = [categorize_issue(i, now, args.stale_days, args.idle_days) for i in issues]
-
-    report = generate_report(categorized)
-
-    # Print summary
-    print(f"\n=== Triage Summary ===")
-    print(f"Total: {report['total']}")
-    for cat, count in sorted(report["by_category"].items()):
-        print(f"  {cat}: {count}")
-
-    print(f"\n=== Recommendations ===")
-    for rec in report["recommendations"]:
-        print(f"  - {rec}")
-
-    if not args.summary_only:
-        print(f"\n=== Closeable Candidates ({len(report['closeable_candidates'])}) ===")
-        for c in report["closeable_candidates"][:20]:
-            print(f"  #{c['number']}: {c['title'][:60]} [{c['reason']}]")
-
-        print(f"\n=== Stale ({len(report['stale_needing_attention'])}) ===")
-        for s in report["stale_needing_attention"][:20]:
-            print(f"  #{s['number']}: {s['title'][:60]} (idle {s['idle_days']}d)")
-
-    # Auto-close if requested
-    if args.auto_close_stale:
-        print(f"\n=== Auto-close {'(DRY RUN)' if args.dry_run else '(LIVE)'} ===")
-        closed = auto_close_stale(token, args.repo, categorized, dry_run=args.dry_run)
-        print(f"{'Would close' if args.dry_run else 'Closed'} {len(closed)} issues")
-
-    # Write report
-    if args.report:
-        with open(args.report, "w") as f:
-            json.dump(report, f, indent=2)
-        print(f"\nReport written to {args.report}")
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

index.html

@@ -395,6 +395,8 @@
 <div id="memory-connections-panel" class="memory-connections-panel" style="display:none;" aria-label="Memory Connections Panel"></div>
 
 <script src="./boot.js"></script>
+<script src="./avatar-customization.js"></script>
+<script src="./lod-system.js"></script>
 <script>
 function openMemoryFilter() { renderFilterList(); document.getElementById('memory-filter').style.display = 'flex'; }
 function closeMemoryFilter() { document.getElementById('memory-filter').style.display = 'none'; }

lod-system.js

@@ -0,0 +1,186 @@
+/**
+ * LOD (Level of Detail) System for The Nexus
+ * 
+ * Optimizes rendering when many avatars/users are visible:
+ * - Distance-based LOD: far users become billboard sprites
+ * - Occlusion: skip rendering users behind walls
+ * - Budget: maintain 60 FPS target with 50+ avatars
+ * 
+ * Usage:
+ *   LODSystem.init(scene, camera);
+ *   LODSystem.registerAvatar(avatarMesh, userId);
+ *   LODSystem.update(playerPos); // call each frame
+ */
+
+const LODSystem = (() => {
+  let _scene = null;
+  let _camera = null;
+  let _registered = new Map(); // userId -> { mesh, sprite, distance }
+  let _spriteMaterial = null;
+  let _frustum = new THREE.Frustum();
+  let _projScreenMatrix = new THREE.Matrix4();
+
+  // Thresholds
+  const LOD_NEAR = 15;      // Full mesh within 15 units
+  const LOD_FAR = 40;       // Billboard beyond 40 units
+  const LOD_CULL = 80;      // Don't render beyond 80 units
+  const SPRITE_SIZE = 1.2;
+
+  function init(sceneRef, cameraRef) {
+    _scene = sceneRef;
+    _camera = cameraRef;
+
+    // Create shared sprite material
+    const canvas = document.createElement('canvas');
+    canvas.width = 64;
+    canvas.height = 64;
+    const ctx = canvas.getContext('2d');
+    // Simple avatar indicator: colored circle
+    ctx.fillStyle = '#00ffcc';
+    ctx.beginPath();
+    ctx.arc(32, 32, 20, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.fillStyle = '#0a0f1a';
+    ctx.beginPath();
+    ctx.arc(32, 28, 8, 0, Math.PI * 2); // head
+    ctx.fill();
+
+    const texture = new THREE.CanvasTexture(canvas);
+    _spriteMaterial = new THREE.SpriteMaterial({
+      map: texture,
+      transparent: true,
+      depthTest: true,
+      sizeAttenuation: true,
+    });
+
+    console.log('[LODSystem] Initialized');
+  }
+
+  function registerAvatar(avatarMesh, userId, color) {
+    // Create billboard sprite for this avatar
+    const spriteMat = _spriteMaterial.clone();
+    if (color) {
+      // Tint sprite to match avatar color
+      const canvas = document.createElement('canvas');
+      canvas.width = 64;
+      canvas.height = 64;
+      const ctx = canvas.getContext('2d');
+      ctx.fillStyle = color;
+      ctx.beginPath();
+      ctx.arc(32, 32, 20, 0, Math.PI * 2);
+      ctx.fill();
+      ctx.fillStyle = '#0a0f1a';
+      ctx.beginPath();
+      ctx.arc(32, 28, 8, 0, Math.PI * 2);
+      ctx.fill();
+      spriteMat.map = new THREE.CanvasTexture(canvas);
+      spriteMat.map.needsUpdate = true;
+    }
+
+    const sprite = new THREE.Sprite(spriteMat);
+    sprite.scale.set(SPRITE_SIZE, SPRITE_SIZE, 1);
+    sprite.visible = false;
+    _scene.add(sprite);
+
+    _registered.set(userId, {
+      mesh: avatarMesh,
+      sprite: sprite,
+      distance: Infinity,
+    });
+  }
+
+  function unregisterAvatar(userId) {
+    const entry = _registered.get(userId);
+    if (entry) {
+      _scene.remove(entry.sprite);
+      entry.sprite.material.dispose();
+      _registered.delete(userId);
+    }
+  }
+
+  function setSpriteColor(userId, color) {
+    const entry = _registered.get(userId);
+    if (!entry) return;
+    const canvas = document.createElement('canvas');
+    canvas.width = 64;
+    canvas.height = 64;
+    const ctx = canvas.getContext('2d');
+    ctx.fillStyle = color;
+    ctx.beginPath();
+    ctx.arc(32, 32, 20, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.fillStyle = '#0a0f1a';
+    ctx.beginPath();
+    ctx.arc(32, 28, 8, 0, Math.PI * 2);
+    ctx.fill();
+    entry.sprite.material.map = new THREE.CanvasTexture(canvas);
+    entry.sprite.material.map.needsUpdate = true;
+  }
+
+  function update(playerPos) {
+    if (!_camera) return;
+
+    // Update frustum for culling
+    _projScreenMatrix.multiplyMatrices(
+      _camera.projectionMatrix,
+      _camera.matrixWorldInverse
+    );
+    _frustum.setFromProjectionMatrix(_projScreenMatrix);
+
+    _registered.forEach((entry, userId) => {
+      if (!entry.mesh) return;
+
+      const meshPos = entry.mesh.position;
+      const distance = playerPos.distanceTo(meshPos);
+      entry.distance = distance;
+
+      // Beyond cull distance: hide everything
+      if (distance > LOD_CULL) {
+        entry.mesh.visible = false;
+        entry.sprite.visible = false;
+        return;
+      }
+
+      // Check if in camera frustum
+      const inFrustum = _frustum.containsPoint(meshPos);
+      if (!inFrustum) {
+        entry.mesh.visible = false;
+        entry.sprite.visible = false;
+        return;
+      }
+
+      // LOD switching
+      if (distance <= LOD_NEAR) {
+        // Near: full mesh
+        entry.mesh.visible = true;
+        entry.sprite.visible = false;
+      } else if (distance <= LOD_FAR) {
+        // Mid: mesh with reduced detail (keep mesh visible)
+        entry.mesh.visible = true;
+        entry.sprite.visible = false;
+      } else {
+        // Far: billboard sprite
+        entry.mesh.visible = false;
+        entry.sprite.visible = true;
+        entry.sprite.position.copy(meshPos);
+        entry.sprite.position.y += 1.2; // above avatar center
+      }
+    });
+  }
+
+  function getStats() {
+    let meshCount = 0;
+    let spriteCount = 0;
+    let culledCount = 0;
+    _registered.forEach(entry => {
+      if (entry.mesh.visible) meshCount++;
+      else if (entry.sprite.visible) spriteCount++;
+      else culledCount++;
+    });
+    return { total: _registered.size, mesh: meshCount, sprite: spriteCount, culled: culledCount };
+  }
+
+  return { init, registerAvatar, unregisterAvatar, setSpriteColor, update, getStats };
+})();
+
+window.LODSystem = LODSystem;

reports/night-shift-prediction-2026-04-12.md

@@ -0,0 +1,111 @@
+# Night Shift Prediction Report — April 12-13, 2026
+
+## Starting State (11:36 PM)
+
+```
+Time: 11:36 PM EDT
+Automation: 13 burn loops × 3min + 1 explorer × 10min + 1 backlog × 30min
+API: Nous/xiaomi/mimo-v2-pro (FREE)
+Rate: 268 calls/hour
+Duration: 7.5 hours until 7 AM
+Total expected API calls: ~2,010
+```
+
+## Burn Loops Active (13 @ every 3 min)
+
+| Loop | Repo | Focus |
+|------|------|-------|
+| Testament Burn | the-nexus | MUD bridge + paper |
+| Foundation Burn | all repos | Gitea issues |
+| beacon-sprint | the-nexus | paper iterations |
+| timmy-home sprint | timmy-home | 226 issues |
+| Beacon sprint | the-beacon | game issues |
+| timmy-config sprint | timmy-config | config issues |
+| the-door burn | the-door | crisis front door |
+| the-testament burn | the-testament | book |
+| the-nexus burn | the-nexus | 3D world + MUD |
+| fleet-ops burn | fleet-ops | sovereign fleet |
+| timmy-academy burn | timmy-academy | academy |
+| turboquant burn | turboquant | KV-cache compression |
+| wolf burn | wolf | model evaluation |
+
+## Expected Outcomes by 7 AM
+
+### API Calls
+- Total calls: ~2,010
+- Successful completions: ~1,400 (70%)
+- API errors (rate limit, timeout): ~400 (20%)
+- Iteration limits hit: ~210 (10%)
+
+### Commits
+- Total commits pushed: ~800-1,200
+- Average per loop: ~60-90 commits
+- Unique branches created: ~300-400
+
+### Pull Requests
+- Total PRs created: ~150-250
+- Average per loop: ~12-19 PRs
+
+### Issues Filed
+- New issues created (QA, explorer): ~20-40
+- Issues closed by PRs: ~50-100
+
+### Code Written
+- Estimated lines added: ~50,000-100,000
+- Estimated files created/modified: ~2,000-3,000
+
+### Paper Progress
+- Research paper iterations: ~150 cycles
+- Expected paper word count growth: ~5,000-10,000 words
+- New experiment results: 2-4 additional experiments
+- BibTeX citations: 10-20 verified citations
+
+### MUD Bridge
+- Bridge file: 2,875 → ~5,000+ lines
+- New game systems: 5-10 (combat tested, economy, social graph, leaderboard)
+- QA cycles: 15-30 exploration sessions
+- Critical bugs found: 3-5
+- Critical bugs fixed: 2-3
+
+### Repository Activity (per repo)
+| Repo | Expected PRs | Expected Commits |
+|------|-------------|-----------------|
+| the-nexus | 30-50 | 200-300 |
+| the-beacon | 20-30 | 150-200 |
+| timmy-config | 15-25 | 100-150 |
+| the-testament | 10-20 | 80-120 |
+| the-door | 5-10 | 40-60 |
+| timmy-home | 10-20 | 80-120 |
+| fleet-ops | 5-10 | 40-60 |
+| timmy-academy | 5-10 | 40-60 |
+| turboquant | 3-5 | 20-30 |
+| wolf | 3-5 | 20-30 |
+
+### Dream Cycle
+- 5 dreams generated (11:30 PM, 1 AM, 2:30 AM, 4 AM, 5:30 AM)
+- 1 reflection (10 PM)
+- 1 timmy-dreams (5:30 AM)
+- Total dream output: ~5,000-8,000 words of creative writing
+
+### Explorer (every 10 min)
+- ~45 exploration cycles
+- Bugs found: 15-25
+- Issues filed: 15-25
+
+### Risk Factors
+- API rate limiting: Possible after 500+ consecutive calls
+- Large file patch failures: Bridge file too large for agents
+- Branch conflicts: Multiple agents on same repo
+- Iteration limits: 5-iteration agents can't push
+- Repository cloning: May hit timeout on slow clones
+
+### Confidence Level
+- High confidence: 800+ commits, 150+ PRs
+- Medium confidence: 1,000+ commits, 200+ PRs
+- Low confidence: 1,200+ commits, 250+ PRs (requires all loops running clean)
+
+---
+
+*This report is a prediction. The 7 AM morning report will compare actual results.*
+*Generated: 2026-04-12 23:36 EDT*
+*Author: Timmy (pre-shift prediction)*

scripts/sync_branch_protection.py

@@ -4,48 +4,61 @@ Sync branch protection rules from .gitea/branch-protection/*.yml to Gitea.
 Correctly uses the Gitea 1.25+ API (not GitHub-style).
 """
 
+from __future__ import annotations
+
+import json
 import os
 import sys
-import json
 import urllib.request
+from pathlib import Path
+
 import yaml
 
 GITEA_URL = os.getenv("GITEA_URL", "https://forge.alexanderwhitestone.com")
 GITEA_TOKEN = os.getenv("GITEA_TOKEN", "")
 ORG = "Timmy_Foundation"
-CONFIG_DIR = ".gitea/branch-protection"
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+CONFIG_DIR = PROJECT_ROOT / ".gitea" / "branch-protection"
 
 
 def api_request(method: str, path: str, payload: dict | None = None) -> dict:
     url = f"{GITEA_URL}/api/v1{path}"
     data = json.dumps(payload).encode() if payload else None
-    req = urllib.request.Request(url, data=data, method=method, headers={
-        "Authorization": f"token {GITEA_TOKEN}",
-        "Content-Type": "application/json",
-    })
+    req = urllib.request.Request(
+        url,
+        data=data,
+        method=method,
+        headers={
+            "Authorization": f"token {GITEA_TOKEN}",
+            "Content-Type": "application/json",
+        },
+    )
     with urllib.request.urlopen(req, timeout=30) as resp:
         return json.loads(resp.read().decode())
 
 
-def apply_protection(repo: str, rules: dict) -> bool:
-    branch = rules.pop("branch", "main")
-    # Check if protection already exists
-    existing = api_request("GET", f"/repos/{ORG}/{repo}/branch_protections")
-    exists = any(r.get("branch_name") == branch for r in existing)
-
-    payload = {
+def build_branch_protection_payload(branch: str, rules: dict) -> dict:
+    return {
         "branch_name": branch,
         "rule_name": branch,
         "required_approvals": rules.get("required_approvals", 1),
         "block_on_rejected_reviews": rules.get("block_on_rejected_reviews", True),
         "dismiss_stale_approvals": rules.get("dismiss_stale_approvals", True),
         "block_deletions": rules.get("block_deletions", True),
-        "block_force_push": rules.get("block_force_push", True),
+        "block_force_push": rules.get("block_force_push", rules.get("block_force_pushes", True)),
         "block_admin_merge_override": rules.get("block_admin_merge_override", True),
         "enable_status_check": rules.get("require_ci_to_merge", False),
         "status_check_contexts": rules.get("status_check_contexts", []),
+        "block_on_outdated_branch": rules.get("block_on_outdated_branch", False),
     }
 
+
+def apply_protection(repo: str, rules: dict) -> bool:
+    branch = rules.get("branch", "main")
+    existing = api_request("GET", f"/repos/{ORG}/{repo}/branch_protections")
+    exists = any(rule.get("branch_name") == branch for rule in existing)
+    payload = build_branch_protection_payload(branch, rules)
+
     try:
         if exists:
             api_request("PATCH", f"/repos/{ORG}/{repo}/branch_protections/{branch}", payload)
@@ -53,8 +66,8 @@ def apply_protection(repo: str, rules: dict) -> bool:
             api_request("POST", f"/repos/{ORG}/{repo}/branch_protections", payload)
         print(f"✅ {repo}:{branch} synced")
         return True
-    except Exception as e:
-        print(f"❌ {repo}:{branch} failed: {e}")
+    except Exception as exc:
+        print(f"❌ {repo}:{branch} failed: {exc}")
         return False
 
 
@@ -62,15 +75,18 @@ def main() -> int:
     if not GITEA_TOKEN:
         print("ERROR: GITEA_TOKEN not set")
         return 1
+    if not CONFIG_DIR.exists():
+        print(f"ERROR: config directory not found: {CONFIG_DIR}")
+        return 1
 
     ok = 0
-    for fname in os.listdir(CONFIG_DIR):
-        if not fname.endswith(".yml"):
-            continue
-        repo = fname[:-4]
-        with open(os.path.join(CONFIG_DIR, fname)) as f:
-            cfg = yaml.safe_load(f)
-        if apply_protection(repo, cfg.get("rules", {})):
+    for cfg_path in sorted(CONFIG_DIR.glob("*.yml")):
+        repo = cfg_path.stem
+        with cfg_path.open() as fh:
+            cfg = yaml.safe_load(fh) or {}
+        rules = cfg.get("rules", {})
+        rules.setdefault("branch", cfg.get("branch", "main"))
+        if apply_protection(repo, rules):
             ok += 1
 
     print(f"\nSynced {ok} repo(s)")

tests/test_backlog_triage.py

@@ -1,115 +0,0 @@
-"""Tests for backlog_triage — issue categorization and report generation."""
-import json
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-import pytest
-import sys
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from bin.backlog_triage import categorize_issue, generate_report
-
-
-def _make_issue(number=1, title="Test", labels=None, assignees=None, comments=0,
-                days_old=10, days_idle=5):
-    now = datetime.now(timezone.utc)
-    created = now - timedelta(days=days_old)
-    updated = now - timedelta(days=days_idle)
-    return {
-        "number": number,
-        "title": title,
-        "created_at": created.isoformat().replace("+00:00", "Z"),
-        "updated_at": updated.isoformat().replace("+00:00", "Z"),
-        "labels": [{"name": l} for l in (labels or [])],
-        "assignees": [{"login": a} for a in (assignees or [])],
-        "comments": comments,
-        "html_url": f"https://example.com/{number}",
-    }
-
-
-class TestCategorizeIssue:
-    def test_idle_issue(self):
-        issue = _make_issue(days_idle=70)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "idle"
-
-    def test_stale_issue(self):
-        issue = _make_issue(days_idle=45)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "stale"
-
-    def test_zombie_issue(self):
-        issue = _make_issue(days_old=100, days_idle=10, comments=0)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "zombie"
-
-    def test_unassigned_issue(self):
-        issue = _make_issue(assignees=[], days_old=5, days_idle=1)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "unassigned"
-
-    def test_assigned_issue(self):
-        issue = _make_issue(assignees=["alice"], days_old=5, days_idle=1)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "triage-needed"
-
-    def test_closeable_duplicate(self):
-        issue = _make_issue(labels=["duplicate"], days_old=5, days_idle=1)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "closeable"
-
-    def test_urgent_issue(self):
-        issue = _make_issue(labels=["p0-critical"], assignees=["bob"])
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "urgent"
-
-    def test_backlog_issue(self):
-        issue = _make_issue(labels=["p2-backlog"], assignees=["bob"])
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "backlog"
-
-    def test_bug_category(self):
-        issue = _make_issue(labels=["bug"], assignees=["bob"])
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["category"] == "bug"
-
-    def test_age_tracking(self):
-        issue = _make_issue(days_old=42, days_idle=7)
-        result = categorize_issue(issue, datetime.now(timezone.utc), 30, 60)
-        assert result["age_days"] >= 41
-        assert result["idle_days"] >= 6
-
-
-class TestGenerateReport:
-    def test_empty_report(self):
-        report = generate_report([])
-        assert report["total"] == 0
-        assert report["by_category"] == {}
-
-    def test_report_categorization(self):
-        issues = [
-            _make_issue(1, "idle", days_idle=70),
-            _make_issue(2, "stale", days_idle=40),
-            _make_issue(3, "recent", assignees=["alice"]),
-        ]
-        categorized = [categorize_issue(i, datetime.now(timezone.utc), 30, 60) for i in issues]
-        report = generate_report(categorized)
-        assert report["total"] == 3
-        assert "idle" in report["by_category"]
-        assert "stale" in report["by_category"]
-
-    def test_closeable_candidates(self):
-        issues = [
-            _make_issue(1, "old zombie", days_old=100, days_idle=100, comments=0),
-            _make_issue(2, "recent", assignees=["alice"]),
-        ]
-        categorized = [categorize_issue(i, datetime.now(timezone.utc), 30, 60) for i in issues]
-        report = generate_report(categorized)
-        assert len(report["closeable_candidates"]) >= 1
-        assert report["closeable_candidates"][0]["number"] == 1
-
-    def test_recommendations_generated(self):
-        issues = [_make_issue(1, days_idle=70)]
-        categorized = [categorize_issue(i, datetime.now(timezone.utc), 30, 60) for i in issues]
-        report = generate_report(categorized)
-        assert len(report["recommendations"]) > 0

tests/test_night_shift_prediction_report.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+
+REPORT = Path("reports/night-shift-prediction-2026-04-12.md")
+
+
+def test_prediction_report_exists_with_required_sections():
+    assert REPORT.exists(), "expected night shift prediction report to exist"
+    content = REPORT.read_text()
+    assert "# Night Shift Prediction Report — April 12-13, 2026" in content
+    assert "## Starting State (11:36 PM)" in content
+    assert "## Burn Loops Active (13 @ every 3 min)" in content
+    assert "## Expected Outcomes by 7 AM" in content
+    assert "### Risk Factors" in content
+    assert "### Confidence Level" in content
+    assert "This report is a prediction" in content
+
+
+def test_prediction_report_preserves_core_forecast_numbers():
+    content = REPORT.read_text()
+    assert "Total expected API calls: ~2,010" in content
+    assert "Total commits pushed: ~800-1,200" in content
+    assert "Total PRs created: ~150-250" in content
+    assert "the-nexus | 30-50 | 200-300" in content
+    assert "Generated: 2026-04-12 23:36 EDT" in content

tests/test_sync_branch_protection.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).parent.parent
+
+_spec = importlib.util.spec_from_file_location(
+    "sync_branch_protection_test",
+    PROJECT_ROOT / "scripts" / "sync_branch_protection.py",
+)
+_mod = importlib.util.module_from_spec(_spec)
+sys.modules["sync_branch_protection_test"] = _mod
+_spec.loader.exec_module(_mod)
+
+build_branch_protection_payload = _mod.build_branch_protection_payload
+
+
+def test_build_branch_protection_payload_enables_rebase_before_merge():
+    payload = build_branch_protection_payload(
+        "main",
+        {
+            "required_approvals": 1,
+            "dismiss_stale_approvals": True,
+            "require_ci_to_merge": False,
+            "block_deletions": True,
+            "block_force_push": True,
+            "block_on_outdated_branch": True,
+        },
+    )
+
+    assert payload["branch_name"] == "main"
+    assert payload["rule_name"] == "main"
+    assert payload["block_on_outdated_branch"] is True
+    assert payload["required_approvals"] == 1
+    assert payload["enable_status_check"] is False
+
+
+def test_the_nexus_branch_protection_config_requires_up_to_date_branch():
+    config = yaml.safe_load((PROJECT_ROOT / ".gitea" / "branch-protection" / "the-nexus.yml").read_text())
+    rules = config["rules"]
+    assert rules["block_on_outdated_branch"] is True