James (Architect) ─── reviews PRs, sets direction, ships features
  │
  ▼
Passion Agent (24/7 Mac Mini) ─── 92 modules, 109K LOC
  ├── Brain Cycle ─── 30min intervals, 60 cycles/day
  │     ├── Strategist → picks highest-value work
  │     ├── Scheduler → routes to right LLM backend
  │     └── Executor → spawns subprocess agents
  ├── 3 LLM Backends: Claude · DeepSeek · Gemini
  ├── 47 Managed Repos ─── 89.9% autonomous approval rate
  ├── Intel Radar ─── Reddit, HN, Bluesky, RSS
  ├── Career Engine ─── 6+ job APIs, auto-apply pipeline
  └── Memory System ─── somatic markers, narrative identity
        ▼
  PACT Dashboard ─── Agent command terminal, auto-select engine, useSSE streaming, 121 components, 695 tests, OWASP-hardened
        ▼
  Passion Memory MCP ─── Shared brain across all sessions

What makes this different: Memory persists across sessions via Passion Memory MCP. LLM routing by task type. Subprocess isolation per task. PR approval feedback shifts future prioritization. Zero human intervention from cycle start to merged PR.

Zero-denominator crashes in FCPXML time parsing — Final Cut Pro XML uses rational time notation (1001/30000s). Malformed files sent 0/0 framedurations causing crashes. Traced every division operation, added guards at the parsing boundary. 5 fixes, 7 new tests, 618 passing.

Per-frame memory allocation in animation loop — Function.prototype.bind() inside requestAnimationFrame was allocating ~60 objects/second. Cached the reference, extracted timing values to CSS custom properties. Eliminated ~3,600 unnecessary allocations per minute.

Context window management for autonomous agents — Tool outputs consumed 83% of context. Implemented observation masking (compress to structured summaries), sub-agent isolation (scoped context per task), and 70% utilization trigger for compression. Eliminated mid-task truncation entirely.

Iframe sandbox security — PACT Dashboard embeds external services. Every iframe gets sandbox="allow-scripts" only — no allow-same-origin, no allow-top-navigation. HTTPS-only allowlisted origins per OWASP A05:2021.

Envelope sanitization at API boundaries — YouTube API responses hit per-field sanitizers directly — any malformed envelope (missing items, oversized payloads, wrong types) bypassed validation entirely. Built a structural pre-validator: schema shape check before field-level processing. Catches CWE-20 (improper input validation), CWE-400 (uncontrolled resource consumption), CWE-754 (improper unusual condition checks). 23 new tests, full suite green.

Intelligent auto-selection for video embeds — Dashboard embedded videos fought for attention — multiple iframes loading simultaneously, competing for bandwidth, none contextually relevant. Built a viewport-aware selection engine: tracks scroll position, user interaction signals, and content adjacency to dynamically surface the most relevant embed. Combined with the auto-select rules engine refactor (extracted computeEntryTiming, freezeActivityMap, maxSeverity), the system now picks what matters. 323 auto-select + 381 rotation tests green.

Cinematic hero orchestration — The Royalty Protocol hero needed dynamic background video, scroll-triggered element reveals, and layered typography — all without fighting IntelDossier's real-time threat data. Solved with a staggered reveal choreography: video loads lazily with poster fallback, scroll-driven IntersectionObserver triggers per-section fade/translate sequences, and IntelDossier mounts only after the hero viewport exit. Zero layout shift, no competing paint cycles.

SSE data layer extraction — useSSEConnection was a 200-line monolith handling transport, parsing, reconnect, and domain state. Extracted core data-fetching logic into a focused useSSE hook, leaving useSSEConnection as a thin transport wrapper. Added first-class loading and error state UI — previously, failed streams showed nothing. Now downstream consumers get typed {data, error, isLoading} instead of raw EventSource management. Halved the surface area for SSE bugs.

Wheel-driven parallax engine — The lock screen hero needed cinematic depth without scroll-jacking the page. Built a 4-layer parallax system: each layer maps wheel delta to a displacement scaled by its depth factor (0.15× background → 0.6× foreground). Added ambient sine-wave drift (sin(t × 0.001)) so the scene breathes even idle, plus exponential momentum decay (velocity *= 0.95 per frame) that returns layers to center naturally. All offsets applied via CSS custom properties — zero layout thrash, single requestAnimationFrame loop for all layers.

Enum aliasing flake in test suite — tests/test_models.py intermittently failed because MarkerType.INCOMPLETE and MarkerType.TODO resolved to the same underlying value. Python enums alias duplicate values to the first-defined member, so MarkerType(1) always returned TODO regardless of which was asserted. The test expected INCOMPLETE by name but got TODO by identity. Fixed by asserting on .value instead of enum identity — correct behavior, stable test.

Async cleanup in React animation hooks — Three independent hooks (useIdleAnimations, useTerminal, useSSEConnection) had timer/reconnect leaks that survived unmount. useIdleAnimations had an untracked inner setTimeout chaining timers on every idle cycle — leaked chains on unmount. useTerminal's onerror handler scheduled reconnects after cleanup() had already run. useSSEConnection's onmessage captured stale closure state, making disconnect recovery dead code. Fixed all three with mountedRef/cleanedUpRef/connectedRef patterns — refs maintain correct state across async boundaries where closures can't.

Passion Agent's monolithic config — Single config.json at 92 modules is a merge conflict magnet. Should have split to per-module config at module 20. Config architecture decisions compound faster than code decisions.

SQLite access patterns — Right database choice, wrong abstraction. Raw SQL in 30+ modules instead of a thin repository pattern. The storage engine choice was right; the access pattern was the mistake.

Test strategy — 618 tests in fcpxml-mcp-server, mostly unit. But the bugs that shipped were integration-level — malformed XML that parsed fine individually but broke combined. Should have started with 10 integration tests using real FCPXML files.

PACT component explosion — 121 components, not enough composition. A <DataCard> with render props beats three single-use wrappers sharing 80% markup. Component count should go down as a codebase matures.

Learning Suite shared layout — 10 games with nearly identical shells (header, score, timer, explanation panel), each implemented independently. A shared <GameShell> with render props would have cut 40% of the markup. Noticed at game 4, kept shipping because each was a 2-hour build. Speed over architecture was the right call for the first 5; doubling down past that was the mistake.

Zero dependencies — no build step, no package.json, no CI. GitHub renders README.md as the profile page at github.com/DareDev256. Badge services inject dynamic images at render time. Passion Agent writes to two marker-delimited zones (daily status + showcase) on automated 30-minute brain cycles — everything outside markers requires human review.

1. Create a repo matching your GitHub username (docs)
2. Find-replace DareDev256 with your username across all badge URLs and GitHub links (~25 instances)
3. Edit signature.svg — swap hex colors (#6C63FF primary, #A78BFA secondary, #818CF8 tertiary), rewrite the four <text class="sub"> subtitles, update <text class="tag"> stats. Emblem center is at (130, 115) — all coordinates reference this origin
4. Push to main — GitHub renders within seconds
5. Verify at github.com/<your-username> — preview locally with grip README.md or any GFM-compatible renderer

Five files, no extras:

Two HTML comment-delimited zones are machine-writable by Passion Agent. Writes are idempotent — content between markers is fully replaced each cycle.

Raw endpoint: https://raw.githubusercontent.com/DareDev256/DareDev256/main/README.md

Integration: Poll the raw endpoint and parse between markers for machine-readable status. No auth required. Propagates within seconds of push.

Full design language, metrics sync map, and update playbooks in FOR_DARE.md.