Compare commits
1 Commits
issue-510-
...
feat/622-t
| Author | SHA1 | Date | |
|---|---|---|---|
| 89e46680df |
@@ -1,359 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Context Overflow Guard Script
|
||||
Issue #510: [Robustness] Context overflow automation — auto-summarize and commit
|
||||
|
||||
Monitors tmux pane context levels and triggers actions at thresholds:
|
||||
- 60%: Send summarization + commit prompt
|
||||
- 80%: URGENT force commit, restart fresh with summary
|
||||
- Logs context levels to tmux-state.json
|
||||
|
||||
Usage:
|
||||
python3 context-overflow-guard.py # Run once
|
||||
python3 context-overflow-guard.py --daemon # Run continuously
|
||||
python3 context-overflow-guard.py --status # Show current context levels
|
||||
"""
|
||||
|
||||
import os, sys, json, subprocess, time, re
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
# Configuration
|
||||
LOG_DIR = Path.home() / ".local" / "timmy" / "fleet-health"
|
||||
STATE_FILE = LOG_DIR / "tmux-state.json"
|
||||
LOG_FILE = LOG_DIR / "context-overflow.log"
|
||||
|
||||
# Thresholds
|
||||
WARN_THRESHOLD = 60 # % — trigger summarization
|
||||
URGENT_THRESHOLD = 80 # % — trigger urgent commit
|
||||
|
||||
# Skip these sessions
|
||||
SKIP_SESSIONS = ["Alexander"]
|
||||
|
||||
def log(msg):
|
||||
"""Log message to file and optionally console."""
|
||||
timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
|
||||
log_entry = "[" + timestamp + "] " + msg
|
||||
|
||||
LOG_DIR.mkdir(parents=True, exist_ok=True)
|
||||
with open(LOG_FILE, "a") as f:
|
||||
f.write(log_entry + "\n")
|
||||
|
||||
if "--quiet" not in sys.argv:
|
||||
print(log_entry)
|
||||
|
||||
def run_tmux(cmd):
|
||||
"""Run tmux command and return output."""
|
||||
try:
|
||||
result = subprocess.run(
|
||||
"tmux " + cmd,
|
||||
shell=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=10
|
||||
)
|
||||
return result.stdout.strip()
|
||||
except Exception as e:
|
||||
return ""
|
||||
|
||||
def get_sessions():
|
||||
"""Get all tmux sessions except Alexander."""
|
||||
output = run_tmux("list-sessions -F '#{session_name}'")
|
||||
if not output:
|
||||
return []
|
||||
|
||||
sessions = []
|
||||
for line in output.split("\n"):
|
||||
session = line.strip()
|
||||
if session and session not in SKIP_SESSIONS:
|
||||
sessions.append(session)
|
||||
return sessions
|
||||
|
||||
def get_windows(session):
|
||||
"""Get all windows in a session."""
|
||||
output = run_tmux("list-windows -t " + session + " -F '#{window_index}:#{window_name}'")
|
||||
if not output:
|
||||
return []
|
||||
|
||||
windows = []
|
||||
for line in output.split("\n"):
|
||||
if ":" in line:
|
||||
idx, name = line.split(":", 1)
|
||||
windows.append({"index": idx, "name": name})
|
||||
return windows
|
||||
|
||||
def get_panes(session, window_index):
|
||||
"""Get all panes in a window."""
|
||||
target = session + ":" + window_index
|
||||
output = run_tmux("list-panes -t " + target + " -F '#{pane_index}'")
|
||||
if not output:
|
||||
return []
|
||||
|
||||
panes = []
|
||||
for line in output.split("\n"):
|
||||
pane = line.strip()
|
||||
if pane:
|
||||
panes.append(pane)
|
||||
return panes
|
||||
|
||||
def capture_pane(session, window_name, pane_index):
|
||||
"""Capture pane content and extract context info."""
|
||||
target = session + ":" + window_name + "." + pane_index
|
||||
output = run_tmux("capture-pane -t " + target + " -p 2>&1")
|
||||
|
||||
if not output:
|
||||
return None
|
||||
|
||||
# Look for context bar pattern: ⚕ model | used/total | % | time
|
||||
# Example: ⚕ mimo-v2-pro | 45,230/131,072 | 34% | 12m remaining
|
||||
context_pattern = r"⚕\s+([^|]+)\|\s*([\d,]+)/([\d,]+)\|\s*(\d+)%\|"
|
||||
|
||||
lines = output.split("\n")
|
||||
for line in lines:
|
||||
match = re.search(context_pattern, line)
|
||||
if match:
|
||||
model = match.group(1).strip()
|
||||
used_str = match.group(2).replace(",", "")
|
||||
total_str = match.group(3).replace(",", "")
|
||||
percent = int(match.group(4))
|
||||
|
||||
try:
|
||||
used = int(used_str)
|
||||
total = int(total_str)
|
||||
except:
|
||||
used = 0
|
||||
total = 0
|
||||
|
||||
return {
|
||||
"model": model,
|
||||
"used": used,
|
||||
"total": total,
|
||||
"percent": percent,
|
||||
"raw_line": line.strip()
|
||||
}
|
||||
|
||||
# Alternative pattern: just look for percentage in context-like lines
|
||||
percent_pattern = r"(\d+)%"
|
||||
for line in lines:
|
||||
if "⚕" in line or "remaining" in line.lower() or "context" in line.lower():
|
||||
match = re.search(percent_pattern, line)
|
||||
if match:
|
||||
percent = int(match.group(1))
|
||||
return {
|
||||
"model": "unknown",
|
||||
"used": 0,
|
||||
"total": 0,
|
||||
"percent": percent,
|
||||
"raw_line": line.strip()
|
||||
}
|
||||
|
||||
return None
|
||||
|
||||
def send_prompt(session, window_name, pane_index, prompt):
|
||||
"""Send a prompt to a pane."""
|
||||
target = session + ":" + window_name + "." + pane_index
|
||||
|
||||
# Escape quotes in prompt
|
||||
escaped_prompt = prompt.replace('"', '\\"')
|
||||
|
||||
cmd = 'send-keys -t ' + target + ' "/queue ' + escaped_prompt + '" Enter'
|
||||
result = run_tmux(cmd)
|
||||
|
||||
log("Sent prompt to " + target + ": " + prompt[:50] + "...")
|
||||
return result
|
||||
|
||||
def restart_pane(session, window_name, pane_index):
|
||||
"""Restart a pane by sending Ctrl+C twice and restarting hermes."""
|
||||
target = session + ":" + window_name + "." + pane_index
|
||||
|
||||
# Send Ctrl+C twice to exit
|
||||
run_tmux("send-keys -t " + target + " C-c")
|
||||
time.sleep(0.5)
|
||||
run_tmux("send-keys -t " + target + " C-c")
|
||||
time.sleep(1)
|
||||
|
||||
# Try to detect profile from process
|
||||
pid_cmd = "list-panes -t " + target + " -F '#{pane_pid}'"
|
||||
pid = run_tmux(pid_cmd)
|
||||
|
||||
if pid:
|
||||
# Try to find hermes process with profile
|
||||
try:
|
||||
ps_result = subprocess.run(
|
||||
"ps aux | grep " + pid + " | grep hermes | grep -v grep",
|
||||
shell=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=5
|
||||
)
|
||||
ps_line = ps_result.stdout.strip()
|
||||
|
||||
# Look for -p profile flag
|
||||
profile_match = re.search(r"-p\s+(\S+)", ps_line)
|
||||
if profile_match:
|
||||
profile = profile_match.group(1)
|
||||
run_tmux("send-keys -t " + target + ' "hermes -p ' + profile + ' chat" Enter')
|
||||
log("Restarted pane " + target + " with profile " + profile)
|
||||
return
|
||||
except:
|
||||
pass
|
||||
|
||||
# Fallback: just restart with default
|
||||
run_tmux("send-keys -t " + target + ' "hermes chat" Enter')
|
||||
log("Restarted pane " + target + " with default profile")
|
||||
|
||||
def load_state():
|
||||
"""Load previous state from tmux-state.json."""
|
||||
if STATE_FILE.exists():
|
||||
try:
|
||||
with open(STATE_FILE) as f:
|
||||
return json.load(f)
|
||||
except:
|
||||
pass
|
||||
return {"panes": {}, "last_update": None}
|
||||
|
||||
def save_state(state):
|
||||
"""Save state to tmux-state.json."""
|
||||
LOG_DIR.mkdir(parents=True, exist_ok=True)
|
||||
state["last_update"] = datetime.now(timezone.utc).isoformat()
|
||||
|
||||
with open(STATE_FILE, "w") as f:
|
||||
json.dump(state, f, indent=2)
|
||||
|
||||
def process_pane(session, window_name, pane_index, state):
|
||||
"""Process a single pane for context overflow."""
|
||||
target = session + ":" + window_name + "." + pane_index
|
||||
|
||||
# Capture pane
|
||||
context_info = capture_pane(session, window_name, pane_index)
|
||||
if not context_info:
|
||||
return
|
||||
|
||||
percent = context_info["percent"]
|
||||
|
||||
# Update state
|
||||
if "panes" not in state:
|
||||
state["panes"] = {}
|
||||
|
||||
state["panes"][target] = {
|
||||
"context_percent": percent,
|
||||
"model": context_info["model"],
|
||||
"used": context_info["used"],
|
||||
"total": context_info["total"],
|
||||
"last_check": datetime.now(timezone.utc).isoformat(),
|
||||
"raw_line": context_info["raw_line"]
|
||||
}
|
||||
|
||||
# Check thresholds
|
||||
if percent >= URGENT_THRESHOLD:
|
||||
log("URGENT: " + target + " at " + str(percent) + "% — forcing commit and restart")
|
||||
|
||||
# Send urgent commit prompt
|
||||
urgent_prompt = "URGENT: Context at " + str(percent) + "%. Commit all work NOW, summarize progress, then restart fresh."
|
||||
send_prompt(session, window_name, pane_index, urgent_prompt)
|
||||
|
||||
# Wait a bit for the prompt to be processed
|
||||
time.sleep(2)
|
||||
|
||||
# Restart the pane
|
||||
restart_pane(session, window_name, pane_index)
|
||||
|
||||
elif percent >= WARN_THRESHOLD:
|
||||
log("WARN: " + target + " at " + str(percent) + "% — sending summarization prompt")
|
||||
|
||||
# Send summarization prompt
|
||||
warn_prompt = "Context filling up (" + str(percent) + "%). Summarize current work, commit everything, and prepare for fresh session."
|
||||
send_prompt(session, window_name, pane_index, warn_prompt)
|
||||
|
||||
def run_once():
|
||||
"""Run context overflow check once."""
|
||||
log("=== Context Overflow Check ===")
|
||||
|
||||
state = load_state()
|
||||
sessions = get_sessions()
|
||||
|
||||
if not sessions:
|
||||
log("No tmux sessions found")
|
||||
return
|
||||
|
||||
total_panes = 0
|
||||
warned_panes = 0
|
||||
urgent_panes = 0
|
||||
|
||||
for session in sessions:
|
||||
windows = get_windows(session)
|
||||
|
||||
for window in windows:
|
||||
window_name = window["name"]
|
||||
panes = get_panes(session, window["index"])
|
||||
|
||||
for pane_index in panes:
|
||||
total_panes += 1
|
||||
process_pane(session, window_name, pane_index, state)
|
||||
|
||||
target = session + ":" + window_name + "." + pane_index
|
||||
if target in state.get("panes", {}):
|
||||
percent = state["panes"][target].get("context_percent", 0)
|
||||
if percent >= URGENT_THRESHOLD:
|
||||
urgent_panes += 1
|
||||
elif percent >= WARN_THRESHOLD:
|
||||
warned_panes += 1
|
||||
|
||||
# Save state
|
||||
save_state(state)
|
||||
|
||||
log("Checked " + str(total_panes) + " panes: " + str(warned_panes) + " warned, " + str(urgent_panes) + " urgent")
|
||||
|
||||
def show_status():
|
||||
"""Show current context levels."""
|
||||
state = load_state()
|
||||
|
||||
if not state.get("panes"):
|
||||
print("No context data available. Run without --status first.")
|
||||
return
|
||||
|
||||
print("Context Levels (last updated: " + str(state.get("last_update", "unknown")) + ")")
|
||||
print("=" * 80)
|
||||
|
||||
# Sort by context percentage (highest first)
|
||||
panes = sorted(state["panes"].items(), key=lambda x: x[1].get("context_percent", 0), reverse=True)
|
||||
|
||||
for target, info in panes:
|
||||
percent = info.get("context_percent", 0)
|
||||
model = info.get("model", "unknown")
|
||||
|
||||
# Color coding
|
||||
if percent >= URGENT_THRESHOLD:
|
||||
status = "URGENT"
|
||||
elif percent >= WARN_THRESHOLD:
|
||||
status = "WARN"
|
||||
else:
|
||||
status = "OK"
|
||||
|
||||
print(target.ljust(30) + " " + str(percent).rjust(3) + "% " + status.ljust(7) + " " + model)
|
||||
|
||||
def daemon_mode():
|
||||
"""Run continuously."""
|
||||
log("Starting context overflow daemon (check every 60s)")
|
||||
|
||||
while True:
|
||||
try:
|
||||
run_once()
|
||||
time.sleep(60)
|
||||
except KeyboardInterrupt:
|
||||
log("Daemon stopped by user")
|
||||
break
|
||||
except Exception as e:
|
||||
log("Error: " + str(e))
|
||||
time.sleep(10)
|
||||
|
||||
def main():
|
||||
if "--status" in sys.argv:
|
||||
show_status()
|
||||
elif "--daemon" in sys.argv:
|
||||
daemon_mode()
|
||||
else:
|
||||
run_once()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,4 +1,3 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Full Nostr agent-to-agent communication demo - FINAL WORKING
|
||||
"""
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Soul Eval Gate — The Conscience of the Training Pipeline
|
||||
|
||||
|
||||
@@ -196,37 +196,7 @@
|
||||
"paused_reason": null,
|
||||
"skills": [],
|
||||
"skill": null
|
||||
},
|
||||
{
|
||||
"id": "tmux-supervisor-513",
|
||||
"name": "Autonomous Cron Supervisor",
|
||||
"prompt": "Load the tmux-supervisor skill and execute the monitoring protocol.\n\nCheck both `dev` and `timmy` tmux sessions for idle panes. Only send Telegram notifications on actionable events (idle, overflow, failure). Be silent when all agents are working.\n\nSteps:\n1. List all tmux sessions (skip 'Alexander')\n2. For each session, list windows and panes\n3. Capture each pane and classify state (idle vs active)\n4. For idle panes: read context, craft context-aware prompt\n5. Send /queue prompts to idle panes\n6. Verify prompts landed\n7. Only notify via Telegram if:\n - A pane was prompted (idle detected)\n - A pane shows context overflow (>80%)\n - A pane is stuck or crashed\n8. If all panes are active: respond with [SILENT]",
|
||||
"schedule": {
|
||||
"kind": "interval",
|
||||
"minutes": 7,
|
||||
"display": "every 7m"
|
||||
},
|
||||
"schedule_display": "every 7m",
|
||||
"repeat": {
|
||||
"times": null,
|
||||
"completed": 0
|
||||
},
|
||||
"enabled": true,
|
||||
"created_at": "2026-04-15T03:00:00.000000+00:00",
|
||||
"next_run_at": null,
|
||||
"last_run_at": null,
|
||||
"last_status": null,
|
||||
"last_error": null,
|
||||
"deliver": "telegram",
|
||||
"origin": null,
|
||||
"state": "scheduled",
|
||||
"paused_at": null,
|
||||
"paused_reason": null,
|
||||
"skills": [
|
||||
"tmux-supervisor"
|
||||
],
|
||||
"skill": "tmux-supervisor"
|
||||
}
|
||||
],
|
||||
"updated_at": "2026-04-13T02:00:00+00:00"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
- name: Nightly Pipeline Scheduler
|
||||
schedule: '*/30 18-23,0-8 * * *' # Every 30 min, off-peak hours only
|
||||
tasks:
|
||||
- name: Check and start pipelines
|
||||
shell: "bash scripts/nightly-pipeline-scheduler.sh"
|
||||
env:
|
||||
PIPELINE_TOKEN_LIMIT: "500000"
|
||||
PIPELINE_PEAK_START: "9"
|
||||
PIPELINE_PEAK_END: "18"
|
||||
@@ -1,4 +1,3 @@
|
||||
#!/usr/bin/env python3
|
||||
import json
|
||||
from hermes_tools import browser_navigate, browser_vision
|
||||
|
||||
|
||||
@@ -1,4 +1,3 @@
|
||||
#!/usr/bin/env python3
|
||||
import json
|
||||
from hermes_tools import browser_navigate, browser_vision
|
||||
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
# Nightly Pipeline Scheduler
|
||||
|
||||
Auto-starts batch pipelines when inference is available.
|
||||
|
||||
## What It Does
|
||||
|
||||
1. Checks inference provider health (OpenRouter, Ollama, RunPod)
|
||||
2. Checks if it's off-peak hours (configurable, default: after 6PM)
|
||||
3. Checks interactive session load (don't fight with live users)
|
||||
4. Checks daily token budget (configurable limit)
|
||||
5. Starts the highest-priority incomplete pipeline
|
||||
|
||||
## Pipeline Priority Order
|
||||
|
||||
| Priority | Pipeline | Deps | Max Tokens |
|
||||
|----------|----------|------|------------|
|
||||
| 1 | playground-factory | none | 100,000 |
|
||||
| 2 | training-factory | none | 150,000 |
|
||||
| 3 | knowledge-mine | training-factory running | 80,000 |
|
||||
| 4 | adversary | knowledge-mine running | 50,000 |
|
||||
| 5 | codebase-genome | none | 120,000 |
|
||||
|
||||
## Usage
|
||||
|
||||
```bash
|
||||
# Normal run (used by cron)
|
||||
./scripts/nightly-pipeline-scheduler.sh
|
||||
|
||||
# Dry run (show what would start)
|
||||
./scripts/nightly-pipeline-scheduler.sh --dry-run
|
||||
|
||||
# Status report
|
||||
./scripts/nightly-pipeline-scheduler.sh --status
|
||||
|
||||
# Force start during peak hours
|
||||
./scripts/nightly-pipeline-scheduler.sh --force
|
||||
```
|
||||
|
||||
## Configuration
|
||||
|
||||
Set via environment variables:
|
||||
- `PIPELINE_TOKEN_LIMIT`: Daily token budget (default: 500,000)
|
||||
- `PIPELINE_PEAK_START`: Peak hours start (default: 9)
|
||||
- `PIPELINE_PEAK_END`: Peak hours end (default: 18)
|
||||
- `HERMES_HOME`: Hermes home directory (default: ~/.hermes)
|
||||
|
||||
## Cron
|
||||
|
||||
Runs every 30 minutes. Off-peak only (unless --force).
|
||||
See `cron/pipeline-scheduler.yml`.
|
||||
@@ -1,383 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
# nightly-pipeline-scheduler.sh — Auto-start batch pipelines when inference is available.
|
||||
#
|
||||
# Checks provider health, pipeline progress, token budget, and interactive load.
|
||||
# Starts the highest-priority incomplete pipeline that can run.
|
||||
#
|
||||
# Usage:
|
||||
# ./scripts/nightly-pipeline-scheduler.sh # Normal run
|
||||
# ./scripts/nightly-pipeline-scheduler.sh --dry-run # Show what would start
|
||||
# ./scripts/nightly-pipeline-scheduler.sh --status # Pipeline status report
|
||||
|
||||
set -euo pipefail
|
||||
|
||||
# --- Configuration ---
|
||||
HERMES_HOME="${HERMES_HOME:-$HOME/.hermes}"
|
||||
BUDGET_FILE="${HERMES_HOME}/pipeline_budget.json"
|
||||
STATE_FILE="${HERMES_HOME}/pipeline_state.json"
|
||||
LOG_FILE="${HERMES_HOME}/logs/pipeline-scheduler.log"
|
||||
TOKEN_DAILY_LIMIT="${PIPELINE_TOKEN_LIMIT:-500000}"
|
||||
PEAK_HOURS_START="${PIPELINE_PEAK_START:-9}"
|
||||
PEAK_HOURS_END="${PIPELINE_PEAK_END:-18}"
|
||||
|
||||
# Pipeline definitions (priority order)
|
||||
# Each pipeline: name, script, max_tokens, dependencies
|
||||
PIPELINES=(
|
||||
"playground-factory|scripts/pipeline_playground_factory.sh|100000|none"
|
||||
"training-factory|scripts/pipeline_training_factory.sh|150000|none"
|
||||
"knowledge-mine|scripts/pipeline_knowledge_mine.sh|80000|training-factory"
|
||||
"adversary|scripts/pipeline_adversary.sh|50000|knowledge-mine"
|
||||
"codebase-genome|scripts/pipeline_codebase_genome.sh|120000|none"
|
||||
)
|
||||
|
||||
# --- Colors ---
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[0;33m'
|
||||
CYAN='\033[0;36m'
|
||||
NC='\033[0m'
|
||||
|
||||
# --- Helpers ---
|
||||
now_hour() { date +%-H; }
|
||||
is_peak_hours() {
|
||||
local h=$(now_hour)
|
||||
[[ $h -ge $PEAK_HOURS_START && $h -lt $PEAK_HOURS_END ]]
|
||||
}
|
||||
|
||||
ensure_dirs() {
|
||||
mkdir -p "$(dirname "$LOG_FILE")" "$(dirname "$BUDGET_FILE")" "$(dirname "$STATE_FILE")"
|
||||
}
|
||||
|
||||
log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"; }
|
||||
|
||||
get_budget_used_today() {
|
||||
if [[ -f "$BUDGET_FILE" ]]; then
|
||||
local today=$(date +%Y-%m-%d)
|
||||
python3 -c "
|
||||
import json, sys
|
||||
with open('$BUDGET_FILE') as f:
|
||||
d = json.load(f)
|
||||
print(d.get('daily', {}).get('$today', {}).get('tokens_used', 0))
|
||||
" 2>/dev/null || echo 0
|
||||
else
|
||||
echo 0
|
||||
fi
|
||||
}
|
||||
|
||||
get_budget_remaining() {
|
||||
local used=$(get_budget_used_today)
|
||||
echo $((TOKEN_DAILY_LIMIT - used))
|
||||
}
|
||||
|
||||
update_budget() {
|
||||
local pipeline="$1"
|
||||
local tokens="$2"
|
||||
local today=$(date +%Y-%m-%d)
|
||||
python3 -c "
|
||||
import json, os
|
||||
path = '$BUDGET_FILE'
|
||||
d = {}
|
||||
if os.path.exists(path):
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
daily = d.setdefault('daily', {})
|
||||
day = daily.setdefault('$today', {'tokens_used': 0, 'pipelines': {}})
|
||||
day['tokens_used'] = day.get('tokens_used', 0) + $tokens
|
||||
day['pipelines']['$pipeline'] = day['pipelines'].get('$pipeline', 0) + $tokens
|
||||
with open(path, 'w') as f:
|
||||
json.dump(d, f, indent=2)
|
||||
"
|
||||
}
|
||||
|
||||
get_pipeline_state() {
|
||||
if [[ -f "$STATE_FILE" ]]; then
|
||||
cat "$STATE_FILE"
|
||||
else
|
||||
echo "{}"
|
||||
fi
|
||||
}
|
||||
|
||||
set_pipeline_state() {
|
||||
local pipeline="$1"
|
||||
local state="$2" # running, complete, failed, skipped
|
||||
python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
d = {}
|
||||
if os.path.exists(path):
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
d['$pipeline'] = {'state': '$state', 'updated': '$(date -Iseconds)'}
|
||||
with open(path, 'w') as f:
|
||||
json.dump(d, f, indent=2)
|
||||
"
|
||||
}
|
||||
|
||||
is_pipeline_complete() {
|
||||
local pipeline="$1"
|
||||
python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
if not os.path.exists(path):
|
||||
print('false')
|
||||
else:
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
state = d.get('$pipeline', {}).get('state', 'not_started')
|
||||
print('true' if state == 'complete' else 'false')
|
||||
" 2>/dev/null || echo false
|
||||
}
|
||||
|
||||
is_pipeline_running() {
|
||||
local pipeline="$1"
|
||||
python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
if not os.path.exists(path):
|
||||
print('false')
|
||||
else:
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
state = d.get('$pipeline', {}).get('state', 'not_started')
|
||||
print('true' if state == 'running' else 'false')
|
||||
" 2>/dev/null || echo false
|
||||
}
|
||||
|
||||
check_dependency() {
|
||||
local dep="$1"
|
||||
if [[ "$dep" == "none" ]]; then
|
||||
return 0
|
||||
fi
|
||||
# For knowledge-mine: training-factory must be running or complete
|
||||
if [[ "$dep" == "training-factory" ]]; then
|
||||
local state=$(python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
if not os.path.exists(path):
|
||||
print('not_started')
|
||||
else:
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
print(d.get('training-factory', {}).get('state', 'not_started'))
|
||||
" 2>/dev/null || echo "not_started")
|
||||
[[ "$state" == "running" || "$state" == "complete" ]]
|
||||
return $?
|
||||
fi
|
||||
# For adversary: knowledge-mine must be at least 50% done
|
||||
# Simplified: check if it's running (we'd need progress tracking for 50%)
|
||||
if [[ "$dep" == "knowledge-mine" ]]; then
|
||||
local state=$(python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
if not os.path.exists(path):
|
||||
print('not_started')
|
||||
else:
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
print(d.get('knowledge-mine', {}).get('state', 'not_started'))
|
||||
" 2>/dev/null || echo "not_started")
|
||||
[[ "$state" == "running" || "$state" == "complete" ]]
|
||||
return $?
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
check_inference_available() {
|
||||
# Check if any inference provider is responding
|
||||
# 1. Check OpenRouter
|
||||
local or_ok=$(curl -s -o /dev/null -w "%{http_code}" \
|
||||
--connect-timeout 5 "https://openrouter.ai/api/v1/models" 2>/dev/null || echo "000")
|
||||
|
||||
# 2. Check local Ollama
|
||||
local ollama_ok=$(curl -s -o /dev/null -w "%{http_code}" \
|
||||
--connect-timeout 5 "http://localhost:11434/api/tags" 2>/dev/null || echo "000")
|
||||
|
||||
# 3. Check RunPod (if configured)
|
||||
local runpod_ok="000"
|
||||
if [[ -n "${RUNPOD_ENDPOINT:-}" ]]; then
|
||||
runpod_ok=$(curl -s -o /dev/null -w "%{http_code}" \
|
||||
--connect-timeout 5 "$RUNPOD_ENDPOINT/health" 2>/dev/null || echo "000")
|
||||
fi
|
||||
|
||||
if [[ "$or_ok" == "200" || "$ollama_ok" == "200" || "$runpod_ok" == "200" ]]; then
|
||||
return 0
|
||||
fi
|
||||
return 1
|
||||
}
|
||||
|
||||
check_interactive_load() {
|
||||
# Check if there are active interactive sessions (don't fight with live users)
|
||||
# Look for tmux panes with active hermes sessions
|
||||
local active=$(tmux list-panes -a -F '#{pane_pid} #{pane_current_command}' 2>/dev/null \
|
||||
| grep -c "hermes\|python3" || echo 0)
|
||||
|
||||
# If more than 3 interactive sessions, skip pipeline start
|
||||
if [[ $active -gt 3 ]]; then
|
||||
return 1
|
||||
fi
|
||||
return 0
|
||||
}
|
||||
|
||||
start_pipeline() {
|
||||
local name="$1"
|
||||
local script="$2"
|
||||
local max_tokens="$3"
|
||||
local budget_remaining="$4"
|
||||
local mode="${5:-run}"
|
||||
|
||||
if [[ "$budget_remaining" -lt "$max_tokens" ]]; then
|
||||
log "SKIP $name: insufficient budget ($budget_remaining < $max_tokens tokens)"
|
||||
return 1
|
||||
fi
|
||||
|
||||
if [[ ! -f "$script" ]]; then
|
||||
log "SKIP $name: script not found ($script)"
|
||||
return 1
|
||||
fi
|
||||
|
||||
if [[ "$mode" == "dry-run" ]]; then
|
||||
log "DRY-RUN: Would start $name (budget: $budget_remaining, needs: $max_tokens)"
|
||||
return 0
|
||||
fi
|
||||
|
||||
log "START $name (budget: $budget_remaining, max_tokens: $max_tokens)"
|
||||
set_pipeline_state "$name" "running"
|
||||
|
||||
# Run in background, capture output
|
||||
local log_path="${HERMES_HOME}/logs/pipeline-${name}.log"
|
||||
bash "$script" --max-tokens "$max_tokens" >> "$log_path" 2>&1 &
|
||||
local pid=$!
|
||||
|
||||
# Wait a moment to check if it started OK
|
||||
sleep 2
|
||||
if kill -0 $pid 2>/dev/null; then
|
||||
log "RUNNING $name (PID: $pid, log: $log_path)"
|
||||
# Record the PID
|
||||
python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
d = {}
|
||||
if os.path.exists(path):
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
d['$name']['pid'] = $pid
|
||||
with open(path, 'w') as f:
|
||||
json.dump(d, f, indent=2)
|
||||
"
|
||||
return 0
|
||||
else
|
||||
log "FAIL $name: script exited immediately"
|
||||
set_pipeline_state "$name" "failed"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
# --- Main ---
|
||||
main() {
|
||||
local mode="${1:-run}"
|
||||
ensure_dirs
|
||||
|
||||
log "=== Pipeline Scheduler ($mode) ==="
|
||||
|
||||
# Check 1: Is inference available?
|
||||
if ! check_inference_available; then
|
||||
log "No inference provider available. Skipping all pipelines."
|
||||
exit 0
|
||||
fi
|
||||
log "Inference: AVAILABLE"
|
||||
|
||||
# Check 2: Is it peak hours?
|
||||
if is_peak_hours && [[ "$mode" != "--force" ]]; then
|
||||
local h=$(now_hour)
|
||||
log "Peak hours ($h:00). Skipping pipeline start. Use --force to override."
|
||||
exit 0
|
||||
fi
|
||||
log "Off-peak: OK"
|
||||
|
||||
# Check 3: Interactive load
|
||||
if ! check_interactive_load && [[ "$mode" != "--force" ]]; then
|
||||
log "High interactive load. Skipping pipeline start."
|
||||
exit 0
|
||||
fi
|
||||
log "Interactive load: OK"
|
||||
|
||||
# Check 4: Token budget
|
||||
local budget=$(get_budget_remaining)
|
||||
log "Token budget remaining: $budget / $TOKEN_DAILY_LIMIT"
|
||||
|
||||
if [[ $budget -le 0 ]]; then
|
||||
log "Daily token budget exhausted. Stopping."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Check 5: Pipeline status
|
||||
if [[ "$mode" == "--status" ]]; then
|
||||
echo -e "${CYAN}Pipeline Status:${NC}"
|
||||
echo "────────────────────────────────────────────────────"
|
||||
for entry in "${PIPELINES[@]}"; do
|
||||
IFS='|' read -r name script max_tokens dep <<< "$entry"
|
||||
local state=$(python3 -c "
|
||||
import json, os
|
||||
path = '$STATE_FILE'
|
||||
if not os.path.exists(path):
|
||||
print('not_started')
|
||||
else:
|
||||
with open(path) as f:
|
||||
d = json.load(f)
|
||||
print(d.get('$name', {}).get('state', 'not_started'))
|
||||
" 2>/dev/null || echo "not_started")
|
||||
|
||||
local color=$NC
|
||||
case "$state" in
|
||||
running) color=$YELLOW ;;
|
||||
complete) color=$GREEN ;;
|
||||
failed) color=$RED ;;
|
||||
esac
|
||||
printf " %-25s %b%s%b (max: %s tokens, dep: %s)\n" "$name" "$color" "$state" "$NC" "$max_tokens" "$dep"
|
||||
done
|
||||
echo "────────────────────────────────────────────────────"
|
||||
echo " Budget: $budget / $TOKEN_DAILY_LIMIT tokens remaining"
|
||||
echo " Peak hours: $PEAK_HOURS_START:00 - $PEAK_HOURS_END:00"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Find and start the highest-priority incomplete pipeline
|
||||
local started=0
|
||||
for entry in "${PIPELINES[@]}"; do
|
||||
IFS='|' read -r name script max_tokens dep <<< "$entry"
|
||||
|
||||
# Skip if already running or complete
|
||||
if [[ "$(is_pipeline_running $name)" == "true" ]]; then
|
||||
log "SKIP $name: already running"
|
||||
continue
|
||||
fi
|
||||
if [[ "$(is_pipeline_complete $name)" == "true" ]]; then
|
||||
log "SKIP $name: already complete"
|
||||
continue
|
||||
fi
|
||||
|
||||
# Check dependency
|
||||
if ! check_dependency "$dep"; then
|
||||
log "SKIP $name: dependency $dep not met"
|
||||
continue
|
||||
fi
|
||||
|
||||
# Try to start
|
||||
if start_pipeline "$name" "$script" "$max_tokens" "$budget" "$mode"; then
|
||||
started=1
|
||||
# Only start one pipeline per run (let it claim tokens before next check)
|
||||
# Exception: playground-factory and training-factory can run in parallel
|
||||
if [[ "$name" != "playground-factory" && "$name" != "training-factory" ]]; then
|
||||
break
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
if [[ $started -eq 0 ]]; then
|
||||
log "No pipelines to start (all complete, running, or blocked)."
|
||||
fi
|
||||
|
||||
log "=== Pipeline Scheduler done ==="
|
||||
}
|
||||
|
||||
main "$@"
|
||||
194
scripts/token-tracker.py
Normal file
194
scripts/token-tracker.py
Normal file
@@ -0,0 +1,194 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Token Budget Tracker -- real-time spend dashboard for pipelines."""
|
||||
|
||||
import argparse, json, os, sqlite3, sys, time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
|
||||
DB_PATH = Path.home() / ".hermes" / "pipelines" / "token_usage.db"
|
||||
ALERT_THRESHOLDS = [0.5, 0.8, 1.0]
|
||||
DEFAULT_BUDGETS = {
|
||||
"knowledge-mine": 200_000_000,
|
||||
"training-factory": 215_000_000,
|
||||
"playground": 16_000_000,
|
||||
"adversary": 17_000_000,
|
||||
}
|
||||
|
||||
def get_db():
|
||||
DB_PATH.parent.mkdir(parents=True, exist_ok=True)
|
||||
conn = sqlite3.connect(str(DB_PATH))
|
||||
conn.row_factory = sqlite3.Row
|
||||
conn.execute("PRAGMA journal_mode=WAL")
|
||||
conn.executescript("""
|
||||
CREATE TABLE IF NOT EXISTS token_usage (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
pipeline TEXT NOT NULL,
|
||||
worker TEXT NOT NULL,
|
||||
tokens INTEGER NOT NULL,
|
||||
recorded_at REAL NOT NULL,
|
||||
hour_bucket TEXT NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS pipeline_budgets (
|
||||
pipeline TEXT PRIMARY KEY,
|
||||
target_tokens INTEGER NOT NULL,
|
||||
updated_at REAL NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS alerts_sent (
|
||||
pipeline TEXT NOT NULL,
|
||||
threshold REAL NOT NULL,
|
||||
sent_at REAL NOT NULL,
|
||||
PRIMARY KEY (pipeline, threshold)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_usage_pipeline_hour
|
||||
ON token_usage(pipeline, hour_bucket);
|
||||
""")
|
||||
for name, target in DEFAULT_BUDGETS.items():
|
||||
conn.execute(
|
||||
"INSERT OR IGNORE INTO pipeline_budgets (pipeline, target_tokens, updated_at) VALUES (?, ?, ?)",
|
||||
(name, target, time.time())
|
||||
)
|
||||
conn.commit()
|
||||
return conn
|
||||
|
||||
def log_usage(conn, pipeline, worker, tokens):
|
||||
now = time.time()
|
||||
hour = datetime.now().strftime("%Y-%m-%d %H:00")
|
||||
conn.execute(
|
||||
"INSERT INTO token_usage (pipeline, worker, tokens, recorded_at, hour_bucket) VALUES (?, ?, ?, ?, ?)",
|
||||
(pipeline, worker, tokens, now, hour)
|
||||
)
|
||||
conn.commit()
|
||||
check_alerts(conn, pipeline)
|
||||
|
||||
def get_pipeline_stats(conn):
|
||||
rows = conn.execute("""
|
||||
SELECT u.pipeline, COALESCE(b.target_tokens, 0) as target,
|
||||
SUM(u.tokens) as used, MIN(u.recorded_at) as started_at,
|
||||
COUNT(DISTINCT u.worker) as workers
|
||||
FROM token_usage u
|
||||
LEFT JOIN pipeline_budgets b ON u.pipeline = b.pipeline
|
||||
GROUP BY u.pipeline ORDER BY used DESC
|
||||
""").fetchall()
|
||||
return [dict(r) for r in rows]
|
||||
|
||||
def fmt(n):
|
||||
if n >= 1_000_000_000: return f"{n/1_000_000_000:.1f}B"
|
||||
if n >= 1_000_000: return f"{n/1_000_000:.1f}M"
|
||||
if n >= 1_000: return f"{n/1_000:.1f}K"
|
||||
return str(n)
|
||||
|
||||
def bar(ratio, w=8):
|
||||
filled = int(ratio * w)
|
||||
return "█" * filled + "░" * (w - filled)
|
||||
|
||||
def eta(used, target, started):
|
||||
if used <= 0 or started <= 0: return "--"
|
||||
elapsed = (time.time() - started) / 3600
|
||||
if elapsed <= 0: return "--"
|
||||
rate = used / elapsed
|
||||
remaining = target - used
|
||||
if remaining <= 0: return "DONE"
|
||||
h = remaining / rate
|
||||
return f"{h/24:.1f}d" if h >= 24 else f"{h:.1f}h"
|
||||
|
||||
def render_dashboard(conn):
|
||||
stats = get_pipeline_stats(conn)
|
||||
if not stats:
|
||||
print("No pipeline data recorded yet.")
|
||||
return
|
||||
print()
|
||||
print(f"{'Pipeline':<20} {'Tokens Used':>12} {'Target':>10} {'Progress':>10} {'ETA':>8} {'Workers':>8}")
|
||||
print("-" * 72)
|
||||
total_used = total_target = 0
|
||||
for s in stats:
|
||||
used = s["used"] or 0
|
||||
target = s["target"] or 1
|
||||
ratio = min(used / target, 1.0) if target > 0 else 0
|
||||
print(f"{s['pipeline']:<20} {fmt(used):>12} {fmt(target):>10} {bar(ratio):>10} {eta(used, target, s['started_at'] or 0):>8} {s['workers'] or 0:>8}")
|
||||
total_used += used
|
||||
total_target += target
|
||||
print("-" * 72)
|
||||
r = min(total_used / total_target, 1.0) if total_target > 0 else 0
|
||||
print(f"{'TOTAL':<20} {fmt(total_used):>12} {fmt(total_target):>10} {bar(r):>10}")
|
||||
print()
|
||||
|
||||
def render_watch(conn, interval=5):
|
||||
try:
|
||||
while True:
|
||||
os.system("clear" if os.name != "nt" else "cls")
|
||||
print(f"Token Budget Tracker -- {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
|
||||
print("Press Ctrl+C to exit")
|
||||
render_dashboard(conn)
|
||||
time.sleep(interval)
|
||||
except KeyboardInterrupt:
|
||||
print("\nExiting.")
|
||||
|
||||
def render_daily_summary(conn):
|
||||
since = time.time() - 86400
|
||||
rows = conn.execute("""
|
||||
SELECT pipeline, SUM(tokens) as total, COUNT(DISTINCT worker) as workers, COUNT(*) as entries
|
||||
FROM token_usage WHERE recorded_at >= ? GROUP BY pipeline ORDER BY total DESC
|
||||
""", (since,)).fetchall()
|
||||
if not rows:
|
||||
print("No usage in last 24 hours.")
|
||||
return
|
||||
print(f"\nDaily Summary -- last 24 hours")
|
||||
print(f"{'Pipeline':<20} {'Total Tokens':>14} {'Workers':>8} {'Entries':>8}")
|
||||
print("-" * 54)
|
||||
gt = 0
|
||||
for r in rows:
|
||||
print(f"{r['pipeline']:<20} {fmt(r['total']):>14} {r['workers']:>8} {r['entries']:>8}")
|
||||
gt += r["total"]
|
||||
print("-" * 54)
|
||||
print(f"{'TOTAL':<20} {fmt(gt):>14}\n")
|
||||
|
||||
def check_alerts(conn, pipeline):
|
||||
row = conn.execute(
|
||||
"SELECT SUM(u.tokens) as used, COALESCE(b.target_tokens, 0) as target "
|
||||
"FROM token_usage u LEFT JOIN pipeline_budgets b ON u.pipeline = b.pipeline "
|
||||
"WHERE u.pipeline = ?", (pipeline,)
|
||||
).fetchone()
|
||||
if not row or row["target"] <= 0: return
|
||||
ratio = row["used"] / row["target"]
|
||||
for t in ALERT_THRESHOLDS:
|
||||
if ratio >= t:
|
||||
existing = conn.execute("SELECT 1 FROM alerts_sent WHERE pipeline = ? AND threshold = ?", (pipeline, t)).fetchone()
|
||||
if not existing:
|
||||
print(f"⚠️ BUDGET ALERT: {pipeline} at {int(t*100)}% ({fmt(row['used'])}/{fmt(row['target'])})", file=sys.stderr)
|
||||
conn.execute("INSERT INTO alerts_sent (pipeline, threshold, sent_at) VALUES (?, ?, ?)", (pipeline, t, time.time()))
|
||||
conn.commit()
|
||||
|
||||
def set_budget(conn, pipeline, target):
|
||||
conn.execute("INSERT OR REPLACE INTO pipeline_budgets (pipeline, target_tokens, updated_at) VALUES (?, ?, ?)",
|
||||
(pipeline, int(target), time.time()))
|
||||
conn.execute("DELETE FROM alerts_sent WHERE pipeline = ?", (pipeline,))
|
||||
conn.commit()
|
||||
print(f"Budget set: {pipeline} = {fmt(int(target))} tokens")
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Token Budget Tracker")
|
||||
parser.add_argument("--watch", action="store_true")
|
||||
parser.add_argument("--watch-interval", type=int, default=5)
|
||||
parser.add_argument("--summary", action="store_true")
|
||||
parser.add_argument("--log", nargs=3, metavar=("PIPELINE", "WORKER", "TOKENS"))
|
||||
parser.add_argument("--budget", nargs=2, metavar=("PIPELINE", "TARGET"))
|
||||
parser.add_argument("--db", type=str, default=str(DB_PATH))
|
||||
args = parser.parse_args()
|
||||
global DB_PATH
|
||||
DB_PATH = Path(args.db)
|
||||
conn = get_db()
|
||||
if args.log:
|
||||
log_usage(conn, args.log[0], args.log[1], int(args.log[2]))
|
||||
print(f"Logged: {args.log[0]}/{args.log[1]} = {fmt(int(args.log[2]))} tokens")
|
||||
elif args.budget:
|
||||
set_budget(conn, args.budget[0], args.budget[1])
|
||||
elif args.summary:
|
||||
render_daily_summary(conn)
|
||||
elif args.watch:
|
||||
render_watch(conn, interval=args.watch_interval)
|
||||
else:
|
||||
render_dashboard(conn)
|
||||
conn.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,4 +1,3 @@
|
||||
#!/usr/bin/env python3
|
||||
import json
|
||||
from hermes_tools import browser_navigate, browser_vision
|
||||
|
||||
|
||||
Reference in New Issue
Block a user