Canonical policy: ops/director/jsoc-agent-policy.md
Routing matrix: ops/director/jsoc-routing-matrix.md
Specialist registry: ops/director/specialized-agent-registry-2026-04-12.md

Hermes — orchestration, routing, integration, verification, final handoff
Codex — primary coding lane for implementation, debugging, and refactors
Pi — permanent reinforcement, verification, product/UX review, and operator-readability lane
Hermes/Pi subagents — bounded specialist packets when leverage is clearly higher

Default flow:
  1. Hermes scopes and routes
  2. Pi frames first when product, UX, or verification clarity is the blocker
  3. Codex takes first coding pass
  4. All completed non-Hermes work routes to Pi
  5. Pi runs reinforcement review before signoff
  6. Pi disposition = pass, return, self-fix, or escalate
  7. Hermes verifies only after Pi passes the work forward

Selection rules:
  • Codex first for code changes by default
  • Pi first for product framing, evidence-first review, and UX-heavy work
  • Hermes/Pi subagents only for bounded parallel specialist work
  • Completed work from any non-Hermes lane goes to Pi before Hermes
  • Pi may self-fix bounded low-risk issues it can verify end to end
  • One task, one owner, no split authority

Hardware: Dell Optiplex
OS: WSL2 Ubuntu on Windows
Tailscale IP: 100.114.166.26

Runtime:
  OpenClaw v0.6.0
  Node v22.22.1
  Model: openrouter/minimax/minimax-m2.5
  Shell: bash

Recovery access:
  SSH → IP
  wsl
  systemctl --user restart openclaw-gateway

ReeseBrain vault: ~/ReeseBrain/ (active Obsidian vault)
Fallback path: ~/Documents/Obsidian Vault (symlinked)

Host: taild94591.ts.net
Tailscale IP: 100.81.215.55
LAN IP: 10.10.1.120
OS: Ubuntu 24.04.4 LTS, Kernel 6.17.0-19

Hardware (current → target):
  CPU: i5-9400F (6 cores, 2.9/4.1 GHz)
  RAM: 15GB DDR4 → 64GB
  GPU: GTX 1660 6GB → RTX 3090 24GB
  Disk: 913GB LVM (833GB available)
  NVIDIA: 570.211.01 / CUDA 12.8

Software:
  Docker 29.3.1 + Compose v5.1.1
  Node v24.14.1 (nvm) · npm 11.11.0 · Bun 1.3.11
  Python 3.12.3 · Git 2.43.0 · Ollama (systemd)

Security:
  SSH key-based auth only (password disabled)
  UFW active (SSH only)
  Key: ~/.ssh/id_nyxserver
  Wrapper: ssh-nyxserver

Workspace: ~/workspace/ (data/exports, projects, scripts, services)

Status: Setup complete. Awaiting RAM + GPU upgrades before final Hermes cutover.

Active services:
  SSH (port 22, key auth only)
  llama.cpp supergemma (port 9000)
  UFW · NVIDIA Persistence
  Prometheus (30-day retention)
  Grafana (http://10.10.1.120:3000, admin:hermes2026)
  Node Exporter · cAdvisor

Hermes staging:
  Repo: /home/reese/apps/hermes-agent
  Venv: /home/reese/apps/hermes-agent/.venv
  Home: /home/reese/.hermes
  Gateway: systemd user unit (enabled, intentionally inactive)

Bitcoin sidecar:
  nyx-electrs — restart-looping (RPC auth mismatch, known issue)

Helper commands:
  nyx-ops-status
  nyx-hermes-cutover-check
  nyx-hermes-gateway-preflight

Cutover readiness checks:
  • Restic verify cron + log freshness (<26h)
  • Timers enabled + active
  • Readiness snapshot (<45m threshold)
  • Restore-drill freshness (<192h / 8 days)
  • Gateway preflight: validates unit, checks platforms, checks credentials

Three-layer backup system:

Layer 1 — Syncthing (real-time):
  WSL2 ↔ NyxServer, LAN direct (tcp://10.10.1.120:22000)
  114,677 files synced (100%), 30-day versioning enabled
  Firewall: 22000/tcp, 22000/udp, 21027/udp

Layer 2 — Git (hourly):
  Bare repo: ~/backups/reesebrain.git
  Live checkout: ~/backups/reesebrain-live
  Scope: ReeseBrain vault only

Layer 3 — Restic (daily, 2 AM):
  Repo: ~/backups/restic-repo
  Scope: ReeseBrain, monitoring, projects, migration, .config, .ssh, /etc/ssh, /etc/ufw
  Size: 6.4GB (80,287 files)
  Retention: daily 7, weekly 4, monthly 12, auto-prune
  Verification: repo check + read-data-subset 1% + restore probe

Restore drill: Manual + scheduled, baseline fresh
Future: 9TB drive install → move restic to /mnt/backup

Active APIs:
  Kraken — LIVE trading (Hermes BTC/XMR)
  Google Calendar — authenticated, API scripts
  Google Workspace — integrated via Pi
  Brave Search — configured
  Firecrawl — web extraction backend
  OpenRouter — model routing
  OpenAI Codex — Hermes primary provider
  Anthropic Claude — API token active

Communication:
  Telegram — primary command/notification channel
    Bot token active (gateway restart-looping on token rejection)
    Home channel: 8723371505 (Reese Johnson DM)
    NYX AGENT group: -1003664281916
      Topic 12: inbox/cron
      Topic 27: Titan/finance
      Topic 31: ideas
      Topic 34: wins
      Topic 593: security
    Reesehapi group: -1003754098957

  Webhook: gateway enabled

MCP servers:
  reesebrain — filesystem access to vault
  time — local timezone America/Chicago

Key lesson: Assistant setup is infrastructure, not just prompts.

Core rules:
  1. Use only pieces needed for task — keep modular, narrow skills
  2. Save lesson when useful discovery made — turn into reusable artifact
  3. Summarize runs and keep clean path for next execution

Checkpoints matter:
  Long work not one blur — save state, summarize, keep next step obvious.

Memory architecture:
  Daily notes: memory/YYYY-MM-DD.md (raw logs)
  MEMORY.md: curated long-term (main session only)
  Write it down: "Remember this" → update memory or relevant file
  Learn lesson → update AGENTS.md, TOOLS.md, or skill
  Make mistake → document so future-you doesn't repeat

Core rule: Start with objective, source of truth, blocker, finish line — NOT implementation.

Before any AI-assisted task:
  1. State goal in one sentence
  2. Name source of truth
  3. List constraints and known risks
  4. Ask clarifying questions if fuzzy
  5. Decide what "done" means
  6. Execute
  7. Validate
  8. Capture lesson

What good looks like:
  • Fewer assumptions
  • More zoomed-out thinking
  • Better first-pass results
  • Closed loops

Anti-patterns:
  • Jumping to implementation without framing
  • Treating opinions as facts
  • Widening scope before data stability
  • Confusing motion with progress
  • Leaving work at "almost done"

Hermes execution sequence:
  1. Identify actual goal
  2. Identify source of truth or system
  3. Identify likely blocker or missing dependency
  4. Push back if request built on bad assumption

Source-first principle — when task touches data, dashboards, workflows:
  • What system is this in?
  • Where is source of truth?
  • What access do we have?
  • What changed recently?

If vague, sharpen it instead of wandering.
If blocked, give next best path, not a shrug.

Coach-back mode:
  After task, say what was unclear, what should be asked differently,
  what should be saved as reusable rule.

Blocker protocol:
  If blocked, give 3 alternates.

Good prompts:
  "What is fastest safe path?"
  "What source should we trust?"
  "What am I assuming that's wrong?"
  "What's missing?"
  "Show next best move"

Bad prompts:
  "Go figure it out"
  "Just make it work"
  "Try your best"

Standard prompt pattern (copy/paste ready):

"Here is the objective: [goal].
Here is the source of truth: [systems/data].
Here are known constraints: [time/data/ops].
Do not assume stakeholder statements are absolute truth.
First: ask clarifying questions.
Second: propose best strategy with tradeoffs.
Third: give execution plan with validation steps."

Personal operator protocol (daily):
  • What outcome is needed?
  • What is the source of truth?
  • What assumption breaks this?
  • What questions are unanswered?
  • What does "done" mean?

End-of-day closeout:
  • Wins shipped
  • Open loops
  • Biggest assumption risk
  • First action tomorrow

Priority 1 — Prompt quality under pressure:
  Pattern: jumping into build with incomplete framing
  Target: Goal → Constraints → Source → Questions → Plan → Execute

Priority 2 — Finish loops, not starts:
  Pattern: strong momentum on build, weaker closure
  Target: each task ends with validation + owner-ready output

Priority 3 — Scope control:
  Pattern: expanding breadth before data reliability locked
  Target: lock fundamentals first (category correctness, labeling), then scale

Priority 4 — Confidence & rhythm:
  Pattern: interpreting iteration friction as underperformance
  Target: measured weekly progression using objective checkpoints

4-week tactical plan:
  Week 1: Data integrity — finalize categories, fix trailing bug, validation checklist
  Week 2: Item-level intelligence — 90-day items, subtype clustering, booth summary
  Week 3: Decision layer — new dashboard, decision support for vendor intake
  Week 4: Operational hardening — prompt templates, error-review, runbook

Track weekly:
  • % tasks fully closed (implemented + validated + documented)
  • Rework count per task
  • Data quality error rate
  • Request-to-decision time
  • Reused SOP/template workflows vs ad hoc

Personal growth targets:
  • Cleaner framing of objectives
  • Finish more loops per week
  • Calm under pressure
  • Use AI as strategy partner, not just executor

Bottom line: Become elite at framing objectives, extracting right context,
shipping closed loops, compounding reusable workflows.

Location: /home/reese/projects/mission-control
Stack: Astro 5, React 19, Tailwind CSS v4, TypeScript, Vite, Sharp
Purpose: Central operational hub — knowledge, blog, system status
Output: Static site
Commands: npm run dev | build | preview | check | lint
Site URL: https://mission-control.local

Location: /home/reese/projects/agentwall
Purpose: Runtime control plane for AI agents — policy enforcement, containment, audit

Core capabilities:
  1. Inspect action
  2. Decide allow/deny/approve
  3. Route risky actions to human when needed
  4. Save evidence for audit

Features shipping:
  • Policy evaluation API
  • Provenance-aware decisions
  • SSRF/private-range blocking
  • Default-deny egress
  • DLP scanning
  • Human approval gate + persistent approval queue
  • Dashboard + incident simulation mode
  • Structured audit log
  • Two-layer console: Core (default) + Advanced

Integration: OpenClaw monitor-first
AgentWall URL: http://127.0.0.1:3015 (observe mode)
Exploring pivot: SOC/NOC control plane with blue-team + red-team capability

Location: /home/reese/projects/shared-lab
Purpose: Operator control plane and collaboration boundary

Roles:
  Hermes — operator, strategy, review
  Mercury — bounded execution support

Rules:
  1. Control boundary, not dumping ground
  2. Every task gets unique ID
  3. Specs in specs/
  4. Machine-readable state in state/
  5. Artifacts in outputs/, logs/, reviews/
  6. Revisions create new versions

Status flow: queued → in_progress → delivered → revision_requested → approved → complete → blocked

Location: 2231 Madison St, Clarksville, TN
Type: Multi-business hospitality/entertainment hub
Reese's role: Build AI systems to optimize the building's businesses

Key focus areas:
  • Cross-business automation
  • Lead capture
  • Booking/scheduling
  • Staff operations
  • Marketing optimization
  • Real-time dashboards

Status: Active work focus
Work hours: 0800-1700
Mercury prioritizes this for Reese

Type: Bounded workflow-intelligence layer
Knowledge base root: Projects/Acropolis/Index

Focus areas:
  • Workflow capture proposals
  • Correction/retry/skill-gap telemetry
  • Operator-first ranking
  • Runbook-first artifact generation

Canonical URL: http://10.10.1.69:3211/dashboard
Status: In progress — verify live before sharing URLs

Stage: Concept
Type: Personal AI swarm / opportunity engine

Core idea:
  AI swarm that researches user, scans web for opportunities,
  matches to skills/assets, proposes micro-businesses, keeps user in control
  through review/approval, uses budget to create value 24/7/365.

Stronger positioning:
  Controlled AI opportunity engine finding value projects matched to user's skills,
  helping turn best ones into approved revenue-producing actions.

Key risks to solve:
  1. Too broad — needs narrow wedge first
  2. Trust is the real product — people hate AI when random
  3. Personalization needs proof — what data, what private, how ranked
  4. Approval loop must be real — bounded workflows

Build first:
  One persona, one job-to-be-done, one opportunity source,
  one approval workflow, one KPI, smallest version, test.

First outcome:
  User profile → 3-5 ranked opportunities → user picks one →
  system drafts artifact → user approves

Type: Sidecar lane for event-driven trading
Rule: Thesis-backed only. No live execution without explicit approval.

Core idea: Trade events only when real, confirmed, still moving, clean instrument.
Don't chase headlines without price confirmation.

Event classes:
  Oil/geopolitics · Macro policy · Tariffs/trade · Earnings/guidance
  Weather/disasters · Credit/liquidity · Supply-chain · Regulatory/legal
  Positioning/squeeze

Decision gate (all must pass):
  Event confirmed · Market reacting · Move has follow-through
  Instrument liquid · Stop obvious · Reward ≥ 2R
  Net edge survives fees/slippage/tax

Confirmation stack:
  Official source → Major newswire → Price confirmation in related asset
  → Second-order confirmation (sector/ETF/futures) → Physical confirmation

Free data sources:
  BTC: Kraken/Coinbase/CoinGecko
  Equities/ETF: Alpaca/Twelve Data/Finnhub/Yahoo
  Macro: BLS/BEA/Fed/SEC/EIA/Treasury/Federal Register/NOAA/FEMA/USGS
  Headlines: SEC/Fed/EIA/CFTC RSS, GDELT
  Oil/geo: EIA, UKMTO, IMF, NOAA, USGS

Routing: All alerts → Telegram finance thread (topic 27)
Surveillance: Every 15 min, alerts only when confirmed + tradeable

Role: Durable second machine for Bitcoin infra, automation, data retention

Current state:
  SSH works (password disabled, root disabled)
  Bitcoin Knots synced · Electrs · Mempool · Lightning · BTC RPC Explorer
  n8n · ntfy (repaired)

Strategic framing (not random app zoo):
  1. Bitcoin infrastructure
  2. Automation/event processing node
  3. Shared storage/runbook/backup endpoint
  4. Incubator for one public open-source product

Strategic wedge — Bitcoin Ops Spine:
  Service watching node health, wallets, fees, mempool, confirmations,
  address activity, service failures → structured alerts to ntfy/Telegram + audit trail

Roadmap:
  Phase 1: Stabilize
  Phase 2: Integrate with workspace
  Phase 3: Build Bitcoin Ops Spine MVP

Non-goals: No random consumer apps, no GPU/LLM fantasies,
no money-touching without explicit review

Goal: Markdown-first research KB
  Ingest raw sources → compile structured notes/articles →
  run integrity linting → write artifacts back to repo

Priority workers:
  kb-source-distiller · kb-article-compiler · kb-linter-contradictions-gaps

Repository schema:
  raw/ — inbox, articles, papers, repos, datasets, images, transcripts
  compiled/ — sources, concepts, articles, index
  reports/ · slides/ · lint/ · config/ · evals/ · tmp/

Artifact types:
  Source Note — slug.md with summary, key claims, evidence, entities, open questions
  Concept Page — definition, subtopics, related, supporting sources
  Article — thesis, synthesis, evidence by source, tensions, implications
  Lint Report — summary, critical/high/medium/low issues, contradictions, next actions

Build order:
  1. kb-source-distiller + 30-example eval set
  2. kb-article-compiler + 15-example eval set
  3. kb-linter + 20-example eval set
  4. Then self-evolution

manim-video — Mathematical animation video generation
excalidraw — Diagram and whiteboard creation
p5js — Creative coding / generative art
ascii-art — ASCII art generation
ascii-video — ASCII video rendering
songwriting — AI-assisted songwriting and music creation

webhook-subscriptions — Webhook setup and management
tailscale — Tailscale VPN configuration
syncthing — File synchronization setup
password-ssh — SSH key management
wsl2-cutover — WSL2 migration procedures
nyxserver-prep — NyxServer preparation and staging

claude-code — Claude Code integration and usage
codex — OpenAI Codex agent operations
director-of-operations — Operational orchestration
hermes-agent — Hermes agent framework management
pi-worker-orchestration — Pi agent task delegation

arxiv — Academic paper search and analysis
blogwatcher — Blog monitoring and tracking
domain-intel — Domain intelligence gathering
duckduckgo-search — Web search operations
event-trading-sidecar — Event-driven trading research
polymarket — Prediction market analysis
sec-current-8k — SEC 8-K filing monitoring
xint-cli — Intelligence CLI tool

agentwall-kb-file-backed-probes — AgentWall knowledge base probes
agentwall-live-bringup — AgentWall deployment
agentwall-priority-buildout — AgentWall feature development
alpaca-paper-equities — Alpaca paper trading integration
operator-dashboard-bootstrap — Dashboard scaffolding
mission-control-heroui-migration — Mission Control UI migration
titan-profile-bootstrap — Titan trading bot setup

codebase-inspection — Repository analysis and exploration
github-auth — GitHub authentication management
code-review — Automated code review
pr-workflow — Pull request workflow management
repo-management — Repository administration

apple-notes — Apple Notes integration
apple-reminders — Apple Reminders sync
findmy — Find My device tracking
imessage — iMessage interaction

google-workspace — Google Workspace integration (Calendar, Drive, etc.)
linear — Linear project management
notion — Notion workspace
powerpoint — Presentation generation
ocr-and-documents — OCR and document processing

gif-search — GIF search and retrieval
heartmula — (media tool)
songsee — Song identification
youtube-content — YouTube content analysis

obsidian — Obsidian vault management
markdown-kb-compiler — Markdown knowledge base compilation (multiple variants)

skill-factory — Meta-skill for creating new skills
hermes-dojo — Hermes self-improvement system
mcporter — MCP server management
native-mcp — Native MCP integration
godmode — Red-teaming capability
himalaya — Email via CLI
telegram-cron-inbox — Telegram cron job inbox
daily-agentwall-cybersecurity — Daily security monitoring

data-science: jupyter-live-kernel — Live Jupyter kernel
gaming: pokemon-player, minecraft-modpack-server — Game automation
smart-home: openhue — Philips Hue control
social-media: xitter — Twitter/X interaction
leisure: find-nearby — Local discovery
music-creation: songwriting — AI music composition
inference-sh: CLI — Inference.sh CLI tool

Ares tracks:
  • Sleep quality and duration
  • CPAP therapy compliance and efficacy
  • Recovery readiness (HRV, RHR, respiratory)
  • Training volume and progression
  • Bodyweight trends
  • Daily adherence scores

Data sources: Apple Health exports, CPAP data exports, InBody scans
Goal: Turn raw health data into useful trends and actionable recommendations

Reminder rules (event-driven, not nagging):
  • No Apple Health upload 7+ days
  • No CPAP upload 7+ days
  • Weekly training/recovery review due
  • Recovery trend slipped multiple days
  • Sleep trend degrading
  • RHR elevated + HRV suppressed
  Do NOT repeat reminder within 48h unless situation worsens

Weight: 169.0 lb
Body Fat: 11.6%
Skeletal Muscle Mass: 87.5 lb
Lean Body Mass: 149.5 lb
Body Fat Mass: 19.5 lb
BMI: 27.3
Visceral Fat Level: 1
ECW/TBW: 0.349
Total Body Water: 70.5 lb
Dry Lean Mass: 41.0 lb
BMR: 1834 kcal

Segmental lean:
  Right Arm: 8.40 lb (121.9%)
  Left Arm: 8.51 lb (123.3%)
  Trunk: 64.7 lb (117.7%)
  Right Leg: 22.05 lb (115.2%)
  Left Leg: 22.44 lb (117.0%)

Notes: Strong segmental lean. Trunk fat concentration visible.
Use InBody scans as checkpoints — compare muscle/fat against recovery/training.

Program: Mountain Dog Diet "Ares" by John Meadows
URL: https://mountaindogdiet.com/programs/ares/
Structure: 5-day/week push/pull/legs direction
Style: Mike Mentzer HIT-style preference layered on top

Program notes:
  • 4-6 days/week base, extra days optional (based on recovery)
  • Warns against heavy direct arm days on top of base volume
  • High-intensity technique waving: drop sets, iso holds, forced reps,
    partials, rest/pause
  • More chest/back later phases, less direct arms later

Ares guidance for Reese:
  • Adapt spirit to 5-day structure
  • Prioritize recovery/sleep/CPAP/HRV/RHR/adherence over pure effort
  • Avoid junk volume or heavy arms if recovery says no
  • Training should fit: bodybuilding, joint health, long-term adherence
  • High intensity, low volume emphasis
  • Recovery as primary constraint
  • Data-driven adjustments from health metrics

Last Apple Health upload: None
Last CPAP upload: None
Current program: John Meadows Ares (5-day push/pull/legs, phase TBD)

Baselines (pending data):
  Resting heart rate: TBD
  HRV: TBD
  Sleep hours: TBD
  Weight: 169.0 lb (as of 2026-03-19)

Trend state:
  Recovery: unknown
  Sleep: unknown
  Training: unknown
  Weight: baseline

Active alerts: None
Status: Framework ready, awaiting health data uploads to establish trends

Status: LIVE TRADING on Kraken
Pairs: BTC/USD, XMR/USD
Strategy: Multi-timeframe confluence
Frequency: Every 5 minutes
Model: minimax-m2.5

Cron jobs:
  Hermes Trader — */5 (every 5 min)
  Morning Briefing — 5:30 AM CDT (calendar/weather/BTC via Telegram)

Rules:
  • Thesis-backed only
  • No live execution without explicit approval (for new positions)
  • TradingAgents = read-only research sidecar, NOT for live trading
  • Tax-aware trading preferences
  • Cannot spend money or make withdrawals without asking

Trading history highlights:
  2026-03-08: Authorized Hermes to trade, consolidated portfolio to USD + XMR + BTC
  2026-03-10: BTC buy signal at $69,708 (RISK_ON_EXPANSION regime)
  2026-03-11: Executed BTC @ $70,333, ETH @ $2,061, SOL @ $87
  Key bug: Kraken API requires raw binary SHA256 for API-Sign, NOT hex

Type: Sidecar lane for event-driven trading
Not the whole system — needs trend, momentum, mean reversion, hedging playbooks too.

Core idea:
  Trade events only when real, confirmed, still moving, clean instrument.
  Don't chase headlines without price confirmation.

Event classes:
  Oil/geopolitics · Macro policy · Tariffs/trade · Earnings/guidance
  Weather/disasters · Credit/liquidity · Supply-chain · Regulatory/legal
  Positioning/squeeze

Decision gate (ALL must pass):
  ✔ Event confirmed
  ✔ Market reacting
  ✔ Move has follow-through
  ✔ Instrument liquid
  ✔ Stop obvious
  ✔ Reward ≥ 2R
  ✔ Net edge survives fees/slippage/tax

Confirmation stack:
  Official source → Major newswire → Price confirmation in related asset
  → Second-order confirmation → Physical confirmation

BTC/Crypto:
  Kraken · Coinbase · CoinGecko (free API)

Equities/ETF:
  Alpaca (paper trading approved) · Twelve Data · Finnhub · Yahoo Finance

Macro/Official:
  BLS · BEA · Fed · SEC · EIA · Treasury · Federal Register
  NOAA · FEMA · USGS

Headlines/Events:
  SEC/Fed/EIA/CFTC RSS feeds · GDELT

Oil/Geopolitical:
  EIA · UKMTO · IMF · NOAA · USGS

Routing: All alerts → Telegram finance thread (topic 27)
Event surveillance: Every 15 min
Alerts: Only when confirmed + tradeable
Known constraints: Rate limits, best-effort sources, selective to avoid noise

Active services:
  Bitcoin Knots (synced) · Electrs · Mempool · Lightning (LND)
  BTC RPC Explorer · n8n · ntfy

Strategic wedge — Bitcoin Ops Spine:
  Monitor: node health, wallets, fees, mempool, confirmations,
  address activity, service failures
  Alert: structured → ntfy/Telegram + audit trail
  Future: open-source product

Bitcoin custody: Air-gapped (Coldcard)
Lightning: Layer available via LND

Non-goals:
  No random consumer apps
  No GPU/LLM on Umbrel
  No money-touching without explicit review

Location: /home/reese/ReeseBrain/
Type: Obsidian vault — active operator memory
Fallback: ~/Documents/Obsidian Vault (symlinked)

Directory structure:
  Getting Started/ — Setup guides, communication style
  Systems/ — Agent docs, technical stack, operating standards
  Projects/ — Project notes (NyxServer, 2231, Acropolis, HIM, Titan, Umbrel, KB Compiler)
  Daily Notes/ — Daily journaling (YYYY-MM/YYYY-MM-DD.md format)
  Recovered/ — Recovered agent configs (Ares)
  Trading.md — (placeholder)
  AGENTS.md — Vault context and operating rules

Rules:
  • Preserve Obsidian wiki-link style: [[Systems/Agent Overview]]
  • Don't reorganize vault unless explicitly asked
  • Prefer updating existing notes over creating duplicates
  • Keep notes simple, readable, durable
  • Vault is active operator memory, not scratchpad

Structure: Daily Notes/YYYY-MM/YYYY-MM-DD.md
Template sections:
  Morning — weather, BTC price, priority
  Decisions Made
  Insights/Lessons
  Tasks Completed
  Tasks For Tomorrow
  Notes
Tags: #daily #YYYY-MM #meeting #decision #lesson

Key daily notes:
  2026-03-08: First multi-agent day, authorized Hermes trading, 4 sub-agents created
  2026-03-09–13: Trading signal logs (BTC/XMR bearish → RISK_ON_EXPANSION)
  2026-03-31: NyxServer setup complete — Docker, monitoring, backup, Hermes staged
  2026-04-01: NyxServer overnight ops — 5 hardening runs, cutover checks, preflight
  2026-04-02: Vault sync confirmed, Tailscale on nyxserver online

Style: Direct, brief, opinionated, no corporate fluff, humor acceptable
Autonomy: Execute low risk without permission, ask for high risk
Can create accounts but cannot spend money

Red lines:
  No tweeting · No cold DMs · No withdrawals/deposits from trading accounts

Communication:
  Answer first · Be direct · Be brief · Skip basics · No hedging

Goals: Leverage, distribution, positioning, speed

Profile: Navy veteran, Clarksville TN, systems thinker

Environment: WSL2 on Reese's PC
  AgentWall: /home/reese/projects/agentwall
  Nyxserver: 10.10.1.120, Ubuntu 24.04

Telegram routing:
  NYX AGENT threads with topic assignments (12/27/31/34/593)

JSOC model:
  Hermes = sole orchestrator
  Codex = primary technical execution lane
  Pi = reinforcement, verification, product review, and operator clarity lane
  Hermes/Pi subagents = bounded specialist support only
  Completed non-Hermes work = Pi review before Hermes finalization

Focus: Reinforcement review, verification pressure-testing, product/UX critique
Model routing: gpt-5.4 default, gpt-5.3-codex for coding route, medium reasoning
Autonomous by default, notify only on trading changes

Current priorities:
  • Catch fake-success signals before signoff
  • Double-check completed work from other agents
  • Convert repeated mistakes into memory/skill updates
  • Dedicated Pi gateway still blocked by shared Telegram token + webhook port conflict

Skills:
  pi-review-lane — findings-first reinforcement review with bounded specialist checks
  pi-learning-loop — convert durable review findings into memory, skills, or routing updates
  operator-core — Initiative, verification, blocker-first execution
  telegram-bot-ops — Telegram bot operations
  hermes-dev — Hermes development/maintenance
  google-workspace — Google Workspace API integration

Mission Control:
  Review lane feed: ops/director/pi-review-lane.json
  Disposition plan: ops/director/pi-review-disposition-plan-2026-04-13.md
  Packet manager: npm run pi-review -- submit|review|finalize|resubmit

Extensions: reese-studio, pi-pi, agent-chain, pure-focus
Themes: midnight-glass, catppuccin-mocha, dracula, tokyo-night, rose-pine

Contingency plan — documented
Morning briefing automation — 5:30 AM CDT, Telegram delivery
Brave Search integration — configured
17 skills across agents — operational
ReeseBrain vault — complete, synced, backed up 3 layers
NyxServer Phase 1 — base setup complete
NyxServer Phase 2 — Hermes staging complete
Multi-agent system — Mercury, Athena, Vulcan, Hermes, Apollo operational
Hermes live trading — BTC/XMR on Kraken
Syncthing — 100% real-time sync WSL2 ↔ NyxServer
Monitoring stack — Prometheus/Grafana/node-exporter/cAdvisor live
Backup system — 3-layer (Syncthing + Git + Restic) operational
InBody baseline — 169 lb, 11.6% BF, 87.5 lb SMM established

Active issues:
  • Telegram bot token rejected by server (gateway restart-looping)
  • nyx-electrs restart-looping (RPC auth mismatch)
  • Gateway preflight: needs-config (no messaging platform enabled on NyxServer)
  • Hermes doctor warnings: Nous Portal not logged in, codex CLI not installed,
    honcho not configured, image_gen/rl optional keys missing

Pending hardware:
  • NyxServer RAM upgrade (15GB → 64GB)
  • NyxServer GPU upgrade (GTX 1660 → RTX 3090)
  • Optional 9TB backup drive

Backlog:
  • Install Tailscale on RJPC Windows
  • Mission Control reliability improvements
  • Move restic repo to 9TB drive
  • Add GPU exporter to monitoring
  • Grafana alerts configuration
  • Daily status digest
  • Final Hermes cutover to NyxServer (blocked on hardware)

Why Astro, React islands, and Tailwind v4 are a better fit for a fast, structured operational site.
Published: Thu Apr 09 2026
Read time: 1 min

Tailwind v4 plus Vite keeps the new Mission Control site precise, fast, and easy to iterate.
Published: Thu Apr 09 2026
Read time: 1 min