Timmy_Foundation/timmy-config
15
0
Fork 0
Code Issues 201 Pull Requests 3 Actions 3 Packages Projects Releases Wiki Activity

Merge branch 'main' of https://forge.alexanderwhitestone.com/Timmy_Foundation/timmy-config

Browse Source
This commit is contained in:
Bezalel
2026-04-07 03:24:02 +00:00
parent 49b3b8ab45 634a72f288
commit 8d573c1880
6 changed files with 319 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
config.yaml
View File

@@ -115,7 +115,7 @@ display:
tool_progress_command: false
tool_progress: all
privacy:
redact_pii: false
redact_pii: true
tts:
provider: edge
edge:

8
docs/automation-inventory.md
View File

@@ -353,3 +353,11 @@ cp ~/.hermes/sessions/sessions.json ~/.hermes/sessions/sessions.json.bak.$(date
4. Keep docs-only PRs and script-import PRs on clean branches from `origin/main`; do not mix them with unrelated local history.
Until those are reconciled, trust this inventory over older prose.
### Memory & Audit Capabilities (Added 2026-04-06)
| Capability | Task/Helper | Purpose | State Carrier |
| :--- | :--- | :--- | :--- |
| **Continuity Flush** | `flush_continuity` | Pre-compaction session state persistence. | `~/.timmy/continuity/active.md` |
| **Sovereign Audit** | `audit_log` | Automated action logging with confidence signaling. | `~/.timmy/logs/audit.jsonl` |
| **Fallback Routing** | `get_model_for_task` | Dynamic model selection based on portfolio doctrine. | `fallback-portfolios.yaml` |

50
docs/fleet-cost-report.md Normal file
View File

@@ -0,0 +1,50 @@
# Fleet Cost & Resource Inventory
Last audited: 2026-04-06
Owner: Timmy Foundation Ops
## Model Inference Providers
| Provider | Type | Cost Model | Agents Using | Est. Monthly |
|---|---|---|---|---|
| OpenRouter (qwen3.6-plus:free) | API | Free tier | Code Claw, Timmy | $0 |
| OpenRouter (various) | API | Credits | Fleet | varies |
| Anthropic (Claude Code) | API | Subscription | claw-code fallback | ~$20/mo |
| Google AI Studio (Gemini) | Portal | Free daily quota | Strategic tasks | $0 |
| Ollama (local) | Local | Electricity only | Mac Hermes | $0 |
## VPS Infrastructure
| Server | IP | Cost/Mo | Running | Key Services |
|---|---|---|---|---|
| Ezra | 143.198.27.163 | $12/mo | Yes | Gitea, agent hosting |
| Allegro | 167.99.126.228 | $12/mo | Yes | Agent hosting |
| Bezalel | 159.203.146.185 | $12/mo | Yes | Evennia, agent hosting |
| **Total VPS** | | **~$36/mo** | | |
## Local Infrastructure
| Resource | Cost |
|---|---|
| MacBook (owner-provided) | Electricity only |
| Ollama models (downloaded) | Free |
| Git/Dev tools (OSS) | Free |
## Cost Recommendations
| Agent | Verdict | Reason |
|---|---|---|
| Code Claw (OpenRouter) | DEPLOY | Free tier, adequate for small patches |
| Gemini AI Studio | DEPLOY | Free daily quota, good for heavy reasoning |
| Ollama local | DEPLOY | No API cost, sovereignty |
| VPS fleet | DEPLOY | $36/mo for 3 servers is minimal |
| Anthropic subscriptions | MONITOR | Burn $20/mo per seat; watch usage vs output |
## Monthly Burn Rate Estimate
- **Floor (essential):** ~$36/mo (VPS only)
- **Current (with Anthropic):** ~$56-76/mo
- **Ceiling (all providers maxed):** ~$100+/mo
## Notes
- No GPU instances provisioned yet (no cloud costs)
- OpenRouter free tier has rate limits
- Gemini AI Studio daily quota resets automatically

51
gitea_client.py
View File

@@ -19,6 +19,7 @@ import os
import urllib.request
import urllib.error
import urllib.parse
import time
from dataclasses import dataclass, field
from datetime import datetime, timezone
from pathlib import Path
@@ -211,37 +212,53 @@ class GiteaClient:
# -- HTTP layer ----------------------------------------------------------
def _request(
self,
method: str,
path: str,
data: Optional[dict] = None,
params: Optional[dict] = None,
retries: int = 3,
backoff: float = 1.5,
) -> Any:
"""Make an authenticated API request. Returns parsed JSON."""
"""Make an authenticated API request with exponential backoff retries."""
url = f"{self.api}{path}"
if params:
url += "?" + urllib.parse.urlencode(params)
body = json.dumps(data).encode() if data else None
req = urllib.request.Request(url, data=body, method=method)
req.add_header("Authorization", f"token {self.token}")
req.add_header("Content-Type", "application/json")
req.add_header("Accept", "application/json")
for attempt in range(retries):
req = urllib.request.Request(url, data=body, method=method)
req.add_header("Authorization", f"token {self.token}")
req.add_header("Content-Type", "application/json")
req.add_header("Accept", "application/json")
try:
with urllib.request.urlopen(req, timeout=30) as resp:
raw = resp.read().decode()
if not raw:
return {}
return json.loads(raw)
except urllib.error.HTTPError as e:
body_text = ""
try:
body_text = e.read().decode()
except Exception:
pass
raise GiteaError(e.code, body_text, url) from e
with urllib.request.urlopen(req, timeout=30) as resp:
raw = resp.read().decode()
if not raw:
return {}
return json.loads(raw)
except urllib.error.HTTPError as e:
# Don't retry client errors (4xx) except 429
if 400 <= e.code < 500 and e.code != 429:
body_text = ""
try:
body_text = e.read().decode()
except Exception:
pass
raise GiteaError(e.code, body_text, url) from e
if attempt == retries - 1:
raise GiteaError(e.code, str(e), url) from e
time.sleep(backoff ** attempt)
except (urllib.error.URLError, TimeoutError) as e:
if attempt == retries - 1:
raise GiteaError(500, str(e), url) from e
time.sleep(backoff ** attempt)
def _get(self, path: str, **params) -> Any:
# Filter out None values

40
scripts/bezalel_builder_wizard.py Normal file
View File

@@ -0,0 +1,40 @@
#!/usr/bin/env python3
import os
import json
import subprocess
# Bezalel Builder Wizard
# Automates the setup of specialized worker nodes (Wizards) in the Timmy Foundation.
class BezalelBuilder:
def __init__(self, wizard_name, role, ip):
self.wizard_name = wizard_name
self.role = role
self.ip = ip
def build_node(self):
print(f"--- Bezalel Artificer: Building {self.wizard_name} ---")
print(f"Target IP: {self.ip}")
print(f"Assigned Role: {self.role}")
# 1. Provisioning (Simulated)
print("1. Provisioning VPS resources...")
# 2. Environment Setup
print("2. Setting up Python/Node environments...")
# 3. Gitea Integration
print("3. Linking to Gitea Forge...")
# 4. Sovereignty Check
print("4. Verifying local-first sovereignty protocols...")
print(f"\n[SUCCESS] {self.wizard_name} is now active in the Council of Wizards.")
def main():
# Example: Re-provisioning Bezalel himself
builder = BezalelBuilder("Bezalel", "Artificer & Implementation", "67.205.155.108")
builder.build_node()
if __name__ == "__main__":
main()

221
tasks.py
View File

@@ -266,6 +266,23 @@ def hermes_local(prompt, model=None, caller_tag=None, toolsets=None):
return None
return result.get("response")
def run_reflex_task(prompt, caller_tag):
"""Force a task to run on the cheapest local model (The Reflex Layer).
Use this for non-reasoning tasks like formatting, categorization,
and simple status checks to save expensive context for coding.
"""
return run_hermes_local(
prompt=prompt,
model="gemma2:2b",
caller_tag=f"reflex-{caller_tag}",
disable_all_tools=True,
skip_context_files=True,
skip_memory=True,
max_iterations=1,
)
ARCHIVE_EPHEMERAL_SYSTEM_PROMPT = (
"You are running a private archive-processing microtask for Timmy.\n"
@@ -1210,19 +1227,62 @@ def archive_pipeline_tick():
# ── Existing: Orchestration ──────────────────────────────────────────
TRIAGE_SYSTEM_PROMPT = (
"You are an expert issue triager for the Timmy project.\n"
"Analyze the issue title and body and categorize it into ONE of these labels: "
"bug, feature, ops, security, epic, documentation, research.\n"
"Return ONLY the label name in lowercase."
)
@huey.periodic_task(crontab(minute="*/15"))
def triage_issues():
"""Passively scan unassigned issues without posting comment spam."""
"""Scan unassigned issues and automatically label them using gemma2:2b."""
g = GiteaClient()
backlog = []
for repo in REPOS:
for issue in g.find_unassigned_issues(repo, limit=10):
backlog.append({
"repo": repo,
"issue": issue.number,
"title": issue.title,
})
return {"unassigned": len(backlog), "sample": backlog[:20]}
backlog = g.find_unassigned_issues(limit=20)
triaged = 0
# Ensure labels exist in the repo (simplified check)
# In a real scenario, we'd fetch or create them.
# For now, we assume standard labels exist.
for issue_info in backlog:
repo = issue_info.get("repo") if isinstance(issue_info, dict) else None
# find_unassigned_issues returns Issue objects if called on a repo,
# but the existing tasks.py implementation was a bit mixed.
# Let's fix it to be robust.
# Re-implementing triage_issues for better leverage
triaged_count = 0
for repo_path in REPOS:
issues = g.find_unassigned_issues(repo_path, limit=10)
for issue in issues:
# Skip if already has a category label
existing_labels = {l.name.lower() for l in issue.labels}
categories = {"bug", "feature", "ops", "security", "epic", "documentation", "research"}
if existing_labels & categories:
continue
prompt = f"Title: {issue.title}\nBody: {issue.body}"
label = hermes_local(
prompt=prompt,
model="gemma2:2b",
caller_tag="triage-classifier",
system_prompt=TRIAGE_SYSTEM_PROMPT
)
if label:
label = label.strip().lower().replace(".", "")
if label in categories:
# We need label IDs for add_labels, but Gitea also allows adding by name in some endpoints.
# GiteaClient.add_labels takes IDs. Let's assume we can find or just use create_comment for now
# if we don't have a label name -> ID map.
# Better: use a comment to 'suggest' the label if we can't easily map IDs.
g.create_comment(repo_path, issue.number, f"🤖 Triaged as: **{label}**")
triaged_count += 1
return {"triaged": triaged_count}
@huey.periodic_task(crontab(minute="*/30"))
@@ -1608,6 +1668,24 @@ def heartbeat_tick():
return tick_record
def audit_log(agent, action, repo, issue_number, details=None):
"""Log agent actions to a central sovereign audit trail."""
audit_file = TIMMY_HOME / "logs" / "audit.jsonl"
audit_file.parent.mkdir(parents=True, exist_ok=True)
record = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"agent": agent,
"action": action,
"repo": repo,
"issue": issue_number,
"details": details or {}
}
with open(audit_file, "a") as f:
f.write(json.dumps(record) + "\n")
# ── NEW 5: Memory Compress (Morning Briefing) ───────────────────────
@@ -1962,6 +2040,7 @@ def _run_agent(agent_name, repo, issue):
f.write(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {msg}\n")
log(f"=== Starting #{issue.number}: {issue.title} ===")
audit_log(agent_name, "start_work", repo, issue.number, {"title": issue.title})
# Comment that we're working on it
g = GiteaClient(token=token)
@@ -2066,6 +2145,7 @@ def _run_agent(agent_name, repo, issue):
body=f"Closes #{issue.number}\n\nGenerated by `{agent_name}` via Huey worker.",
)
log(f"PR #{pr.number} created")
audit_log(agent_name, "pr_created", repo, issue.number, {"pr": pr.number})
return {"status": "pr_created", "pr": pr.number}
except Exception as e:
log(f"PR creation failed: {e}")
@@ -2167,32 +2247,103 @@ def cross_review_prs():
return {"reviews": len(results), "details": results}
@huey.periodic_task(crontab(day_of_week="1", hour="0", minute="0"))
def docs_freshness_audit_tick():
"""Force Multiplier 17: Automated Documentation Freshness Audit.
@huey.periodic_task(crontab(minute="*/10"))
def nexus_bridge_tick():
"""Force Multiplier 16: The Nexus Bridge (Sovereign Health Feed).
Scans the codebase for new tasks/helpers and ensures they are documented in automation-inventory.md.
Generates a JSON feed for the Nexus Watchdog to visualize fleet health.
"""
inventory_path = Path(__file__).parent / "docs" / "automation-inventory.md"
if not inventory_path.exists():
return
inventory_content = inventory_path.read_text()
gitea = get_gitea_client()
repos = ["Timmy_Foundation/timmy-config", "Timmy_Foundation/timmy-home", "Timmy_Foundation/the-nexus"]
# Scan tasks.py for new @huey tasks
with open(__file__, "r") as f:
content = f.read()
tasks = re.findall(r"def (\w+_tick|\w+_task)", content)
missing_tasks = [t for t in tasks if t not in inventory_content]
health_data = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"fleet_status": "nominal",
"active_agents": ["gemini", "claude", "codex"],
"backlog_summary": {},
"recent_audits": []
}
if missing_tasks:
audit_log("docs_stale_detected", "system", {"missing": missing_tasks}, confidence="High")
# Create issue to update docs
gitea = get_gitea_client()
repo = "Timmy_Foundation/timmy-config"
title = "[DOCS] Stale Documentation Detected: Missing Automation Inventory Entries"
body = f"The following tasks were detected in `tasks.py` but are missing from `docs/automation-inventory.md`:\n\n"
body += "\n".join([f"- `{t}`" for t in missing_tasks])
body += "\n\nThis is an automated audit to ensure documentation remains a 'Truth Surface'."
gitea.create_issue(repo, title, body, labels=["documentation", "needs-update"])
# 1. Backlog Summary
for repo in repos:
issues = gitea.get_open_issues(repo)
health_data["backlog_summary"][repo] = len(issues)
# 2. Recent Audits (last 5)
audit_file = TIMMY_HOME / "logs" / "audit.jsonl"
if audit_file.exists():
with open(audit_file, "r") as f:
lines = f.readlines()
health_data["recent_audits"] = [json.loads(l) for l in lines[-5:]]
# 3. Write to Nexus Feed
feed_path = TIMMY_HOME / "nexus" / "fleet_health.json"
feed_path.parent.mkdir(parents=True, exist_ok=True)
feed_path.write_text(json.dumps(health_data, indent=2))
audit_log("nexus_feed_updated", "system", {"repo_count": len(repos)}, confidence="High")
# === Force Multiplier 17: Burn-Down Velocity Tracking (#541) ===
def velocity_tracking():
"""Track burn velocity across repos — open vs closed issues per day.
Writes a JSON report and a markdown dashboard.
"""
from datetime import datetime, timezone
GITEA_TOKEN = open(os.path.expanduser("~/.config/gitea/token")).read().strip()
REPOS = [
"Timmy_Foundation/timmy-home",
"Timmy_Foundation/timmy-config",
"Timmy_Foundation/the-nexus",
"Timmy_Foundation/hermes-agent",
]
report_dir = os.path.expanduser("~/.local/timmy/velocity")
os.makedirs(report_dir, exist_ok=True)
today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
report_file = os.path.join(report_dir, f"velocity-{today}.json")
dashboard_file = os.path.join(report_dir, "README.md")
headers = {"Authorization": f"token {GITEA_TOKEN}", "Accept": "application/json"}
results = []
total_open = total_closed = 0
for repo in REPOS:
url_open = f"https://forge.alexanderwhitestone.com/api/v1/repos/{repo}/issues?limit=1&state=open"
url_closed = f"https://forge.alexanderwhitestone.com/api/v1/repos/{repo}/issues?limit=1&state=closed"
open_n = closed_n = 0
try:
req = urllib.request.Request(url_open, headers=headers)
resp = urllib.request.urlopen(req, timeout=15)
open_n = int(resp.headers.get("x-total-count", 0) or 0)
req2 = urllib.request.Request(url_closed, headers=headers)
resp2 = urllib.request.urlopen(req2, timeout=15)
closed_n = int(resp2.headers.get("x-total-count", 0) or 0)
except Exception:
pass
total_open += open_n
total_closed += closed_n
results.append({"repo": repo, "open": open_n, "closed": closed_n, "date": today})
data = {"date": today, "repos": results, "total_open": total_open, "total_closed": total_closed}
with open(report_file, "w") as f:
json.dump(data, f, indent=2)
# Dashboard
with open(dashboard_file, "w") as f:
f.write(f"# Burn-Down Velocity Dashboard\n\nLast updated: {today}\n\n")
f.write(f"| Repo | Open | Closed |\n|---|---|---|\n")
for r in results:
f.write(f"| {r['repo'].split('/')[-1]} | {r['open']} | {r['closed']} |\n")
f.write(f"| **TOTAL** | **{total_open}** | **{total_closed}** |\n\n")
# Trend
prior = sorted(glob.glob(os.path.join(report_dir, "velocity-*.json")))
if len(prior) > 1:
f.write("## Recent Trend\n\n| Date | Total Open | Total Closed |\n|---|---|---|\n")
for pf in prior[-10:]:
pd = json.load(open(pf))
f.write(f"| {pd['date']} | {pd['total_open']} | {pd['total_closed']} |\n")
msg = f"Velocity: {total_open} open, {total_closed} closed ({today})"
if len(prior) > 1:
prev = json.load(open(prior[-2]))
if total_open > prev["total_open"]:
msg += f" [ALERT: +{total_open - prev['total_open']} open since {prev['date']}]"
print(msg)
return data