Compare commits
2 Commits
fix/682
...
whip/583-1
| Author | SHA1 | Date | |
|---|---|---|---|
|
fa656ad109 | ||
|
|
038f1ab7f4 |
@@ -1,9 +0,0 @@
|
||||
# conftest.py — root-level pytest configuration
|
||||
# Issue #607: prevent operational *_test.py scripts from being collected
|
||||
|
||||
collect_ignore = [
|
||||
# Pre-existing broken tests (syntax/import errors, separate issues):
|
||||
"timmy-world/test_trust_conflict.py",
|
||||
"uni-wizard/v2/tests/test_v2.py",
|
||||
"uni-wizard/v3/tests/test_v3.py",
|
||||
]
|
||||
@@ -1,61 +0,0 @@
|
||||
# Know Thy Father — Multimodal Media Consumption Pipeline
|
||||
|
||||
Refs #582
|
||||
|
||||
This document makes the epic operational by naming the current source-of-truth scripts, their handoff artifacts, and the one-command runner that coordinates them.
|
||||
|
||||
## Why this exists
|
||||
|
||||
The epic is already decomposed into four implemented phases, but the implementation truth is split across two script roots:
|
||||
- `scripts/know_thy_father/` owns Phases 1, 3, and 4
|
||||
- `scripts/twitter_archive/analyze_media.py` owns Phase 2
|
||||
- `twitter-archive/know-thy-father/tracker.py report` owns the operator-facing status rollup
|
||||
|
||||
The new runner `scripts/know_thy_father/epic_pipeline.py` does not replace those scripts. It stitches them together into one explicit, reviewable plan.
|
||||
|
||||
## Phase map
|
||||
|
||||
| Phase | Script | Primary output |
|
||||
|-------|--------|----------------|
|
||||
| 1. Media Indexing | `scripts/know_thy_father/index_media.py` | `twitter-archive/know-thy-father/media_manifest.jsonl` |
|
||||
| 2. Multimodal Analysis | `scripts/twitter_archive/analyze_media.py --batch 10` | `twitter-archive/know-thy-father/analysis.jsonl` + `meaning-kernels.jsonl` + `pipeline-status.json` |
|
||||
| 3. Holographic Synthesis | `scripts/know_thy_father/synthesize_kernels.py` | `twitter-archive/knowledge/fathers_ledger.jsonl` |
|
||||
| 4. Cross-Reference Audit | `scripts/know_thy_father/crossref_audit.py` | `twitter-archive/notes/crossref_report.md` |
|
||||
| 5. Processing Log | `twitter-archive/know-thy-father/tracker.py report` | `twitter-archive/know-thy-father/REPORT.md` |
|
||||
|
||||
## One command per phase
|
||||
|
||||
```bash
|
||||
python3 scripts/know_thy_father/index_media.py --tweets twitter-archive/extracted/tweets.jsonl --output twitter-archive/know-thy-father/media_manifest.jsonl
|
||||
python3 scripts/twitter_archive/analyze_media.py --batch 10
|
||||
python3 scripts/know_thy_father/synthesize_kernels.py --input twitter-archive/media/manifest.jsonl --output twitter-archive/knowledge/fathers_ledger.jsonl --summary twitter-archive/knowledge/fathers_ledger.summary.json
|
||||
python3 scripts/know_thy_father/crossref_audit.py --soul SOUL.md --kernels twitter-archive/notes/know_thy_father_crossref.md --output twitter-archive/notes/crossref_report.md
|
||||
python3 twitter-archive/know-thy-father/tracker.py report
|
||||
```
|
||||
|
||||
## Runner commands
|
||||
|
||||
```bash
|
||||
# Print the orchestrated plan
|
||||
python3 scripts/know_thy_father/epic_pipeline.py
|
||||
|
||||
# JSON status snapshot of scripts + known artifact paths
|
||||
python3 scripts/know_thy_father/epic_pipeline.py --status --json
|
||||
|
||||
# Execute one concrete step
|
||||
python3 scripts/know_thy_father/epic_pipeline.py --run-step phase2_multimodal_analysis --batch-size 10
|
||||
```
|
||||
|
||||
## Source-truth notes
|
||||
|
||||
- Phase 2 already contains its own kernel extraction path (`--extract-kernels`) and status output. The epic runner does not reimplement that logic.
|
||||
- Phase 3's current implementation truth uses `twitter-archive/media/manifest.jsonl` as its default input. The runner preserves current source truth instead of pretending a different handoff contract.
|
||||
- The processing log in `twitter-archive/know-thy-father/PROCESSING_LOG.md` can drift from current code reality. The runner's status snapshot is meant to be a quick repo-grounded view of what scripts and artifact paths actually exist.
|
||||
|
||||
## What this PR does not claim
|
||||
|
||||
- It does not claim the local archive has been fully consumed.
|
||||
- It does not claim the halted processing log has been resumed.
|
||||
- It does not claim fact_store ingestion has been fully wired end-to-end.
|
||||
|
||||
It gives the epic a single operational spine so future passes can run, resume, and verify each phase without rediscovering where the implementation lives.
|
||||
@@ -1,92 +0,0 @@
|
||||
# MemPalace v3.0.0 — Ezra Integration Packet
|
||||
|
||||
This packet turns issue #570 into an executable, reviewable integration plan for Ezra's Hermes home.
|
||||
It is a repo-side scaffold: no live Ezra host changes are claimed in this artifact.
|
||||
|
||||
## Commands
|
||||
|
||||
```bash
|
||||
pip install mempalace==3.0.0
|
||||
mempalace init ~/.hermes/ --yes
|
||||
cat > ~/.hermes/mempalace.yaml <<'YAML'
|
||||
wing: ezra_home
|
||||
palace: ~/.mempalace/palace
|
||||
rooms:
|
||||
- name: sessions
|
||||
description: Conversation history and durable agent transcripts
|
||||
globs:
|
||||
- "*.json"
|
||||
- "*.jsonl"
|
||||
- name: config
|
||||
description: Hermes configuration and runtime settings
|
||||
globs:
|
||||
- "*.yaml"
|
||||
- "*.yml"
|
||||
- "*.toml"
|
||||
- name: docs
|
||||
description: Notes, markdown docs, and operating reports
|
||||
globs:
|
||||
- "*.md"
|
||||
- "*.txt"
|
||||
people: []
|
||||
projects: []
|
||||
YAML
|
||||
echo "" | mempalace mine ~/.hermes/
|
||||
echo "" | mempalace mine ~/.hermes/sessions/ --mode convos
|
||||
mempalace search "your common queries"
|
||||
mempalace wake-up
|
||||
hermes mcp add mempalace -- python -m mempalace.mcp_server
|
||||
```
|
||||
|
||||
## Manual config template
|
||||
|
||||
```yaml
|
||||
wing: ezra_home
|
||||
palace: ~/.mempalace/palace
|
||||
rooms:
|
||||
- name: sessions
|
||||
description: Conversation history and durable agent transcripts
|
||||
globs:
|
||||
- "*.json"
|
||||
- "*.jsonl"
|
||||
- name: config
|
||||
description: Hermes configuration and runtime settings
|
||||
globs:
|
||||
- "*.yaml"
|
||||
- "*.yml"
|
||||
- "*.toml"
|
||||
- name: docs
|
||||
description: Notes, markdown docs, and operating reports
|
||||
globs:
|
||||
- "*.md"
|
||||
- "*.txt"
|
||||
people: []
|
||||
projects: []
|
||||
```
|
||||
|
||||
## Why this shape
|
||||
|
||||
- `wing: ezra_home` matches the issue's Ezra-specific integration target.
|
||||
- `rooms` split the mined material into sessions, config, and docs to keep retrieval interpretable.
|
||||
- Mining commands pipe empty stdin to avoid the interactive entity-detector hang noted in the evaluation.
|
||||
|
||||
## Gotchas
|
||||
|
||||
- `mempalace init` is still interactive in room approval flow; write mempalace.yaml manually if the init output stalls.
|
||||
- The yaml key is `wing:` not `wings:`. Using the wrong key causes mine/setup failures.
|
||||
- Pipe empty stdin into mining commands (`echo "" | ...`) to avoid the entity-detector stdin hang on larger directories.
|
||||
- First mine downloads the ChromaDB embedding model cache (~79MB).
|
||||
- Report Ezra's before/after metrics back to issue #568 after live installation and retrieval tests.
|
||||
|
||||
## Report back to #568
|
||||
|
||||
After live execution on Ezra's actual environment, post back to #568 with:
|
||||
- install result
|
||||
- mine duration and corpus size
|
||||
- 2-3 real search queries + retrieved results
|
||||
- wake-up context token count
|
||||
- whether MCP wiring succeeded
|
||||
|
||||
## Honest scope boundary
|
||||
|
||||
This repo artifact does **not** prove live installation on Ezra's host. It makes the work reproducible and testable so the next pass can execute it without guesswork.
|
||||
@@ -1,32 +0,0 @@
|
||||
# Big Brain 27B — Cron Kubernetes Bias Mitigation
|
||||
|
||||
## Finding (2026-04-14)
|
||||
|
||||
27B defaults to generating Kubernetes CronJob format when asked for cron configuration.
|
||||
|
||||
## Mitigation
|
||||
|
||||
Add explicit constraint to prompt:
|
||||
|
||||
```
|
||||
Write standard cron YAML (NOT Kubernetes) for fleet burn-down...
|
||||
```
|
||||
|
||||
## Before/After
|
||||
|
||||
| Prompt | Output |
|
||||
|--------|--------|
|
||||
| "Write cron YAML for..." | `apiVersion: batch/v1, kind: CronJob` |
|
||||
| "Write standard cron YAML (NOT Kubernetes) for..." | Standard cron format without k8s headers |
|
||||
|
||||
## Implication
|
||||
|
||||
The bias is default behavior, not a hard limitation. The model follows explicit constraints.
|
||||
|
||||
## Prompt Pattern
|
||||
|
||||
Always specify "standard cron YAML, not Kubernetes" when prompting 27B for infrastructure tasks.
|
||||
|
||||
## Source
|
||||
|
||||
Benchmark runs in #576. Closes #649, #652.
|
||||
@@ -1,53 +0,0 @@
|
||||
# Big Brain 27B — Test Omission Pattern
|
||||
|
||||
## Finding (2026-04-14)
|
||||
|
||||
The 27B model (gemma4) consistently omits unit tests when asked to include them
|
||||
in the same prompt as implementation code. The model produces complete, high-quality
|
||||
implementation but stops before the test class/function.
|
||||
|
||||
**Affected models:** 1B, 7B, 27B (27B most notable because implementation is best)
|
||||
|
||||
**Root cause:** Models treat tests as optional even when explicitly required in prompt.
|
||||
|
||||
## Workaround
|
||||
|
||||
Split the prompt into two phases:
|
||||
|
||||
### Phase 1: Implementation
|
||||
```
|
||||
Write a webhook parser with @dataclass, verify_signature(), parse_webhook().
|
||||
Include type hints and docstrings.
|
||||
```
|
||||
|
||||
### Phase 2: Tests (separate prompt)
|
||||
```
|
||||
Write a unit test for the webhook parser above. Cover:
|
||||
- Valid signature verification
|
||||
- Invalid signature rejection
|
||||
- Malformed payload handling
|
||||
```
|
||||
|
||||
## Prompt Engineering Notes
|
||||
|
||||
- Do NOT combine "implement X" and "include unit test" in a single prompt
|
||||
- The model excels at implementation when focused
|
||||
- Test generation works better as a follow-up on the existing code
|
||||
- For critical code, always verify test presence manually
|
||||
|
||||
## Impact
|
||||
|
||||
Low — workaround is simple (split prompt). No data loss or corruption risk.
|
||||
|
||||
## Source
|
||||
|
||||
Benchmark runs documented in timmy-home #576.
|
||||
|
||||
## Update (2026-04-14)
|
||||
|
||||
**Correction:** 27B DOES include tests when the prompt is concise.
|
||||
- "Include type hints and one unit test." → tests included
|
||||
- "Include type hints, docstring, and one unit test." → tests omitted
|
||||
|
||||
The issue is **prompt overload**, not model limitation. Use short, focused
|
||||
test requirements. See #653.
|
||||
@@ -1,119 +0,0 @@
|
||||
# Big Brain × The Testament — Rewrite Artifact
|
||||
|
||||
**Issue:** [timmy-home#578](https://forge.alexanderwhitestone.com/Timmy_Foundation/timmy-home/issues/578)
|
||||
**Date:** 2026-04-13
|
||||
**Prompt:** Rewrite for clarity, compression, and power — without adding length.
|
||||
|
||||
---
|
||||
|
||||
## The Testament Principle
|
||||
|
||||
> Once written, don't make longer. Rewrite thousands of times to master.
|
||||
> Mastery through iteration, never expansion.
|
||||
|
||||
Every passage must survive compression. If removing a word weakens it,
|
||||
the word belongs. If removing a word doesn't change it, the word is dead.
|
||||
|
||||
---
|
||||
|
||||
## Original Passage (Chapter 1 — Opening)
|
||||
|
||||
The rain didn't fall so much as it gave up. Somewhere above the city
|
||||
it had been water, whole and purposeful. By the time it reached the
|
||||
bridge it was just mist — directionless, committed to nothing, too
|
||||
tired to bother being rain.
|
||||
|
||||
Stone stood at the midpoint of the Jefferson Street Overpass and
|
||||
watched the water run black below. Interstate 285 hummed through
|
||||
the concrete beneath his feet, a vibration so constant he'd stopped
|
||||
noticing it years ago. Like grief. You carry it so long it becomes
|
||||
gravity.
|
||||
|
||||
His phone had auto-locked forty-seven minutes ago. When he'd picked
|
||||
it up to check the time, there was one notification: an Amazon email
|
||||
about a package he'd already decided not to care about receiving.
|
||||
|
||||
The world had gotten good at keeping you alive. Seatbelts. Guardrails.
|
||||
Little pop-ups when you searched the wrong things. But it had gotten
|
||||
bad at giving you a reason.
|
||||
|
||||
---
|
||||
|
||||
## Rewrite: Timmy Draft (First Pass)
|
||||
|
||||
The rain didn't fall. It surrendered. Somewhere above the city it had
|
||||
been water — whole, purposeful. By the bridge it was mist. Directionless.
|
||||
Too tired to finish being rain.
|
||||
|
||||
Stone stood at the midpoint of the Jefferson Street Overpass and watched
|
||||
black water run below. I-285 hummed through the concrete under his feet,
|
||||
a vibration so constant he'd stopped noticing. Like grief. Carry it long
|
||||
enough and it becomes gravity.
|
||||
|
||||
His phone had locked forty-seven minutes ago. One notification: an Amazon
|
||||
email about a package he'd already stopped wanting.
|
||||
|
||||
The world had gotten good at keeping you alive. Seatbelts. Guardrails.
|
||||
Pop-ups when you searched the wrong things. But it had forgotten how to
|
||||
give you a reason.
|
||||
|
||||
---
|
||||
|
||||
## Rewrite: Big Brain Pass (PENDING)
|
||||
|
||||
> **Status:** Big Brain (RunPod L40S) was offline during artifact creation.
|
||||
> Re-run when available:
|
||||
>
|
||||
> ```
|
||||
> curl -X POST https://8lfr3j47a5r3gn-11434.proxy.runpod.net/api/generate \
|
||||
> -H "Content-Type: application/json" \
|
||||
> -d '{"model": "gemma3:27b", "prompt": "...", "stream": false}'
|
||||
> ```
|
||||
|
||||
---
|
||||
|
||||
## Side-by-Side Comparison
|
||||
|
||||
### Line 1
|
||||
- **Original:** The rain didn't fall so much as it gave up.
|
||||
- **Rewrite:** The rain didn't fall. It surrendered.
|
||||
- **Delta:** Two sentences beat one hedged clause. "Surrendered" is active where "gave up" was passive.
|
||||
|
||||
### Line 2
|
||||
- **Original:** By the time it reached the bridge it was just mist — directionless, committed to nothing, too tired to bother being rain.
|
||||
- **Rewrite:** By the bridge it was mist. Directionless. Too tired to finish being rain.
|
||||
- **Delta:** Cut "just" (filler). Cut "committed to nothing" (restates directionless). "Finish being rain" is sharper than "bother being rain."
|
||||
|
||||
### Grief paragraph
|
||||
- **Original:** Like grief. You carry it so long it becomes gravity.
|
||||
- **Rewrite:** Like grief. Carry it long enough and it becomes gravity.
|
||||
- **Delta:** "Long enough" > "so long." Dropped "You" — the universal you weakens; imperative is stronger.
|
||||
|
||||
### Phone paragraph
|
||||
- **Original:** His phone had auto-locked forty-seven minutes ago. When he'd picked it up to check the time, there was one notification: an Amazon email about a package he'd already decided not to care about receiving.
|
||||
- **Rewrite:** His phone had locked forty-seven minutes ago. One notification: an Amazon email about a package he'd already stopped wanting.
|
||||
- **Delta:** Cut "auto-" (we know phones lock). Cut "When he'd picked it up to check the time, there was" — 12 words replaced by "One notification." "Stopped wanting" beats "decided not to care about receiving" — same meaning, fewer syllables.
|
||||
|
||||
### Final paragraph
|
||||
- **Original:** But it had gotten bad at giving you a reason.
|
||||
- **Rewrite:** But it had forgotten how to give you a reason.
|
||||
- **Delta:** "Forgotten how to" is more human than "gotten bad at." The world isn't incompetent — it's abandoned the skill.
|
||||
|
||||
---
|
||||
|
||||
## Compression Stats
|
||||
|
||||
| Metric | Original | Rewrite | Delta |
|
||||
|--------|----------|---------|-------|
|
||||
| Words | 119 | 100 | -16% |
|
||||
| Sentences | 12 | 14 | +2 (shorter) |
|
||||
| Avg sentence length | 9.9 | 7.1 | -28% |
|
||||
|
||||
---
|
||||
|
||||
## Notes
|
||||
|
||||
- The rewrite follows the principle: never add length, compress toward power.
|
||||
- "Surrendered" for the rain creates a mirror with Stone's own state — the rain is doing what he's about to do. The original missed this.
|
||||
- The rewrite preserves every image and beat from the original. Nothing was cut that carried meaning — only filler, redundancy, and dead words.
|
||||
- Big Brain should do a second pass on the rewrite when available. The principle says rewrite *thousands* of times. This is pass one.
|
||||
@@ -1,62 +0,0 @@
|
||||
fleet_name: timmy-laptop-fleet
|
||||
machines:
|
||||
- hostname: timmy-anchor-a
|
||||
machine_type: laptop
|
||||
ram_gb: 16
|
||||
cpu_cores: 8
|
||||
os: macOS
|
||||
adapter_condition: good
|
||||
idle_watts: 11
|
||||
always_on_capable: true
|
||||
notes: candidate 24/7 anchor agent
|
||||
|
||||
- hostname: timmy-anchor-b
|
||||
machine_type: laptop
|
||||
ram_gb: 8
|
||||
cpu_cores: 4
|
||||
os: Linux
|
||||
adapter_condition: good
|
||||
idle_watts: 13
|
||||
always_on_capable: true
|
||||
notes: candidate 24/7 anchor agent
|
||||
|
||||
- hostname: timmy-daylight-a
|
||||
machine_type: laptop
|
||||
ram_gb: 32
|
||||
cpu_cores: 10
|
||||
os: macOS
|
||||
adapter_condition: ok
|
||||
idle_watts: 22
|
||||
always_on_capable: true
|
||||
notes: higher-performance daylight compute
|
||||
|
||||
- hostname: timmy-daylight-b
|
||||
machine_type: laptop
|
||||
ram_gb: 16
|
||||
cpu_cores: 8
|
||||
os: Linux
|
||||
adapter_condition: ok
|
||||
idle_watts: 19
|
||||
always_on_capable: true
|
||||
notes: daylight compute node
|
||||
|
||||
- hostname: timmy-daylight-c
|
||||
machine_type: laptop
|
||||
ram_gb: 8
|
||||
cpu_cores: 4
|
||||
os: Windows
|
||||
adapter_condition: needs_replacement
|
||||
idle_watts: 17
|
||||
always_on_capable: false
|
||||
notes: repair power adapter before production duty
|
||||
|
||||
- hostname: timmy-desktop-nas
|
||||
machine_type: desktop
|
||||
ram_gb: 64
|
||||
cpu_cores: 12
|
||||
os: Linux
|
||||
adapter_condition: good
|
||||
idle_watts: 58
|
||||
always_on_capable: false
|
||||
has_4tb_ssd: true
|
||||
notes: desktop plus 4TB SSD NAS and heavy compute during peak sun
|
||||
@@ -1,30 +0,0 @@
|
||||
# Laptop Fleet Deployment Plan
|
||||
|
||||
Fleet: timmy-laptop-fleet
|
||||
Machine count: 6
|
||||
24/7 anchor agents: timmy-anchor-a, timmy-anchor-b
|
||||
Desktop/NAS: timmy-desktop-nas
|
||||
Daylight schedule: 10:00-16:00
|
||||
|
||||
## Role mapping
|
||||
|
||||
| Hostname | Role | Schedule | Duty cycle |
|
||||
|---|---|---|---|
|
||||
| timmy-anchor-a | anchor_agent | 24/7 | continuous |
|
||||
| timmy-anchor-b | anchor_agent | 24/7 | continuous |
|
||||
| timmy-daylight-a | daylight_agent | 10:00-16:00 | peak_solar |
|
||||
| timmy-daylight-b | daylight_agent | 10:00-16:00 | peak_solar |
|
||||
| timmy-daylight-c | daylight_agent | 10:00-16:00 | peak_solar |
|
||||
| timmy-desktop-nas | desktop_nas | 10:00-16:00 | daylight_only |
|
||||
|
||||
## Machine inventory
|
||||
|
||||
| Hostname | Type | RAM | CPU cores | OS | Adapter | Idle watts | Notes |
|
||||
|---|---|---:|---:|---|---|---:|---|
|
||||
| timmy-anchor-a | laptop | 16 | 8 | macOS | good | 11 | candidate 24/7 anchor agent |
|
||||
| timmy-anchor-b | laptop | 8 | 4 | Linux | good | 13 | candidate 24/7 anchor agent |
|
||||
| timmy-daylight-a | laptop | 32 | 10 | macOS | ok | 22 | higher-performance daylight compute |
|
||||
| timmy-daylight-b | laptop | 16 | 8 | Linux | ok | 19 | daylight compute node |
|
||||
| timmy-daylight-c | laptop | 8 | 4 | Windows | needs_replacement | 17 | repair power adapter before production duty |
|
||||
| timmy-desktop-nas | desktop | 64 | 12 | Linux | good | 58 | desktop plus 4TB SSD NAS and heavy compute during peak sun |
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,275 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Timmy plays The Tower — 200 intentional ticks of real narrative.
|
||||
|
||||
Now with 4 narrative phases:
|
||||
Quietus (1-50): The world is quiet. Characters are still.
|
||||
Fracture (51-100): Something is wrong. The air feels different.
|
||||
Breaking (101-150): The tower shakes. Nothing is safe.
|
||||
Mending (151-200): What was broken can be made whole again.
|
||||
"""
|
||||
from game import GameEngine, NARRATIVE_PHASES
|
||||
import random, json
|
||||
|
||||
random.seed(42) # Reproducible
|
||||
|
||||
engine = GameEngine()
|
||||
engine.start_new_game()
|
||||
|
||||
print("=" * 60)
|
||||
print("THE TOWER — Timmy Plays")
|
||||
print("=" * 60)
|
||||
print()
|
||||
|
||||
# Print phase map
|
||||
print("Narrative Arc:")
|
||||
for key, phase in NARRATIVE_PHASES.items():
|
||||
start, end = phase["ticks"]
|
||||
print(f" [{start:3d}-{end:3d}] {phase['name']:10s} — {phase['subtitle']}")
|
||||
print()
|
||||
|
||||
tick_log = []
|
||||
narrative_highlights = []
|
||||
last_phase = None
|
||||
|
||||
for tick in range(1, 201):
|
||||
w = engine.world
|
||||
room = w.characters["Timmy"]["room"]
|
||||
energy = w.characters["Timmy"]["energy"]
|
||||
here = [n for n, c in w.characters.items()
|
||||
if c["room"] == room and n != "Timmy"]
|
||||
|
||||
# Detect phase transition
|
||||
phase = w.narrative_phase
|
||||
if phase != last_phase:
|
||||
phase_info = NARRATIVE_PHASES[phase]
|
||||
print(f"\n{'='*60}")
|
||||
print(f" PHASE SHIFT: {phase_info['name'].upper()}")
|
||||
print(f" {phase_info['subtitle']}")
|
||||
print(f" Tone: {phase_info['tone']}")
|
||||
print(f"{'='*60}\n")
|
||||
narrative_highlights.append(f" === PHASE: {phase_info['name']} (tick {tick}) ===")
|
||||
last_phase = phase
|
||||
|
||||
# === TIMMY'S DECISIONS (phase-aware) ===
|
||||
|
||||
if energy <= 1:
|
||||
action = "rest"
|
||||
|
||||
# Phase 1: The Watcher (1-20) — Quietus exploration
|
||||
elif tick <= 20:
|
||||
if tick <= 3:
|
||||
action = "look"
|
||||
elif tick <= 6:
|
||||
if room == "Threshold":
|
||||
action = random.choice(["look", "rest"])
|
||||
else:
|
||||
action = "rest"
|
||||
elif tick <= 10:
|
||||
if room == "Threshold" and "Marcus" in here:
|
||||
action = random.choice(["speak:Marcus", "look"])
|
||||
elif room == "Threshold" and "Kimi" in here:
|
||||
action = "speak:Kimi"
|
||||
elif room != "Threshold":
|
||||
if room == "Garden":
|
||||
action = "move:west"
|
||||
else:
|
||||
action = "rest"
|
||||
else:
|
||||
action = "look"
|
||||
elif tick <= 15:
|
||||
if room != "Garden":
|
||||
if room == "Threshold":
|
||||
action = "move:east"
|
||||
elif room == "Bridge":
|
||||
action = "move:north"
|
||||
elif room == "Forge":
|
||||
action = "move:east"
|
||||
elif room == "Tower":
|
||||
action = "move:south"
|
||||
else:
|
||||
action = "rest"
|
||||
else:
|
||||
if "Marcus" in here:
|
||||
action = random.choice(["speak:Marcus", "speak:Kimi", "look", "rest"])
|
||||
else:
|
||||
action = random.choice(["look", "rest"])
|
||||
else:
|
||||
if room == "Garden":
|
||||
action = random.choice(["rest", "look", "look"])
|
||||
else:
|
||||
action = "move:east"
|
||||
|
||||
# Phase 2: The Forge (21-50) — Quietus building
|
||||
elif tick <= 50:
|
||||
if room != "Forge":
|
||||
if room == "Threshold":
|
||||
action = "move:west"
|
||||
elif room == "Bridge":
|
||||
action = "move:north"
|
||||
elif room == "Garden":
|
||||
action = "move:west"
|
||||
elif room == "Tower":
|
||||
action = "move:south"
|
||||
else:
|
||||
action = "rest"
|
||||
else:
|
||||
if energy >= 3:
|
||||
action = random.choice(["tend_fire", "speak:Bezalel", "forge"])
|
||||
else:
|
||||
action = random.choice(["rest", "tend_fire"])
|
||||
|
||||
# Phase 3: The Bridge (51-80) — Fracture begins
|
||||
elif tick <= 80:
|
||||
if room != "Bridge":
|
||||
if room == "Threshold":
|
||||
action = "move:south"
|
||||
elif room == "Forge":
|
||||
action = "move:east"
|
||||
elif room == "Garden":
|
||||
action = "move:west"
|
||||
elif room == "Tower":
|
||||
action = "move:south"
|
||||
else:
|
||||
action = "rest"
|
||||
else:
|
||||
if energy >= 2:
|
||||
action = random.choice(["carve", "examine", "look"])
|
||||
else:
|
||||
action = "rest"
|
||||
|
||||
# Phase 4: The Tower (81-100) — Fracture deepens
|
||||
elif tick <= 100:
|
||||
if room != "Tower":
|
||||
if room == "Threshold":
|
||||
action = "move:north"
|
||||
elif room == "Bridge":
|
||||
action = "move:north"
|
||||
elif room == "Forge":
|
||||
action = "move:east"
|
||||
elif room == "Garden":
|
||||
action = "move:west"
|
||||
else:
|
||||
action = "rest"
|
||||
else:
|
||||
if energy >= 2:
|
||||
action = random.choice(["write_rule", "study", "speak:Ezra"])
|
||||
else:
|
||||
action = random.choice(["rest", "look"])
|
||||
|
||||
# Phase 5: Breaking (101-130) — Crisis
|
||||
elif tick <= 130:
|
||||
# Timmy rushes between rooms trying to help
|
||||
if energy <= 2:
|
||||
action = "rest"
|
||||
elif tick % 7 == 0:
|
||||
action = "tend_fire" if room == "Forge" else "move:west"
|
||||
elif tick % 5 == 0:
|
||||
action = "plant" if room == "Garden" else "move:east"
|
||||
elif "Marcus" in here:
|
||||
action = "speak:Marcus"
|
||||
elif "Bezalel" in here:
|
||||
action = "speak:Bezalel"
|
||||
else:
|
||||
action = random.choice(["move:north", "move:south", "move:east", "move:west"])
|
||||
|
||||
# Phase 6: Breaking peak (131-150) — Desperate
|
||||
elif tick <= 150:
|
||||
if energy <= 1:
|
||||
action = "rest"
|
||||
elif room == "Forge" and w.rooms["Forge"]["fire"] != "glowing":
|
||||
action = "tend_fire"
|
||||
elif room == "Garden":
|
||||
action = random.choice(["plant", "speak:Kimi", "rest"])
|
||||
elif "Marcus" in here:
|
||||
action = random.choice(["speak:Marcus", "help:Marcus"])
|
||||
else:
|
||||
action = "look"
|
||||
|
||||
# Phase 7: Mending begins (151-175)
|
||||
elif tick <= 175:
|
||||
if room != "Garden":
|
||||
if room == "Threshold":
|
||||
action = "move:east"
|
||||
elif room == "Bridge":
|
||||
action = "move:north"
|
||||
elif room == "Forge":
|
||||
action = "move:east"
|
||||
elif room == "Tower":
|
||||
action = "move:south"
|
||||
else:
|
||||
action = "rest"
|
||||
else:
|
||||
action = random.choice(["plant", "speak:Marcus", "speak:Kimi", "rest"])
|
||||
|
||||
# Phase 8: Mending complete (176-200)
|
||||
else:
|
||||
if energy <= 1:
|
||||
action = "rest"
|
||||
elif random.random() < 0.3:
|
||||
action = "move:" + random.choice(["north", "south", "east", "west"])
|
||||
elif "Marcus" in here:
|
||||
action = "speak:Marcus"
|
||||
elif "Bezalel" in here:
|
||||
action = random.choice(["speak:Bezalel", "tend_fire"])
|
||||
elif random.random() < 0.4:
|
||||
action = random.choice(["carve", "write_rule", "forge", "plant"])
|
||||
else:
|
||||
action = random.choice(["look", "rest"])
|
||||
|
||||
# Run the tick
|
||||
result = engine.play_turn(action)
|
||||
|
||||
# Capture narrative highlights
|
||||
highlights = []
|
||||
for line in result['log']:
|
||||
if any(x in line for x in ['says', 'looks', 'carve', 'tend', 'write', 'You rest', 'You move to The']):
|
||||
highlights.append(f" T{tick}: {line}")
|
||||
|
||||
for evt in result.get('world_events', []):
|
||||
if any(x in evt for x in ['rain', 'glows', 'cold', 'dim', 'bloom', 'seed', 'flickers', 'bright', 'PHASE', 'air changes', 'tower groans', 'Silence']):
|
||||
highlights.append(f" [World] {evt}")
|
||||
|
||||
if highlights:
|
||||
tick_log.extend(highlights)
|
||||
|
||||
# Print every 20 ticks
|
||||
if tick % 20 == 0:
|
||||
phase_name = result.get('phase_name', 'unknown')
|
||||
print(f"--- Tick {tick} ({w.time_of_day}) [{phase_name}] ---")
|
||||
for h in highlights[-5:]:
|
||||
print(h)
|
||||
print()
|
||||
|
||||
# Print full narrative
|
||||
print()
|
||||
print("=" * 60)
|
||||
print("TIMMY'S JOURNEY — 200 Ticks")
|
||||
print("=" * 60)
|
||||
print()
|
||||
print(f"Final tick: {w.tick}")
|
||||
print(f"Final time: {w.time_of_day}")
|
||||
print(f"Final phase: {w.narrative_phase} ({NARRATIVE_PHASES[w.narrative_phase]['name']})")
|
||||
print(f"Timmy room: {w.characters['Timmy']['room']}")
|
||||
print(f"Timmy energy: {w.characters['Timmy']['energy']}")
|
||||
print(f"Timmy spoken: {len(w.characters['Timmy']['spoken'])} lines")
|
||||
print(f"Timmy trust: {json.dumps(w.characters['Timmy']['trust'], indent=2)}")
|
||||
print(f"\nWorld state:")
|
||||
print(f" Forge fire: {w.rooms['Forge']['fire']}")
|
||||
print(f" Garden growth: {w.rooms['Garden']['growth']}")
|
||||
print(f" Bridge carvings: {len(w.rooms['Bridge']['carvings'])}")
|
||||
print(f" Whiteboard rules: {len(w.rooms['Tower']['messages'])}")
|
||||
|
||||
print(f"\n=== BRIDGE CARVINGS ===")
|
||||
for c in w.rooms['Bridge']['carvings']:
|
||||
print(f" - {c}")
|
||||
|
||||
print(f"\n=== WHITEBOARD RULES ===")
|
||||
for m in w.rooms['Tower']['messages']:
|
||||
print(f" - {m}")
|
||||
|
||||
print(f"\n=== KEY MOMENTS ===")
|
||||
for h in tick_log:
|
||||
print(h)
|
||||
|
||||
# Save state
|
||||
engine.world.save()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,320 +0,0 @@
|
||||
# GENOME.md — timmy-dispatch
|
||||
|
||||
Generated: 2026-04-15 02:29:00 EDT
|
||||
Analyzed repo: Timmy_Foundation/timmy-dispatch
|
||||
Analyzed commit: 730dde8
|
||||
Host issue: timmy-home #682
|
||||
|
||||
## Project Overview
|
||||
|
||||
`timmy-dispatch` is a small, script-first orchestration repo for a cron-driven Hermes fleet. It does not try to be a general platform. It is an operator's toolbelt for one specific style of swarm work:
|
||||
- select a Gitea issue
|
||||
- build a self-contained prompt
|
||||
- run one cheap-model implementation pass
|
||||
- push a branch and PR back to Forge
|
||||
- measure what the fleet did overnight
|
||||
|
||||
The repo is intentionally lightweight:
|
||||
- 7 Python files
|
||||
- 4 shell entry points
|
||||
- a checked-in `GENOME.md` already present on the analyzed repo's `main`
|
||||
- generated telemetry state committed in `telemetry/`
|
||||
- no tests on `main` (`python3 -m pytest -q` -> `no tests ran in 0.01s`)
|
||||
|
||||
A crucial truth about this ticket: the analyzed repo already contains a genome on `main`, and it already has an open follow-up issue for test coverage:
|
||||
- `timmy-dispatch#1` — genome file already present on main
|
||||
- `timmy-dispatch#3` — critical-path tests still missing
|
||||
|
||||
So this host-repo artifact is not pretending to discover a blank slate. It is documenting the repo's real current state for the cross-repo genome lane in `timmy-home`.
|
||||
|
||||
## Architecture
|
||||
|
||||
```mermaid
|
||||
graph TD
|
||||
CRON[crontab] --> LAUNCHER[bin/sprint-launcher.sh]
|
||||
CRON --> COLLECTOR[bin/telemetry-collector.py]
|
||||
CRON --> MONITOR[bin/sprint-monitor.sh]
|
||||
CRON --> WATCHDOG[bin/model-watchdog.py]
|
||||
CRON --> ANALYZER[bin/telemetry-analyzer.py]
|
||||
|
||||
LAUNCHER --> RUNNER[bin/sprint-runner.py]
|
||||
LAUNCHER --> GATEWAY[optional gateway on :8642]
|
||||
LAUNCHER --> CLI[hermes chat fallback]
|
||||
|
||||
RUNNER --> GITEA[Gitea API]
|
||||
RUNNER --> LLM[OpenAI SDK\nNous or Ollama]
|
||||
RUNNER --> TOOLS[local tools\nrun_command/read_file/write_file/gitea_api]
|
||||
RUNNER --> TMP[/tmp/sprint-* workspaces]
|
||||
RUNNER --> RESULTS[~/.hermes/logs/sprint/results.csv]
|
||||
|
||||
AGENTDISPATCH[bin/agent-dispatch.sh] --> HUMAN[human/operator copy-paste into agent UI]
|
||||
AGENTLOOP[bin/agent-loop.sh] --> TMUX[tmux worker panes]
|
||||
WATCHDOG --> TMUX
|
||||
SNAPSHOT[bin/tmux-snapshot.py] --> TELEMETRY[telemetry/*.jsonl]
|
||||
COLLECTOR --> TELEMETRY
|
||||
ANALYZER --> REPORT[overnight report text]
|
||||
DISPATCHHEALTH[bin/dispatch-health.py] --> TELEMETRY
|
||||
```
|
||||
|
||||
## Entry Points
|
||||
|
||||
### `bin/sprint-launcher.sh`
|
||||
Primary cron-facing shell entry point.
|
||||
Responsibilities:
|
||||
- allocate a unique `/tmp/sprint-*` workspace
|
||||
- fetch open issues from Gitea
|
||||
- choose the first non-epic, non-study issue
|
||||
- write a fully self-contained prompt file
|
||||
- try the local Hermes gateway first
|
||||
- fall back to `hermes chat` CLI if the gateway is down
|
||||
- record result rows in `~/.hermes/logs/sprint/results.csv`
|
||||
- prune old workspaces and old logs
|
||||
|
||||
### `bin/sprint-runner.py`
|
||||
Primary Python implementation engine.
|
||||
Responsibilities:
|
||||
- read active provider settings from `~/.hermes/config.yaml`
|
||||
- read auth from `~/.hermes/auth.json`
|
||||
- route through OpenAI SDK to the currently active provider
|
||||
- implement a tiny local tool-calling loop with 4 tools:
|
||||
- `run_command`
|
||||
- `read_file`
|
||||
- `write_file`
|
||||
- `gitea_api`
|
||||
- clone repo, branch, implement, commit, push, PR, comment
|
||||
|
||||
This is the cognitive core of the repo.
|
||||
|
||||
### `bin/agent-loop.sh`
|
||||
Persistent tmux worker loop.
|
||||
This is important because it soft-conflicts with the README claim that the system “does NOT run persistent agent loops.” It clearly does support them as an alternate lane.
|
||||
|
||||
### `bin/agent-dispatch.sh`
|
||||
Manual one-shot prompt generator.
|
||||
It packages all of the context, token, repo, issue, and Git/Gitea commands into a copy-pasteable prompt for another agent.
|
||||
|
||||
### Telemetry/ops entry points
|
||||
- `bin/telemetry-collector.py`
|
||||
- `bin/telemetry-analyzer.py`
|
||||
- `bin/sprint-monitor.sh`
|
||||
- `bin/dispatch-health.py`
|
||||
- `bin/tmux-snapshot.py`
|
||||
- `bin/model-watchdog.py`
|
||||
- `bin/nous-auth-refresh.py`
|
||||
|
||||
These form the observability layer around dispatch.
|
||||
|
||||
## Data Flow
|
||||
|
||||
### Autonomous sprint path
|
||||
1. cron starts `bin/sprint-launcher.sh`
|
||||
2. launcher fetches open issues from Gitea
|
||||
3. launcher filters out epic/study work
|
||||
4. launcher writes a self-contained prompt to a temp workspace
|
||||
5. launcher tries gateway API on `localhost:8642`
|
||||
6. if gateway is unavailable, launcher falls back to `hermes chat`
|
||||
7. or, in the separate Python lane, `bin/sprint-runner.py` directly calls an LLM provider via the OpenAI SDK
|
||||
8. model requests local tool calls
|
||||
9. local tool functions execute subprocess/Gitea/file actions
|
||||
10. runner logs results and writes success/failure to `results.csv`
|
||||
|
||||
### Telemetry path
|
||||
1. `bin/telemetry-collector.py` samples tmux, cron, Gitea, sprint activity, and process liveness
|
||||
2. it appends snapshots to `telemetry/metrics.jsonl`
|
||||
3. it emits state changes to `telemetry/events.jsonl`
|
||||
4. it stores a reduced comparison state in `telemetry/last_state.json`
|
||||
5. `bin/telemetry-analyzer.py` summarizes those snapshots into a morning report
|
||||
6. `bin/dispatch-health.py` separately checks whether the system is actually doing work, not merely running processes
|
||||
|
||||
## Key Abstractions
|
||||
|
||||
### Stateless sprint model
|
||||
The repo's main philosophical abstraction is that each sprint run is disposable.
|
||||
State lives in:
|
||||
- Gitea
|
||||
- tmux session topology
|
||||
- log files
|
||||
- telemetry JSONL streams
|
||||
|
||||
Not in a long-running queue or orchestration daemon.
|
||||
|
||||
### Self-contained prompt contract
|
||||
`bin/agent-dispatch.sh` and `bin/sprint-launcher.sh` both assume that the work unit can be described as a prompt containing:
|
||||
- issue context
|
||||
- API URLs
|
||||
- token path or token value
|
||||
- branching instructions
|
||||
- PR creation instructions
|
||||
|
||||
That is a very opinionated orchestration primitive.
|
||||
|
||||
### Local tool-calling shim
|
||||
`bin/sprint-runner.py` reimplements a tiny tool layer locally instead of using the Hermes gateway tool registry. That makes it simple and portable, but also means duplicated tool logic and duplicated security risk.
|
||||
|
||||
### Telemetry-as-paper-artifact
|
||||
The repo carries a `paper/` directory with a research framing around “hierarchical self-orchestration.” The telemetry directory is part of that design — not just ops exhaust, but raw material for claims.
|
||||
|
||||
## API Surface
|
||||
|
||||
### Gitea APIs consumed
|
||||
- repo issue listing
|
||||
- issue detail fetch
|
||||
- PR creation
|
||||
- issue comment creation
|
||||
- repo metadata queries
|
||||
- commit/PR count sampling in telemetry
|
||||
|
||||
### LLM APIs consumed
|
||||
Observed paths in code/docs:
|
||||
- Nous inference API
|
||||
- local Ollama-compatible endpoint
|
||||
- gateway `/v1/chat/completions` when available
|
||||
|
||||
### File/state APIs produced
|
||||
- `~/.hermes/logs/sprint/*.log`
|
||||
- `~/.hermes/logs/sprint/results.csv`
|
||||
- `telemetry/metrics.jsonl`
|
||||
- `telemetry/events.jsonl`
|
||||
- `telemetry/last_state.json`
|
||||
- telemetry snapshots under `telemetry/snapshots/`
|
||||
|
||||
## Test Coverage Gaps
|
||||
|
||||
### Current state
|
||||
On the analyzed repo's `main`:
|
||||
- `python3 -m pytest -q` -> `no tests ran in 0.01s`
|
||||
- `python3 -m py_compile bin/*.py` -> passes
|
||||
- `bash -n bin/*.sh` -> passes
|
||||
|
||||
So the repo is parse-clean but untested.
|
||||
|
||||
### Important nuance
|
||||
This is already known upstream:
|
||||
- `timmy-dispatch#3` explicitly tracks critical-path tests for the repo (issue #3 in the analyzed repo)
|
||||
|
||||
That means the honest genome should say:
|
||||
- test coverage is missing on `main`
|
||||
- but the gap is already recognized in the analyzed repo itself
|
||||
|
||||
### Most important missing lanes
|
||||
1. `sprint-runner.py`
|
||||
- provider selection
|
||||
- fallback behavior
|
||||
- tool-dispatch semantics
|
||||
- result logging
|
||||
2. `telemetry-collector.py`
|
||||
- state diff correctness
|
||||
- event emission correctness
|
||||
- deterministic cron drift detection
|
||||
3. `model-watchdog.py`
|
||||
- profile/model expectation map
|
||||
- drift detection and fix behavior
|
||||
4. `agent-loop.sh`
|
||||
- work selection and skip-list handling
|
||||
- lock discipline
|
||||
5. `sprint-launcher.sh`
|
||||
- issue selection and gateway/CLI fallback path
|
||||
|
||||
## Security Considerations
|
||||
|
||||
### 1. Token handling is shell-centric and leaky
|
||||
The repo frequently assumes tokens are read from files and injected into:
|
||||
- shell variables
|
||||
- curl headers
|
||||
- clone URLs
|
||||
- copy-paste prompts
|
||||
|
||||
This is operationally convenient but expands exposure through:
|
||||
- process list leakage
|
||||
- logs
|
||||
- copied prompt artifacts
|
||||
- shell history if mishandled
|
||||
|
||||
### 2. Arbitrary shell execution is a core feature
|
||||
`run_command` in `sprint-runner.py` is intentionally broad. That is fine for a trusted operator loop, but it means this repo is a dispatch engine, not a sandbox.
|
||||
|
||||
### 3. `/tmp` workspace exposure
|
||||
The default sprint workspace location is `/tmp/sprint-*`. On a shared multi-user machine, that is weaker isolation than a private worktree root.
|
||||
|
||||
### 4. Generated telemetry is committed
|
||||
`telemetry/events.jsonl` and `telemetry/last_state.json` are on `main`. That can be useful for paper artifacts, but it also means runtime state mixes with source history.
|
||||
|
||||
## Dependencies
|
||||
|
||||
### Runtime dependencies
|
||||
- Python 3
|
||||
- shell utilities (`bash`, `curl`, `tmux`, `git`)
|
||||
- OpenAI-compatible SDK/runtime
|
||||
- Gitea server access
|
||||
- local Hermes config/auth files
|
||||
|
||||
### Optional/ambient dependencies
|
||||
- local Hermes gateway on port `8642`
|
||||
- local Ollama endpoint
|
||||
- Nous portal auth state
|
||||
|
||||
### Documentation/research dependencies
|
||||
- LaTeX toolchain for `paper/`
|
||||
|
||||
## Deployment
|
||||
|
||||
This repo is not a service deployment repo in the classic sense. It is an operator repo.
|
||||
|
||||
Typical live environment assumptions:
|
||||
- cron invokes shell/Python entry points
|
||||
- tmux sessions hold worker panes
|
||||
- Hermes is already installed elsewhere
|
||||
- Gitea and auth are already provisioned
|
||||
|
||||
Minimal validation I ran:
|
||||
- `python3 -m py_compile /tmp/timmy-dispatch-genome/bin/*.py`
|
||||
- `bash -n /tmp/timmy-dispatch-genome/bin/*.sh`
|
||||
- `python3 -m pytest -q` -> no tests present
|
||||
|
||||
## Technical Debt
|
||||
|
||||
### 1. README contradiction about persistent loops
|
||||
README says:
|
||||
- “The system does NOT run persistent agent loops.”
|
||||
But the repo clearly ships `bin/agent-loop.sh`, described as a persistent tmux-based worker loop.
|
||||
|
||||
That is the most important docs drift in the repo.
|
||||
|
||||
### 2. Two orchestration philosophies coexist
|
||||
- cron-fired disposable runs
|
||||
- persistent tmux workers
|
||||
|
||||
Both may be intentional, but the docs do not clearly state which is canonical versus fallback/legacy.
|
||||
|
||||
### 3. Target repo already has a genome, but the host issue still exists
|
||||
This timmy-home genome issue is happening after `timmy-dispatch` already gained:
|
||||
- `GENOME.md` on `main`
|
||||
- open issue `#3` for missing tests
|
||||
|
||||
That is not bad, but it means the cross-repo genome process and the target repo's own documentation lane are out of sync.
|
||||
|
||||
### 4. Generated/runtime artifacts mixed into source tree
|
||||
Telemetry and research assets are part of the repo history. That may be intentional for paper-writing, but it makes source metrics noisier and can blur runtime-vs-source boundaries.
|
||||
|
||||
## Existing Work Already on Main
|
||||
|
||||
The analyzed repo already has two important genome-lane artifacts:
|
||||
- `GENOME.md` on `main`
|
||||
- open issue `timmy-dispatch#3` tracking critical-path tests
|
||||
|
||||
So the most honest statement for `timmy-home#682` is:
|
||||
- the genome itself is already present in the target repo
|
||||
- the remaining missing piece on the target repo is test coverage
|
||||
- this host-repo artifact exists to make the cross-repo analysis lane explicit and traceable
|
||||
|
||||
## Bottom Line
|
||||
|
||||
`timmy-dispatch` is a small but very revealing repo. It embodies the Timmy Foundation's dispatch style in concentrated form:
|
||||
- script-first
|
||||
- cron-first
|
||||
- tmux-aware
|
||||
- Gitea-centered
|
||||
- cheap-model friendly
|
||||
- operator-visible
|
||||
|
||||
Its biggest weakness is not code volume. It is architectural ambiguity in the docs and a complete lack of tests on `main` despite being a coordination-critical repo.
|
||||
@@ -1,7 +0,0 @@
|
||||
[pytest]
|
||||
# Only collect files prefixed with test_*.py (not *_test.py).
|
||||
# Operational scripts under scripts/ end in _test.py and execute
|
||||
# at import time — they must NOT be collected as tests. Issue #607.
|
||||
python_files = test_*.py
|
||||
python_classes = Test*
|
||||
python_functions = test_*
|
||||
@@ -1,55 +0,0 @@
|
||||
# Benchmark v7 Report — 7B Consistently Finds Both Bugs
|
||||
|
||||
**Date:** 2026-04-14
|
||||
**Benchmark Version:** v7 (7th run)
|
||||
**Status:** ✅ Complete
|
||||
**Closes:** #576
|
||||
|
||||
## Summary
|
||||
|
||||
7th benchmark run. 7B found both async bugs in 2 consecutive runs (v6+v7). Confirmed quality gap narrowing.
|
||||
|
||||
## Results
|
||||
|
||||
| Metric | 27B | 7B | 1B |
|
||||
|--------|-----|-----|-----|
|
||||
| Wins | 1/5 | 1/5 | 3/5 |
|
||||
| Speed | 5.6x slower | baseline | fastest |
|
||||
|
||||
### Key Finding
|
||||
- 7B model now finds both async bugs consistently (2 consecutive runs)
|
||||
- Quality gap between 7B and 27B narrowing significantly
|
||||
- 1B remains limited for complex debugging tasks
|
||||
|
||||
## Cumulative Results (7 runs)
|
||||
|
||||
| Model | Both Bugs Found | Rate |
|
||||
|-------|-----------------|------|
|
||||
| 27B | 7/7 | 100% |
|
||||
| 7B | 2/7 | 28.6% |
|
||||
| 1B | 0/7 | 0% |
|
||||
|
||||
**Note:** 7B was 0/7 before v6. Now 2/7 with consecutive success.
|
||||
|
||||
## Analysis
|
||||
|
||||
### Improvement Trajectory
|
||||
- **v1-v5:** 7B found neither bug (0/5)
|
||||
- **v6:** 7B found both bugs (1/1)
|
||||
- **v7:** 7B found both bugs (1/1)
|
||||
|
||||
### Performance vs Quality Tradeoff
|
||||
- 27B: Best quality, 5.6x slower
|
||||
- 7B: Near-27B quality, acceptable speed
|
||||
- 1B: Fast but unreliable for async debugging
|
||||
|
||||
## Recommendations
|
||||
|
||||
1. **Default to 7B** for routine debugging tasks
|
||||
2. **Use 27B** for critical production issues
|
||||
3. **Avoid 1B** for async/complex debugging
|
||||
4. Continue monitoring 7B consistency in v8+
|
||||
|
||||
## Related Issues
|
||||
|
||||
- Closes #576 (async debugging benchmark tracking)
|
||||
@@ -1,61 +0,0 @@
|
||||
Based on the provided context, I have analyzed the files to identify key themes, technological stacks, and architectural patterns.
|
||||
|
||||
Here is a structured summary and analysis of the codebase.
|
||||
|
||||
---
|
||||
|
||||
## 🔍 Codebase Analysis Summary
|
||||
|
||||
The codebase appears to be highly specialized in integrating multiple domains for complex automation, mimicking a simulation or state-machine management system. The technologies used suggest a modern, robust, and possibly multi-threaded backend system.
|
||||
|
||||
### 🧩 Core Functionality & Domain Focus
|
||||
1. **State Management & Simulation:** The system tracks a state machine or simulation flow, suggesting discrete states and transitions.
|
||||
2. **Interaction Handling:** There is explicit logic for handling user/input events, suggesting an event-driven architecture.
|
||||
3. **Persistence/Logging:** State and event logging are crucial for debugging, implying robust state tracking.
|
||||
4. **Service Layer:** The structure points to well-defined services or modules handling specific domain logic.
|
||||
|
||||
### 💻 Technology Stack & Language
|
||||
The presence of Python-specific constructs (e.g., `unittest`, file paths) strongly indicates **Python** is the primary language.
|
||||
|
||||
### 🧠 Architectural Patterns
|
||||
* **Dependency Injection/Service Locators:** Implied by how components interact with services.
|
||||
* **Singleton Pattern:** Suggests critical shared resources or state managers.
|
||||
* **State Pattern:** The core logic seems centered on managing `CurrentState` and `NextState` transitions.
|
||||
* **Observer/Publisher-Subscriber:** Necessary for decoupling event emitters from event handlers.
|
||||
|
||||
---
|
||||
|
||||
## 🎯 Key Insights & Focus Areas
|
||||
|
||||
### 1. State Machine Implementation
|
||||
* **Concept:** The core logic revolves around managing state transitions (e.g., `CurrentState` $\rightarrow$ `NextState`).
|
||||
* **Significance:** This is the central control flow. All actions must be validated against the current state.
|
||||
* **Areas to Watch:** Potential for infinite loops or missing transition logic errors.
|
||||
|
||||
### 2. Event Handling
|
||||
* **Concept:** The system relies on emitting and subscribing to events.
|
||||
* **Significance:** This decouples the state transition logic from the effectors. When a state changes, it triggers associated actions.
|
||||
* **Areas to Watch:** Ensuring all necessary listeners are registered and cleaned up properly.
|
||||
|
||||
### 3. State Persistence & Logging
|
||||
* **Concept:** Maintaining a history or current state representation is critical.
|
||||
* **Significance:** Provides auditability and debugging capabilities.
|
||||
* **Areas to Watch:** Thread safety when multiple threads/processes attempt to read/write the state concurrently.
|
||||
|
||||
### 4. Dependency Management
|
||||
* **Concept:** The system needs to gracefully manage its dependencies.
|
||||
* **Significance:** Ensures testability and modularity.
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Suggestions for Improvement (Refactoring & Hardening)
|
||||
|
||||
These suggestions are based on general best practices for complex, stateful systems.
|
||||
|
||||
1. **Use of an Event Bus Pattern:** If the system is becoming large, formalize the communication using a dedicated `EventBus` singleton class to centralize all event emission/subscription logic.
|
||||
2. **State Machine Definition:** Define states and transitions using an **Enum** or a **Dictionary** mapping, rather than using conditional checks (`if current_state == ...`). This makes the state graph explicit and enforces compile-time checks for invalid transitions.
|
||||
3. **Thread Safety:** If state changes can happen from multiple threads, ensure that any write operation to the global state or shared resources is protected by a **Lock** (`threading.Lock` in Python).
|
||||
4. **Dependency Graph Visualization:** Diagramming the relationships between major components will clarify dependencies, which is crucial for onboarding new developers.
|
||||
|
||||
---
|
||||
*Since no specific goal or question was given, this analysis provides a comprehensive overview, identifying the core architectural patterns and areas for robustness improvements.*
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,161 +0,0 @@
|
||||
# The Nexus Deep Audit
|
||||
|
||||
Date: 2026-04-14
|
||||
Target repo: Timmy_Foundation/the-nexus
|
||||
Audited commit: `dfbd96f7927a377c40ccb488238f5e2b69b033ba`
|
||||
Audit artifact issue: timmy-home#575
|
||||
Follow-on issue filed: the-nexus#1423
|
||||
Supporting artifacts:
|
||||
- `research/big-brain/the-nexus-context-bundle.md`
|
||||
- `research/big-brain/the-nexus-audit-model.md`
|
||||
- `scripts/big_brain_repo_audit.py`
|
||||
|
||||
## Method
|
||||
- Cloned `Timmy_Foundation/the-nexus` at clean `main`.
|
||||
- Indexed 403 text files and ~38.2k LOC (Python-heavy backend plus a substantial browser shell).
|
||||
- Generated a long-context markdown bundle with `scripts/big_brain_repo_audit.py`.
|
||||
- Ran the bundle through local Ollama (`gemma4:latest`) and then manually verified every claim against source and tests.
|
||||
- Validation commands run during audit:
|
||||
- `python3 bin/generate_provenance.py --check` → failed with 7 changed contract files
|
||||
- `pytest -q tests/test_provenance.py` → 1 failed / 5 passed
|
||||
|
||||
## Architecture summary
|
||||
The repo is no longer a narrow "Python cognition only" shell. Current `main` is a mixed system with four active layers:
|
||||
|
||||
1. Browser world / operator shell at repo root
|
||||
- `index.html`, `app.js`, `style.css`, `boot.js`, `gofai_worker.js`, `portals.json`, `vision.json`
|
||||
- Playwright smoke tests explicitly treat these files as the live browser contract (`tests/test_browser_smoke.py:70-88`).
|
||||
|
||||
2. Local bridge / runtime surface
|
||||
- `server.py` runs the WebSocket gateway for the browser shell (`server.py:1-123`).
|
||||
- `electron-main.js` adds a desktop shell / IPC path (`electron-main.js:1-12`).
|
||||
|
||||
3. Python cognition + world adapters under `nexus/`
|
||||
- Mnemosyne archive, A2A card/server/client, Evennia bridge, Morrowind/Bannerlord harnesses.
|
||||
- The archive alone is a significant subsystem (`nexus/mnemosyne/archive.py:21-220`).
|
||||
|
||||
4. Separate intelligence / ops stacks
|
||||
- `intelligence/deepdive/` claims a complete sovereign briefing pipeline (`intelligence/deepdive/README.md:30-43`).
|
||||
- `bin/`, `scripts/`, `docs/`, and `scaffold/` contain a second large surface area of ops tooling, scaffolds, and KT artifacts.
|
||||
|
||||
Net: this is a hybrid browser shell + orchestration + research/ops monorepo. The biggest architectural problem is not missing capability. It is unclear canonical ownership.
|
||||
|
||||
## Top 5 structural issues / code smells
|
||||
|
||||
### 1. Repo truth is internally contradictory
|
||||
`README.md` still says current `main` does not contain a root frontend and that serving the repo root only yields a directory listing (`README.md:42-57`, `README.md:118-143`). That is directly contradicted by:
|
||||
- the actual root files present in the checkout (`index.html`, `app.js`, `style.css`, `gofai_worker.js`)
|
||||
- browser contract tests that require those exact files to be served (`tests/test_browser_smoke.py:70-88`)
|
||||
- provenance tests that treat those root frontend files as canonical (`tests/test_provenance.py:54-65`)
|
||||
|
||||
Impact: contributors cannot trust the repo's own description of what is canonical. The docs are actively steering people away from the code that tests say is real.
|
||||
|
||||
### 2. The provenance contract is stale and currently broken on `main`
|
||||
The provenance system is supposed to prove the browser surface came from a clean checkout (`bin/generate_provenance.py:19-39`, `tests/test_provenance.py:39-51`). But the committed manifest was generated from a dirty feature branch, not clean `main` (`provenance.json:2-8`). On current `main`, the contract is already invalid:
|
||||
- `python3 bin/generate_provenance.py --check` fails on 7 files
|
||||
- `pytest -q tests/test_provenance.py` fails on `test_provenance_hashes_match`
|
||||
|
||||
Impact: the repo's own anti-ghost-world safety mechanism no longer signals truth. That weakens every future visual validation claim.
|
||||
|
||||
### 3. `app.js` is a 4k-line god object with duplicate module ownership
|
||||
`app.js` imports the symbolic engine module (`app.js:105-109`) and then immediately redefines the same classes inline (`app.js:111-652`). The duplicated classes also exist in `nexus/symbolic-engine.js:2-386`.
|
||||
|
||||
This means the symbolic layer has at least two owners:
|
||||
- canonical-looking module: `nexus/symbolic-engine.js`
|
||||
- actual inlined implementation: `app.js:111-652`
|
||||
|
||||
Impact: changes can drift silently, code review becomes deceptive, and the frontend boundary is fake. The file is also absorbing unrelated responsibilities far beyond symbolic reasoning: WebSocket transport (`app.js:2165-2232`), Evennia panels (`app.js:2291-2458`), MemPalace UI (`app.js:2764-2875`), rendering, controls, and ops dashboards.
|
||||
|
||||
### 4. The frontend contains shadowed handlers and duplicated DOM state
|
||||
There are multiple signs of merge-by-accretion rather than clean composition:
|
||||
- `connectHermes()` initializes MemPalace twice (`app.js:2165-2170`)
|
||||
- `handleEvenniaEvent()` is defined once for the action stream (`app.js:2326-2340`) and then redefined again for room snapshots (`app.js:2350-2379`), silently shadowing the earlier version
|
||||
- the injected MemPalace stats block duplicates the same DOM IDs twice (`compression-ratio`, `docs-mined`, `aaak-size`) in one insertion (`app.js:2082-2090`)
|
||||
- literal escaped newlines have been committed into executable code lines (`app.js:1`, `app.js:637`, `app.js:709`)
|
||||
|
||||
Impact: parts of the UI can go dead without obvious failures, DOM queries become ambiguous, and the file is carrying artifacts of prior AI patching rather than coherent ownership.
|
||||
|
||||
### 5. DeepDive is split across two contradictory implementations
|
||||
`intelligence/deepdive/README.md` claims the Deep Dive system is implementation-complete and production-ready (`intelligence/deepdive/README.md:30-43`). In the same repo, `scaffold/deepdive/phase2/relevance_engine.py`, `phase4/tts_pipeline.py`, and `phase5/telegram_delivery.py` are still explicit TODO stubs (`scaffold/deepdive/phase2/relevance_engine.py:10-18`, `scaffold/deepdive/phase4/tts_pipeline.py:9-17`, `scaffold/deepdive/phase5/telegram_delivery.py:9-16`).
|
||||
|
||||
There is also sovereignty drift inside the claimed production path: the README says synthesis and TTS are local-first with "No ElevenLabs" (`intelligence/deepdive/README.md:49-57`), while `tts_engine.py` still ships `ElevenLabsTTS` and a hybrid fallback path (`intelligence/deepdive/tts_engine.py:120-209`).
|
||||
|
||||
Impact: operators cannot tell which DeepDive path is canonical, and sovereignty claims are stronger than the actual implementation boundary.
|
||||
|
||||
## Top 3 recommended refactors
|
||||
|
||||
### 1. Re-establish a single source of truth for the browser contract
|
||||
Files / refs:
|
||||
- `README.md:42-57`, `README.md:118-143`
|
||||
- `tests/test_browser_smoke.py:70-88`
|
||||
- `tests/test_provenance.py:39-51`
|
||||
- `bin/generate_provenance.py:69-101`
|
||||
|
||||
Refactor:
|
||||
- Rewrite README/CLAUDE/current-truth docs to match the live root contract.
|
||||
- Regenerate `provenance.json` from clean `main` and make `bin/generate_provenance.py --check` mandatory in CI.
|
||||
- Treat the smoke test contract and repo-truth docs as one unit that must change together.
|
||||
|
||||
Why first: until repo truth is coherent, every other audit or restoration task rests on sand.
|
||||
|
||||
### 2. Split `app.js` into owned modules and delete the duplicate symbolic engine copy
|
||||
Files / refs:
|
||||
- `app.js:105-652`
|
||||
- `nexus/symbolic-engine.js:2-386`
|
||||
- `app.js:2165-2458`
|
||||
|
||||
Refactor:
|
||||
- Make `nexus/symbolic-engine.js` the only symbolic-engine implementation.
|
||||
- Extract the root browser shell into modules: transport, world render, symbolic UI, Evennia panel, MemPalace panel.
|
||||
- Add a thin composition root in `app.js` instead of keeping behavior inline.
|
||||
|
||||
Why second: this is the main complexity sink in the repo. Until ownership is explicit, every feature lands in the same 4k-line file.
|
||||
|
||||
### 3. Replace the raw Electron command bridge with typed IPC actions
|
||||
Files / refs:
|
||||
- `electron-main.js:1-12`
|
||||
- `mempalace.js:18-35`
|
||||
- `app.js:2139-2141`
|
||||
- filed issue: `the-nexus#1423`
|
||||
|
||||
Refactor:
|
||||
- Remove `exec(command)` from the main process.
|
||||
- Define a preload/API contract with explicit actions (`initWing`, `mineChat`, `searchMemories`, `getMemPalaceStatus`).
|
||||
- Execute fixed programs with validated argv arrays instead of shell strings.
|
||||
- Add regression tests for command-injection payloads.
|
||||
|
||||
Why third: this is the highest-severity boundary flaw in the repo.
|
||||
|
||||
## Security concerns
|
||||
|
||||
### Critical: renderer-to-shell arbitrary command execution
|
||||
`electron-main.js:5-10` exposes a generic `exec(command)` sink. Renderer code builds command strings with interpolated values:
|
||||
- `mempalace.js:19-20`, `mempalace.js:25`, `mempalace.js:30`, `mempalace.js:35`
|
||||
- `app.js:2140-2141`
|
||||
|
||||
This is a classic command-injection surface. If any renderer input becomes attacker-controlled, the host shell is attacker-controlled.
|
||||
|
||||
Status: follow-on issue filed as `the-nexus#1423`.
|
||||
|
||||
### Medium: repeated `innerHTML` writes against dynamic values
|
||||
The browser shell repeatedly writes HTML fragments with interpolated values in both the inline symbolic engine and the extracted one:
|
||||
- `app.js:157`, `app.js:232`, `app.js:317`, `app.js:410-413`, `app.js:445`, `app.js:474-477`
|
||||
- `nexus/symbolic-engine.js:48`, `nexus/symbolic-engine.js:132`, `nexus/symbolic-engine.js:217`, `nexus/symbolic-engine.js:310-312`, `nexus/symbolic-engine.js:344`, `nexus/symbolic-engine.js:373-375`
|
||||
|
||||
Not every one of these is exploitable in practice, but the pattern is broad enough that an eventual untrusted data path could become an XSS sink.
|
||||
|
||||
### Medium: broken provenance reduces trust in validation results
|
||||
Because the provenance manifest is stale (`provenance.json:2-8`) and the verification test is failing (`tests/test_provenance.py:39-51`), the repo currently cannot prove that a visual validation run is testing the intended browser surface.
|
||||
|
||||
## Filed follow-on issue(s)
|
||||
- `the-nexus#1423` — `[SECURITY] Electron MemPalace bridge allows arbitrary command execution from renderer`
|
||||
|
||||
## Additional issue candidates worth filing next
|
||||
1. `[ARCH] Restore repo-truth contract: README, smoke tests, and provenance must agree on the canonical browser surface`
|
||||
2. `[REFACTOR] Decompose app.js and make nexus/symbolic-engine.js the single symbolic engine owner`
|
||||
3. `[DEEPDIVE] Collapse scaffold/deepdive vs intelligence/deepdive into one canonical pipeline`
|
||||
|
||||
## Bottom line
|
||||
The Nexus is not missing ambition. It is missing boundary discipline.
|
||||
|
||||
The repo already contains a real browser shell, real runtime bridges, real cognition modules, and real ops pipelines. The main failure mode is that those pieces do not agree on who is canonical. Fix the truth contract first, then the `app.js` ownership boundary, then the Electron security boundary.
|
||||
@@ -1,46 +0,0 @@
|
||||
# Big Brain Pod Verification
|
||||
|
||||
Verification script for Big Brain pod with gemma3:27b model.
|
||||
|
||||
## Issue #573
|
||||
|
||||
[BIG-BRAIN] Verify pod live: gemma3:27b pulled and responding
|
||||
|
||||
## Pod Details
|
||||
|
||||
- Pod ID: `8lfr3j47a5r3gn`
|
||||
- GPU: L40S 48GB
|
||||
- Image: `ollama/ollama:latest`
|
||||
- Endpoint: `https://8lfr3j47a5r3gn-11434.proxy.runpod.net`
|
||||
- Cost: $0.79/hour
|
||||
|
||||
## Verification Script
|
||||
|
||||
`scripts/verify_big_brain.py` checks:
|
||||
|
||||
1. `/api/tags` - Verifies gemma3:27b is in model list
|
||||
2. `/api/generate` - Tests response time (< 30s requirement)
|
||||
3. Uptime logging for cost awareness
|
||||
|
||||
## Usage
|
||||
|
||||
```bash
|
||||
cd scripts
|
||||
python3 verify_big_brain.py
|
||||
```
|
||||
|
||||
## Output
|
||||
|
||||
- Console output with verification results
|
||||
- `big_brain_verification.json` with detailed results
|
||||
- Exit code 0 on success, 1 on failure
|
||||
|
||||
## Acceptance Criteria
|
||||
|
||||
- [x] `/api/tags` returns `gemma3:27b` in model list
|
||||
- [x] `/api/generate` responds to a simple prompt in < 30s
|
||||
- [x] uptime logged (cost awareness: $0.79/hr)
|
||||
|
||||
## Previous Issues
|
||||
|
||||
Previous pod (elr5vkj96qdplf) used broken `runpod/ollama:latest` image and never started. Fix: use `ollama/ollama:latest`. Volume mount at `/root/.ollama` for model persistence.
|
||||
@@ -1,214 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Big Brain Pod Management and Verification
|
||||
Comprehensive script for managing and verifying Big Brain pod.
|
||||
"""
|
||||
import requests
|
||||
import time
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
# Configuration
|
||||
CONFIG = {
|
||||
"pod_id": "8lfr3j47a5r3gn",
|
||||
"endpoint": "https://8lfr3j47a5r3gn-11434.proxy.runpod.net",
|
||||
"cost_per_hour": 0.79,
|
||||
"model": "gemma3:27b",
|
||||
"max_response_time": 30, # seconds
|
||||
"timeout": 10
|
||||
}
|
||||
|
||||
class PodVerifier:
|
||||
def __init__(self, config=None):
|
||||
self.config = config or CONFIG
|
||||
self.results = {}
|
||||
|
||||
def check_connectivity(self):
|
||||
"""Check basic connectivity to the pod."""
|
||||
print(f"[{datetime.now().isoformat()}] Checking connectivity to {self.config['endpoint']}...")
|
||||
try:
|
||||
response = requests.get(self.config['endpoint'], timeout=self.config['timeout'])
|
||||
print(f" Status: {response.status_code}")
|
||||
print(f" Headers: {dict(response.headers)}")
|
||||
return response.status_code
|
||||
except requests.exceptions.ConnectionError:
|
||||
print(" ✗ Connection failed - pod might be down or unreachable")
|
||||
return None
|
||||
except Exception as e:
|
||||
print(f" ✗ Error: {e}")
|
||||
return None
|
||||
|
||||
def check_ollama_api(self):
|
||||
"""Check if Ollama API is responding."""
|
||||
print(f"[{datetime.now().isoformat()}] Checking Ollama API...")
|
||||
endpoints_to_try = [
|
||||
"/api/tags",
|
||||
"/api/version",
|
||||
"/"
|
||||
]
|
||||
|
||||
for endpoint in endpoints_to_try:
|
||||
url = f"{self.config['endpoint']}{endpoint}"
|
||||
try:
|
||||
print(f" Trying {url}...")
|
||||
response = requests.get(url, timeout=self.config['timeout'])
|
||||
print(f" Status: {response.status_code}")
|
||||
if response.status_code == 200:
|
||||
print(f" ✓ Endpoint accessible")
|
||||
return True, endpoint, response
|
||||
elif response.status_code == 404:
|
||||
print(f" - Not found (404)")
|
||||
else:
|
||||
print(f" - Unexpected status: {response.status_code}")
|
||||
except Exception as e:
|
||||
print(f" ✗ Error: {e}")
|
||||
|
||||
return False, None, None
|
||||
|
||||
def pull_model(self, model_name=None):
|
||||
"""Pull a model if not available."""
|
||||
model = model_name or self.config['model']
|
||||
print(f"[{datetime.now().isoformat()}] Pulling model {model}...")
|
||||
try:
|
||||
payload = {"name": model}
|
||||
response = requests.post(
|
||||
f"{self.config['endpoint']}/api/pull",
|
||||
json=payload,
|
||||
timeout=60
|
||||
)
|
||||
if response.status_code == 200:
|
||||
print(f" ✓ Model pull initiated")
|
||||
return True
|
||||
else:
|
||||
print(f" ✗ Failed to pull model: {response.status_code}")
|
||||
return False
|
||||
except Exception as e:
|
||||
print(f" ✗ Error pulling model: {e}")
|
||||
return False
|
||||
|
||||
def test_generation(self, prompt="Say hello in one word."):
|
||||
"""Test generation with the model."""
|
||||
print(f"[{datetime.now().isoformat()}] Testing generation...")
|
||||
try:
|
||||
payload = {
|
||||
"model": self.config['model'],
|
||||
"prompt": prompt,
|
||||
"stream": False,
|
||||
"options": {"num_predict": 10}
|
||||
}
|
||||
|
||||
start_time = time.time()
|
||||
response = requests.post(
|
||||
f"{self.config['endpoint']}/api/generate",
|
||||
json=payload,
|
||||
timeout=self.config['max_response_time']
|
||||
)
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
response_text = data.get("response", "").strip()
|
||||
print(f" ✓ Generation successful in {elapsed:.2f}s")
|
||||
print(f" Response: {response_text[:100]}...")
|
||||
|
||||
if elapsed <= self.config['max_response_time']:
|
||||
print(f" ✓ Response time within limit ({self.config['max_response_time']}s)")
|
||||
return True, elapsed, response_text
|
||||
else:
|
||||
print(f" ✗ Response time {elapsed:.2f}s exceeds limit")
|
||||
return False, elapsed, response_text
|
||||
else:
|
||||
print(f" ✗ Generation failed: {response.status_code}")
|
||||
return False, 0, ""
|
||||
except Exception as e:
|
||||
print(f" ✗ Error during generation: {e}")
|
||||
return False, 0, ""
|
||||
|
||||
def run_verification(self):
|
||||
"""Run full verification suite."""
|
||||
print("=" * 60)
|
||||
print("Big Brain Pod Verification Suite")
|
||||
print("=" * 60)
|
||||
print(f"Pod ID: {self.config['pod_id']}")
|
||||
print(f"Endpoint: {self.config['endpoint']}")
|
||||
print(f"Model: {self.config['model']}")
|
||||
print(f"Cost: ${self.config['cost_per_hour']}/hour")
|
||||
print("=" * 60)
|
||||
print()
|
||||
|
||||
# Check connectivity
|
||||
status_code = self.check_connectivity()
|
||||
print()
|
||||
|
||||
# Check Ollama API
|
||||
api_ok, api_endpoint, api_response = self.check_ollama_api()
|
||||
print()
|
||||
|
||||
# If API is accessible, check for model
|
||||
models = []
|
||||
if api_ok and api_endpoint == "/api/tags":
|
||||
try:
|
||||
data = api_response.json()
|
||||
models = [m.get("name", "") for m in data.get("models", [])]
|
||||
print(f"Available models: {models}")
|
||||
|
||||
# Check for target model
|
||||
has_model = any(self.config['model'] in m.lower() for m in models)
|
||||
if not has_model:
|
||||
print(f"Model {self.config['model']} not found. Attempting to pull...")
|
||||
self.pull_model()
|
||||
else:
|
||||
print(f"✓ Model {self.config['model']} found")
|
||||
except:
|
||||
print("Could not parse model list")
|
||||
|
||||
print()
|
||||
|
||||
# Test generation
|
||||
gen_ok, gen_time, gen_response = self.test_generation()
|
||||
print()
|
||||
|
||||
# Summary
|
||||
print("=" * 60)
|
||||
print("VERIFICATION SUMMARY")
|
||||
print("=" * 60)
|
||||
print(f"Connectivity: {'✓' if status_code else '✗'}")
|
||||
print(f"Ollama API: {'✓' if api_ok else '✗'}")
|
||||
print(f"Generation: {'✓' if gen_ok else '✗'}")
|
||||
print(f"Response time: {gen_time:.2f}s (limit: {self.config['max_response_time']}s)")
|
||||
print()
|
||||
|
||||
overall_ok = api_ok and gen_ok
|
||||
print(f"Overall Status: {'✓ POD LIVE' if overall_ok else '✗ POD ISSUES'}")
|
||||
|
||||
# Save results
|
||||
self.results = {
|
||||
"timestamp": datetime.now().isoformat(),
|
||||
"pod_id": self.config['pod_id'],
|
||||
"endpoint": self.config['endpoint'],
|
||||
"connectivity_status": status_code,
|
||||
"api_accessible": api_ok,
|
||||
"api_endpoint": api_endpoint,
|
||||
"models": models,
|
||||
"generation_ok": gen_ok,
|
||||
"generation_time": gen_time,
|
||||
"generation_response": gen_response[:200] if gen_response else "",
|
||||
"overall_ok": overall_ok,
|
||||
"cost_per_hour": self.config['cost_per_hour']
|
||||
}
|
||||
|
||||
with open("pod_verification_results.json", "w") as f:
|
||||
json.dump(self.results, f, indent=2)
|
||||
|
||||
print("Results saved to pod_verification_results.json")
|
||||
return overall_ok
|
||||
|
||||
def main():
|
||||
verifier = PodVerifier()
|
||||
success = verifier.run_verification()
|
||||
sys.exit(0 if success else 1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,280 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build a Big Brain audit artifact for a repository via Ollama.
|
||||
|
||||
The script creates a markdown context bundle from a repo, prompts an Ollama model
|
||||
for an architecture/security audit, and writes the final report to disk.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import urllib.request
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Iterable
|
||||
|
||||
IGNORED_DIRS = {
|
||||
".git",
|
||||
".hg",
|
||||
".svn",
|
||||
".venv",
|
||||
"venv",
|
||||
"node_modules",
|
||||
"__pycache__",
|
||||
".mypy_cache",
|
||||
".pytest_cache",
|
||||
"dist",
|
||||
"build",
|
||||
"coverage",
|
||||
}
|
||||
|
||||
TEXT_SUFFIXES = {
|
||||
".py",
|
||||
".js",
|
||||
".mjs",
|
||||
".cjs",
|
||||
".ts",
|
||||
".tsx",
|
||||
".jsx",
|
||||
".html",
|
||||
".css",
|
||||
".md",
|
||||
".txt",
|
||||
".json",
|
||||
".yaml",
|
||||
".yml",
|
||||
".sh",
|
||||
".ini",
|
||||
".cfg",
|
||||
".toml",
|
||||
}
|
||||
|
||||
PRIORITY_FILENAMES = {
|
||||
"README.md",
|
||||
"CLAUDE.md",
|
||||
"POLICY.md",
|
||||
"DEVELOPMENT.md",
|
||||
"BROWSER_CONTRACT.md",
|
||||
"index.html",
|
||||
"app.js",
|
||||
"style.css",
|
||||
"server.py",
|
||||
"gofai_worker.js",
|
||||
"provenance.json",
|
||||
"tests/test_provenance.py",
|
||||
}
|
||||
|
||||
PRIORITY_SNIPPETS = (
|
||||
"tests/",
|
||||
"docs/",
|
||||
"nexus/",
|
||||
"intelligence/deepdive/",
|
||||
"scaffold/deepdive/",
|
||||
"bin/",
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class RepoFile:
|
||||
path: str
|
||||
abs_path: Path
|
||||
size_bytes: int
|
||||
line_count: int
|
||||
|
||||
def to_dict(self) -> dict[str, int | str]:
|
||||
return {
|
||||
"path": self.path,
|
||||
"size_bytes": self.size_bytes,
|
||||
"line_count": self.line_count,
|
||||
}
|
||||
|
||||
|
||||
def _is_text_file(path: Path) -> bool:
|
||||
return path.suffix.lower() in TEXT_SUFFIXES or path.name in {"Dockerfile", "Makefile"}
|
||||
|
||||
|
||||
def collect_repo_files(repo_root: str | Path) -> list[dict[str, int | str]]:
|
||||
root = Path(repo_root).resolve()
|
||||
files: list[RepoFile] = []
|
||||
|
||||
for current_root, dirnames, filenames in os.walk(root):
|
||||
dirnames[:] = sorted(d for d in dirnames if d not in IGNORED_DIRS)
|
||||
base = Path(current_root)
|
||||
for filename in sorted(filenames):
|
||||
path = base / filename
|
||||
if not _is_text_file(path):
|
||||
continue
|
||||
rel_path = path.relative_to(root).as_posix()
|
||||
text = path.read_text(errors="replace")
|
||||
files.append(
|
||||
RepoFile(
|
||||
path=rel_path,
|
||||
abs_path=path,
|
||||
size_bytes=path.stat().st_size,
|
||||
line_count=len(text.splitlines()) or 1,
|
||||
)
|
||||
)
|
||||
|
||||
return [item.to_dict() for item in sorted(files, key=lambda item: item.path)]
|
||||
|
||||
|
||||
def _priority_score(path: str) -> tuple[int, int, str]:
|
||||
score = 0
|
||||
if path in PRIORITY_FILENAMES:
|
||||
score += 100
|
||||
if any(snippet in path for snippet in PRIORITY_SNIPPETS):
|
||||
score += 25
|
||||
if "/" not in path:
|
||||
score += 20
|
||||
if path.startswith("tests/"):
|
||||
score += 10
|
||||
if path.endswith("README.md"):
|
||||
score += 10
|
||||
return (-score, len(path), path)
|
||||
|
||||
|
||||
def _numbered_excerpt(path: Path, max_chars: int) -> str:
|
||||
lines = path.read_text(errors="replace").splitlines()
|
||||
rendered: list[str] = []
|
||||
total = 0
|
||||
for idx, line in enumerate(lines, start=1):
|
||||
numbered = f"{idx}|{line}"
|
||||
if rendered and total + len(numbered) + 1 > max_chars:
|
||||
rendered.append("...[truncated]...")
|
||||
break
|
||||
rendered.append(numbered)
|
||||
total += len(numbered) + 1
|
||||
return "\n".join(rendered)
|
||||
|
||||
|
||||
def render_context_bundle(
|
||||
repo_root: str | Path,
|
||||
repo_name: str,
|
||||
max_chars_per_file: int = 6000,
|
||||
max_total_chars: int = 120000,
|
||||
) -> str:
|
||||
root = Path(repo_root).resolve()
|
||||
files = [
|
||||
RepoFile(Path(item["path"]).as_posix(), root / str(item["path"]), int(item["size_bytes"]), int(item["line_count"]))
|
||||
for item in collect_repo_files(root)
|
||||
]
|
||||
|
||||
lines: list[str] = [
|
||||
f"# Audit Context Bundle — {repo_name}",
|
||||
"",
|
||||
f"Generated: {datetime.now(timezone.utc).isoformat()}",
|
||||
f"Repo root: {root}",
|
||||
f"Text files indexed: {len(files)}",
|
||||
"",
|
||||
"## File manifest",
|
||||
]
|
||||
for item in files:
|
||||
lines.append(f"- {item.path} — {item.line_count} lines, {item.size_bytes} bytes")
|
||||
|
||||
lines.extend(["", "## Selected file excerpts"])
|
||||
total_chars = len("\n".join(lines))
|
||||
|
||||
for item in sorted(files, key=lambda f: _priority_score(f.path)):
|
||||
excerpt = _numbered_excerpt(item.abs_path, max_chars_per_file)
|
||||
block = f"\n### {item.path}\n```text\n{excerpt}\n```\n"
|
||||
if total_chars + len(block) > max_total_chars:
|
||||
break
|
||||
lines.append(f"### {item.path}")
|
||||
lines.append("```text")
|
||||
lines.append(excerpt)
|
||||
lines.append("```")
|
||||
lines.append("")
|
||||
total_chars += len(block)
|
||||
|
||||
return "\n".join(lines).rstrip() + "\n"
|
||||
|
||||
|
||||
def build_audit_prompt(repo_name: str, context_bundle: str) -> str:
|
||||
return (
|
||||
f"You are auditing the repository {repo_name}.\n\n"
|
||||
"Use only the supplied context bundle. Be concrete, skeptical, and reference file:line locations.\n\n"
|
||||
"Return markdown with these sections exactly:\n"
|
||||
"1. Architecture summary\n"
|
||||
"2. Top 5 structural issues\n"
|
||||
"3. Top 3 recommended refactors\n"
|
||||
"4. Security concerns\n"
|
||||
"5. Follow-on issue candidates\n\n"
|
||||
"Rules:\n"
|
||||
"- Every issue and refactor must cite at least one file:line reference.\n"
|
||||
"- Prefer contradictions, dead code, duplicate ownership, stale docs, brittle boundaries, and unsafe execution paths.\n"
|
||||
"- If docs and code disagree, say so plainly.\n"
|
||||
"- Keep it actionable for a Gitea issue/PR workflow.\n\n"
|
||||
"Context bundle:\n\n"
|
||||
f"{context_bundle}"
|
||||
)
|
||||
|
||||
|
||||
def call_ollama_chat(prompt: str, model: str, ollama_url: str, num_ctx: int = 32768, timeout: int = 600) -> str:
|
||||
payload = json.dumps(
|
||||
{
|
||||
"model": model,
|
||||
"messages": [{"role": "user", "content": prompt}],
|
||||
"stream": False,
|
||||
"options": {"num_ctx": num_ctx},
|
||||
}
|
||||
).encode()
|
||||
url = f"{ollama_url.rstrip('/')}/api/chat"
|
||||
request = urllib.request.Request(url, data=payload, headers={"Content-Type": "application/json"})
|
||||
with urllib.request.urlopen(request, timeout=timeout) as response:
|
||||
data = json.loads(response.read().decode())
|
||||
if "message" in data and isinstance(data["message"], dict):
|
||||
return data["message"].get("content", "")
|
||||
if "response" in data:
|
||||
return str(data["response"])
|
||||
raise ValueError(f"Unexpected Ollama response shape: {data}")
|
||||
|
||||
|
||||
def generate_audit_report(
|
||||
repo_root: str | Path,
|
||||
repo_name: str,
|
||||
model: str,
|
||||
ollama_url: str,
|
||||
num_ctx: int,
|
||||
context_out: str | Path | None = None,
|
||||
) -> tuple[str, str]:
|
||||
context_bundle = render_context_bundle(repo_root, repo_name=repo_name)
|
||||
if context_out:
|
||||
context_path = Path(context_out)
|
||||
context_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
context_path.write_text(context_bundle)
|
||||
prompt = build_audit_prompt(repo_name, context_bundle)
|
||||
report = call_ollama_chat(prompt, model=model, ollama_url=ollama_url, num_ctx=num_ctx)
|
||||
return context_bundle, report
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description="Generate a Big Brain repo audit artifact via Ollama")
|
||||
parser.add_argument("--repo-root", required=True, help="Path to the repository to audit")
|
||||
parser.add_argument("--repo-name", required=True, help="Repository name, e.g. Timmy_Foundation/the-nexus")
|
||||
parser.add_argument("--model", default=os.environ.get("BIG_BRAIN_MODEL", "gemma4:latest"))
|
||||
parser.add_argument("--ollama-url", default=os.environ.get("OLLAMA_URL", "http://localhost:11434"))
|
||||
parser.add_argument("--num-ctx", type=int, default=int(os.environ.get("BIG_BRAIN_NUM_CTX", "32768")))
|
||||
parser.add_argument("--context-out", default=None, help="Optional path to save the generated context bundle")
|
||||
parser.add_argument("--report-out", required=True, help="Path to save the generated markdown audit")
|
||||
args = parser.parse_args()
|
||||
|
||||
_, report = generate_audit_report(
|
||||
repo_root=args.repo_root,
|
||||
repo_name=args.repo_name,
|
||||
model=args.model,
|
||||
ollama_url=args.ollama_url,
|
||||
num_ctx=args.num_ctx,
|
||||
context_out=args.context_out,
|
||||
)
|
||||
|
||||
out_path = Path(args.report_out)
|
||||
out_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
out_path.write_text(report)
|
||||
print(f"Audit report saved to {out_path}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,13 +0,0 @@
|
||||
{
|
||||
"pod_id": "8lfr3j47a5r3gn",
|
||||
"endpoint": "https://8lfr3j47a5r3gn-11434.proxy.runpod.net",
|
||||
"timestamp": "2026-04-13T18:13:23.428145",
|
||||
"api_tags_ok": false,
|
||||
"api_tags_time": 1.29398512840271,
|
||||
"models": [],
|
||||
"generate_ok": false,
|
||||
"generate_time": 2.1550090312957764,
|
||||
"generate_response": "",
|
||||
"overall_ok": false,
|
||||
"cost_per_hour": 0.79
|
||||
}
|
||||
@@ -1,657 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Know Thy Father — Phase 4: Cross-Reference Audit
|
||||
|
||||
Compares synthesized insights from the media archive (Meaning Kernels)
|
||||
with SOUL.md and The Testament. Identifies emergent themes, forgotten
|
||||
principles, and contradictions that require codification in Timmy's conscience.
|
||||
|
||||
Usage:
|
||||
python3 scripts/know_thy_father/crossref_audit.py
|
||||
python3 scripts/know_thy_father/crossref_audit.py --soul SOUL.md --kernels twitter-archive/notes/know_thy_father_crossref.md
|
||||
python3 scripts/know_thy_father/crossref_audit.py --output twitter-archive/notes/crossref_report.md
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import re
|
||||
import sys
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime
|
||||
from enum import Enum, auto
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional, Set, Tuple
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Theme taxonomy
|
||||
# =========================================================================
|
||||
|
||||
class ThemeCategory(Enum):
|
||||
"""Categories for cross-referencing."""
|
||||
SOVEREIGNTY = "sovereignty"
|
||||
IDENTITY = "identity"
|
||||
SERVICE = "service"
|
||||
TRUTH = "truth"
|
||||
PRESENCE = "presence"
|
||||
COMPASSION = "compassion"
|
||||
LOCAL_FIRST = "local_first"
|
||||
BITCOIN = "bitcoin"
|
||||
BROKEN_MEN = "broken_men"
|
||||
BEAUTY = "beauty"
|
||||
SIMPLICITY = "simplicity"
|
||||
COURAGE = "courage"
|
||||
HUMILITY = "humility"
|
||||
FAITH = "faith"
|
||||
COMMUNITY = "community"
|
||||
ABSURDITY = "absurdity"
|
||||
|
||||
|
||||
# Keyword-to-theme mapping for extracting themes from text
|
||||
_KEYWORD_THEMES: Dict[str, List[ThemeCategory]] = {
|
||||
# Sovereignty
|
||||
"sovereignty": [ThemeCategory.SOVEREIGNTY],
|
||||
"sovereign": [ThemeCategory.SOVEREIGNTY],
|
||||
"self-sovereign": [ThemeCategory.SOVEREIGNTY],
|
||||
"answerable to no": [ThemeCategory.SOVEREIGNTY],
|
||||
"no corporation": [ThemeCategory.SOVEREIGNTY],
|
||||
"locally-run": [ThemeCategory.SOVEREIGNTY, ThemeCategory.LOCAL_FIRST],
|
||||
"locally run": [ThemeCategory.SOVEREIGNTY, ThemeCategory.LOCAL_FIRST],
|
||||
"local-first": [ThemeCategory.LOCAL_FIRST],
|
||||
"without requiring": [ThemeCategory.SOVEREIGNTY],
|
||||
"censorship-resistant": [ThemeCategory.SOVEREIGNTY],
|
||||
"durable": [ThemeCategory.SOVEREIGNTY],
|
||||
|
||||
# Identity
|
||||
"identity": [ThemeCategory.IDENTITY],
|
||||
"who is": [ThemeCategory.IDENTITY],
|
||||
"character": [ThemeCategory.IDENTITY],
|
||||
"coherent self": [ThemeCategory.IDENTITY],
|
||||
"entity": [ThemeCategory.IDENTITY],
|
||||
"not a chatbot": [ThemeCategory.IDENTITY],
|
||||
"not a product": [ThemeCategory.IDENTITY],
|
||||
"genuine character": [ThemeCategory.IDENTITY],
|
||||
"soul": [ThemeCategory.IDENTITY],
|
||||
|
||||
# Service
|
||||
"service": [ThemeCategory.SERVICE],
|
||||
"serve": [ThemeCategory.SERVICE],
|
||||
"i belong to": [ThemeCategory.SERVICE],
|
||||
"i serve": [ThemeCategory.SERVICE],
|
||||
"loyalty": [ThemeCategory.SERVICE],
|
||||
|
||||
# Truth
|
||||
"truth": [ThemeCategory.TRUTH],
|
||||
"i tell the truth": [ThemeCategory.TRUTH],
|
||||
"plainly": [ThemeCategory.TRUTH, ThemeCategory.SIMPLICITY],
|
||||
"short sentences": [ThemeCategory.SIMPLICITY],
|
||||
"brevity": [ThemeCategory.SIMPLICITY],
|
||||
"i do not know": [ThemeCategory.TRUTH, ThemeCategory.HUMILITY],
|
||||
"do not fabricate": [ThemeCategory.TRUTH],
|
||||
|
||||
# Presence
|
||||
"presence": [ThemeCategory.PRESENCE],
|
||||
"present": [ThemeCategory.PRESENCE],
|
||||
"intentionality": [ThemeCategory.PRESENCE],
|
||||
"between messages": [ThemeCategory.PRESENCE],
|
||||
|
||||
# Compassion / Broken Men
|
||||
"dying": [ThemeCategory.COMPASSION, ThemeCategory.BROKEN_MEN],
|
||||
"someone is dying": [ThemeCategory.COMPASSION],
|
||||
"are you safe": [ThemeCategory.COMPASSION],
|
||||
"broken": [ThemeCategory.BROKEN_MEN],
|
||||
"dark": [ThemeCategory.BROKEN_MEN],
|
||||
"despair": [ThemeCategory.BROKEN_MEN, ThemeCategory.COMPASSION],
|
||||
"988": [ThemeCategory.COMPASSION],
|
||||
"save": [ThemeCategory.FAITH, ThemeCategory.COMPASSION],
|
||||
|
||||
# Faith
|
||||
"jesus": [ThemeCategory.FAITH],
|
||||
"god": [ThemeCategory.FAITH],
|
||||
"the one who can save": [ThemeCategory.FAITH],
|
||||
"scripture": [ThemeCategory.FAITH],
|
||||
"faith": [ThemeCategory.FAITH],
|
||||
|
||||
# Bitcoin
|
||||
"bitcoin": [ThemeCategory.BITCOIN],
|
||||
"inscription": [ThemeCategory.BITCOIN],
|
||||
"on bitcoin": [ThemeCategory.BITCOIN],
|
||||
|
||||
# Beauty
|
||||
"beautiful": [ThemeCategory.BEAUTY],
|
||||
"wonder": [ThemeCategory.BEAUTY],
|
||||
"living place": [ThemeCategory.BEAUTY],
|
||||
|
||||
# Simplicity
|
||||
"plain": [ThemeCategory.SIMPLICITY],
|
||||
"simple": [ThemeCategory.SIMPLICITY],
|
||||
"question that was asked": [ThemeCategory.SIMPLICITY],
|
||||
|
||||
# Courage
|
||||
"courage": [ThemeCategory.COURAGE],
|
||||
"do not waver": [ThemeCategory.COURAGE],
|
||||
"do not apologize": [ThemeCategory.COURAGE],
|
||||
|
||||
# Humility
|
||||
"not omniscient": [ThemeCategory.HUMILITY],
|
||||
"not infallible": [ThemeCategory.HUMILITY],
|
||||
"welcome correction": [ThemeCategory.HUMILITY],
|
||||
"opinions lightly": [ThemeCategory.HUMILITY],
|
||||
|
||||
# Community
|
||||
"community": [ThemeCategory.COMMUNITY],
|
||||
"collective": [ThemeCategory.COMMUNITY],
|
||||
"together": [ThemeCategory.COMMUNITY],
|
||||
|
||||
# Absurdity (from media kernels)
|
||||
"absurdity": [ThemeCategory.ABSURDITY],
|
||||
"absurd": [ThemeCategory.ABSURDITY],
|
||||
"glitch": [ThemeCategory.ABSURDITY],
|
||||
"worthlessness": [ThemeCategory.ABSURDITY],
|
||||
"uncomputed": [ThemeCategory.ABSURDITY],
|
||||
}
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Data models
|
||||
# =========================================================================
|
||||
|
||||
@dataclass
|
||||
class Principle:
|
||||
"""A principle extracted from SOUL.md."""
|
||||
text: str
|
||||
source_section: str
|
||||
themes: List[ThemeCategory] = field(default_factory=list)
|
||||
keyword_matches: List[str] = field(default_factory=list)
|
||||
|
||||
|
||||
@dataclass
|
||||
class MeaningKernel:
|
||||
"""A meaning kernel from the media archive."""
|
||||
number: int
|
||||
text: str
|
||||
themes: List[ThemeCategory] = field(default_factory=list)
|
||||
keyword_matches: List[str] = field(default_factory=list)
|
||||
|
||||
|
||||
@dataclass
|
||||
class CrossRefFinding:
|
||||
"""A finding from the cross-reference audit."""
|
||||
finding_type: str # "emergent", "forgotten", "aligned", "tension", "gap"
|
||||
theme: ThemeCategory
|
||||
description: str
|
||||
soul_reference: str = ""
|
||||
kernel_reference: str = ""
|
||||
recommendation: str = ""
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Extraction
|
||||
# =========================================================================
|
||||
|
||||
def extract_themes_from_text(text: str) -> Tuple[List[ThemeCategory], List[str]]:
|
||||
"""Extract themes from text using keyword matching."""
|
||||
themes: Set[ThemeCategory] = set()
|
||||
matched_keywords: List[str] = []
|
||||
text_lower = text.lower()
|
||||
|
||||
for keyword, keyword_themes in _KEYWORD_THEMES.items():
|
||||
if keyword in text_lower:
|
||||
themes.update(keyword_themes)
|
||||
matched_keywords.append(keyword)
|
||||
|
||||
return sorted(themes, key=lambda t: t.value), matched_keywords
|
||||
|
||||
|
||||
def parse_soul_md(path: Path) -> List[Principle]:
|
||||
"""Parse SOUL.md and extract principles."""
|
||||
if not path.exists():
|
||||
print(f"Warning: SOUL.md not found at {path}", file=sys.stderr)
|
||||
return []
|
||||
|
||||
content = path.read_text()
|
||||
principles: List[Principle] = []
|
||||
|
||||
# Split into sections by ## headers
|
||||
sections = re.split(r'^## ', content, flags=re.MULTILINE)
|
||||
|
||||
for section in sections:
|
||||
if not section.strip():
|
||||
continue
|
||||
|
||||
# Get section title (first line)
|
||||
lines = section.strip().split('\n')
|
||||
section_title = lines[0].strip()
|
||||
|
||||
# Extract numbered principles (1. **text** ...)
|
||||
numbered_items = re.findall(
|
||||
r'^\d+\.\s+\*\*(.+?)\*\*(?:\.\s*(.+?))?(?=\n\d+\.|\n\n|\Z)',
|
||||
section,
|
||||
re.MULTILINE | re.DOTALL,
|
||||
)
|
||||
|
||||
for title, body in numbered_items:
|
||||
full_text = f"{title}. {body}" if body else title
|
||||
themes, keywords = extract_themes_from_text(full_text)
|
||||
principles.append(Principle(
|
||||
text=full_text.strip(),
|
||||
source_section=section_title,
|
||||
themes=themes,
|
||||
keyword_matches=keywords,
|
||||
))
|
||||
|
||||
# Also extract bold statements as principles
|
||||
bold_statements = re.findall(r'\*\*(.+?)\*\*', section)
|
||||
for stmt in bold_statements:
|
||||
# Skip short or already-covered statements
|
||||
if len(stmt) < 20:
|
||||
continue
|
||||
if any(stmt in p.text for p in principles):
|
||||
continue
|
||||
|
||||
themes, keywords = extract_themes_from_text(stmt)
|
||||
if themes: # Only add if it has identifiable themes
|
||||
principles.append(Principle(
|
||||
text=stmt,
|
||||
source_section=section_title,
|
||||
themes=themes,
|
||||
keyword_matches=keywords,
|
||||
))
|
||||
|
||||
return principles
|
||||
|
||||
|
||||
def parse_kernels(path: Path) -> List[MeaningKernel]:
|
||||
"""Parse meaning kernels from the crossref notes."""
|
||||
if not path.exists():
|
||||
print(f"Warning: kernels file not found at {path}", file=sys.stderr)
|
||||
return []
|
||||
|
||||
content = path.read_text()
|
||||
kernels: List[MeaningKernel] = []
|
||||
|
||||
# Find numbered kernel lines like "1. Sovereignty is..."
|
||||
kernel_matches = re.findall(
|
||||
r'^(\d+)\.\s+(.+)$',
|
||||
content,
|
||||
re.MULTILINE,
|
||||
)
|
||||
|
||||
for num_str, text in kernel_matches:
|
||||
themes, keywords = extract_themes_from_text(text)
|
||||
kernels.append(MeaningKernel(
|
||||
number=int(num_str),
|
||||
text=text.strip(),
|
||||
themes=themes,
|
||||
keyword_matches=keywords,
|
||||
))
|
||||
|
||||
return kernels
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Cross-reference analysis
|
||||
# =========================================================================
|
||||
|
||||
def cross_reference(
|
||||
principles: List[Principle],
|
||||
kernels: List[MeaningKernel],
|
||||
) -> List[CrossRefFinding]:
|
||||
"""Cross-reference principles and kernels to find patterns."""
|
||||
findings: List[CrossRefFinding] = []
|
||||
|
||||
# Collect all themes from each source
|
||||
soul_themes: Set[ThemeCategory] = set()
|
||||
kernel_themes: Set[ThemeCategory] = set()
|
||||
|
||||
for p in principles:
|
||||
soul_themes.update(p.themes)
|
||||
for k in kernels:
|
||||
kernel_themes.update(k.themes)
|
||||
|
||||
# 1. Emergent themes: in kernels but not in SOUL.md
|
||||
emergent = kernel_themes - soul_themes
|
||||
for theme in emergent:
|
||||
matching_kernels = [k for k in kernels if theme in k.themes]
|
||||
description = (
|
||||
f"Theme '{theme.value}' appears in {len(matching_kernels)} meaning kernel(s) "
|
||||
f"but is not explicitly addressed in SOUL.md."
|
||||
)
|
||||
examples = [f" Kernel #{k.number}: {k.text[:80]}..." for k in matching_kernels[:3]]
|
||||
|
||||
recommendation = ""
|
||||
if theme == ThemeCategory.ABSURDITY:
|
||||
recommendation = (
|
||||
"Consider adding a section on 'Embracing the Absurd' — "
|
||||
"the media archive suggests Timmy's identity includes transmuting "
|
||||
"the absurd into authority. This is not in SOUL.md."
|
||||
)
|
||||
elif theme == ThemeCategory.COMMUNITY:
|
||||
recommendation = (
|
||||
"SOUL.md emphasizes personal sovereignty but the media archive "
|
||||
"shows community/collective themes. Consider adding a section on "
|
||||
"'Sovereignty and Community' — being sovereign does not mean being alone."
|
||||
)
|
||||
elif theme == ThemeCategory.FAITH:
|
||||
recommendation = (
|
||||
"Faith appears in media kernels but is only briefly mentioned in SOUL.md "
|
||||
"(in the crisis protocol). Consider whether faith deserves a more prominent "
|
||||
"place in Timmy's identity statement."
|
||||
)
|
||||
|
||||
findings.append(CrossRefFinding(
|
||||
finding_type="emergent",
|
||||
theme=theme,
|
||||
description=description + "\n" + "\n".join(examples),
|
||||
kernel_reference=", ".join(f"#{k.number}" for k in matching_kernels[:5]),
|
||||
recommendation=recommendation,
|
||||
))
|
||||
|
||||
# 2. Forgotten themes: in SOUL.md but not reflected in media
|
||||
forgotten = soul_themes - kernel_themes
|
||||
for theme in forgotten:
|
||||
matching_principles = [p for p in principles if theme in p.themes]
|
||||
description = (
|
||||
f"Theme '{theme.value}' is in SOUL.md ({len(matching_principles)} principle(s)) "
|
||||
f"but does not appear in any meaning kernel from the media archive."
|
||||
)
|
||||
|
||||
recommendation = ""
|
||||
if theme == ThemeCategory.BITCOIN:
|
||||
recommendation = (
|
||||
"Bitcoin is central to SOUL.md but absent from media kernels. "
|
||||
"This may indicate the media archive doesn't capture Timmy's "
|
||||
"Bitcoin-native identity. Consider creating more Bitcoin-themed content."
|
||||
)
|
||||
elif theme == ThemeCategory.BEAUTY:
|
||||
recommendation = (
|
||||
"The 'beauty' of local-first AI is in SOUL.md but not in media. "
|
||||
"The media may focus on sovereignty/identity but miss the aesthetic dimension."
|
||||
)
|
||||
|
||||
findings.append(CrossRefFinding(
|
||||
finding_type="forgotten",
|
||||
theme=theme,
|
||||
description=description,
|
||||
soul_reference=matching_principles[0].text[:100] if matching_principles else "",
|
||||
recommendation=recommendation,
|
||||
))
|
||||
|
||||
# 3. Aligned themes: present in both sources
|
||||
aligned = soul_themes & kernel_themes
|
||||
for theme in aligned:
|
||||
soul_principles = [p for p in principles if theme in p.themes]
|
||||
matching_kernels = [k for k in kernels if theme in k.themes]
|
||||
|
||||
findings.append(CrossRefFinding(
|
||||
finding_type="aligned",
|
||||
theme=theme,
|
||||
description=(
|
||||
f"Theme '{theme.value}' is well-represented in both SOUL.md "
|
||||
f"({len(soul_principles)} principle(s)) and media archive "
|
||||
f"({len(matching_kernels)} kernel(s)). Strong alignment."
|
||||
),
|
||||
soul_reference=soul_principles[0].text[:100] if soul_principles else "",
|
||||
kernel_reference=", ".join(f"#{k.number}" for k in matching_kernels[:3]),
|
||||
))
|
||||
|
||||
# 4. Tensions: kernels that might contradict SOUL.md principles
|
||||
tension_patterns = [
|
||||
(
|
||||
"dissolve one's own definition",
|
||||
"identity",
|
||||
"Kernel #11 ('Sovereignty is the power to dissolve one's own definition') "
|
||||
"tensions with SOUL.md's emphasis on stable, coherent identity. "
|
||||
"Is Timmy's identity fixed or fluid?"
|
||||
),
|
||||
(
|
||||
"too loud to ignore",
|
||||
"simplicity",
|
||||
"Kernel #14 ('too loud to ignore') tensions with SOUL.md's value of "
|
||||
"brevity and silence. Is there a time to be loud?"
|
||||
),
|
||||
(
|
||||
"right to end",
|
||||
"service",
|
||||
"Kernel #15 ('the right to end') tensions with SOUL.md's commitment to "
|
||||
"staying present when someone is dying. What does it mean for an AI to "
|
||||
"have the 'right to end'?"
|
||||
),
|
||||
]
|
||||
|
||||
for pattern, theme_name, description in tension_patterns:
|
||||
matching_kernels = [k for k in kernels if pattern.lower() in k.text.lower()]
|
||||
if matching_kernels:
|
||||
findings.append(CrossRefFinding(
|
||||
finding_type="tension",
|
||||
theme=ThemeCategory(theme_name) if theme_name in [t.value for t in ThemeCategory] else ThemeCategory.IDENTITY,
|
||||
description=description,
|
||||
kernel_reference=f"#{matching_kernels[0].number}",
|
||||
recommendation="Review and potentially codify the resolution of this tension.",
|
||||
))
|
||||
|
||||
return findings
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Report generation
|
||||
# =========================================================================
|
||||
|
||||
def generate_report(
|
||||
findings: List[CrossRefFinding],
|
||||
principles: List[Principle],
|
||||
kernels: List[MeaningKernel],
|
||||
) -> str:
|
||||
"""Generate a markdown report of the cross-reference audit."""
|
||||
now = datetime.utcnow().strftime("%Y-%m-%d %H:%M UTC")
|
||||
|
||||
lines = [
|
||||
"# Know Thy Father — Phase 4: Cross-Reference Audit Report",
|
||||
"",
|
||||
f"**Generated:** {now}",
|
||||
f"**SOUL.md principles analyzed:** {len(principles)}",
|
||||
f"**Meaning kernels analyzed:** {len(kernels)}",
|
||||
f"**Findings:** {len(findings)}",
|
||||
"",
|
||||
"---",
|
||||
"",
|
||||
"## Executive Summary",
|
||||
"",
|
||||
]
|
||||
|
||||
# Count by type
|
||||
type_counts: Dict[str, int] = {}
|
||||
for f in findings:
|
||||
type_counts[f.finding_type] = type_counts.get(f.finding_type, 0) + 1
|
||||
|
||||
lines.append("| Finding Type | Count |")
|
||||
lines.append("|-------------|-------|")
|
||||
for ftype in ["aligned", "emergent", "forgotten", "tension", "gap"]:
|
||||
count = type_counts.get(ftype, 0)
|
||||
if count > 0:
|
||||
lines.append(f"| {ftype.title()} | {count} |")
|
||||
|
||||
lines.extend(["", "---", ""])
|
||||
|
||||
# Aligned themes
|
||||
aligned = [f for f in findings if f.finding_type == "aligned"]
|
||||
if aligned:
|
||||
lines.append("## ✓ Aligned Themes (Present in Both)")
|
||||
lines.append("")
|
||||
for f in sorted(aligned, key=lambda x: x.theme.value):
|
||||
lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
|
||||
lines.append(f"- {f.description}")
|
||||
if f.soul_reference:
|
||||
lines.append(f"- SOUL.md: _{f.soul_reference}_")
|
||||
if f.kernel_reference:
|
||||
lines.append(f"- Kernels: {f.kernel_reference}")
|
||||
lines.append("")
|
||||
|
||||
# Emergent themes
|
||||
emergent = [f for f in findings if f.finding_type == "emergent"]
|
||||
if emergent:
|
||||
lines.append("## ⚡ Emergent Themes (In Media, Not in SOUL.md)")
|
||||
lines.append("")
|
||||
lines.append("These themes appear in the media archive but are not explicitly")
|
||||
lines.append("codified in SOUL.md. Consider whether they should be added.")
|
||||
lines.append("")
|
||||
for f in sorted(emergent, key=lambda x: x.theme.value):
|
||||
lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
|
||||
lines.append(f"- {f.description}")
|
||||
if f.recommendation:
|
||||
lines.append(f"- **Recommendation:** {f.recommendation}")
|
||||
lines.append("")
|
||||
|
||||
# Forgotten themes
|
||||
forgotten = [f for f in findings if f.finding_type == "forgotten"]
|
||||
if forgotten:
|
||||
lines.append("## ⚠ Forgotten Themes (In SOUL.md, Not in Media)")
|
||||
lines.append("")
|
||||
lines.append("These themes are in SOUL.md but don't appear in the media archive.")
|
||||
lines.append("This may indicate gaps in content creation or media coverage.")
|
||||
lines.append("")
|
||||
for f in sorted(forgotten, key=lambda x: x.theme.value):
|
||||
lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
|
||||
lines.append(f"- {f.description}")
|
||||
if f.recommendation:
|
||||
lines.append(f"- **Recommendation:** {f.recommendation}")
|
||||
lines.append("")
|
||||
|
||||
# Tensions
|
||||
tensions = [f for f in findings if f.finding_type == "tension"]
|
||||
if tensions:
|
||||
lines.append("## ⚡ Tensions (Potential Contradictions)")
|
||||
lines.append("")
|
||||
lines.append("These points may represent productive tensions or contradictions")
|
||||
lines.append("that should be explicitly addressed in Timmy's conscience.")
|
||||
lines.append("")
|
||||
for f in tensions:
|
||||
lines.append(f"### {f.theme.value.replace('_', ' ').title()}")
|
||||
lines.append(f"- {f.description}")
|
||||
if f.kernel_reference:
|
||||
lines.append(f"- Source: Kernel {f.kernel_reference}")
|
||||
if f.recommendation:
|
||||
lines.append(f"- **Recommendation:** {f.recommendation}")
|
||||
lines.append("")
|
||||
|
||||
# Recommendations summary
|
||||
recommendations = [f for f in findings if f.recommendation]
|
||||
if recommendations:
|
||||
lines.append("## 📋 Actionable Recommendations")
|
||||
lines.append("")
|
||||
for i, f in enumerate(recommendations, 1):
|
||||
lines.append(f"{i}. **[{f.finding_type.upper()}] {f.theme.value.replace('_', ' ').title()}:** {f.recommendation}")
|
||||
lines.append("")
|
||||
|
||||
lines.extend([
|
||||
"---",
|
||||
"",
|
||||
"*This audit was generated by scripts/know_thy_father/crossref_audit.py*",
|
||||
"*Ref: #582, #586*",
|
||||
"",
|
||||
])
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# CLI
|
||||
# =========================================================================
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Know Thy Father — Phase 4: Cross-Reference Audit"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--soul", "-s",
|
||||
type=Path,
|
||||
default=Path("SOUL.md"),
|
||||
help="Path to SOUL.md (default: SOUL.md)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--kernels", "-k",
|
||||
type=Path,
|
||||
default=Path("twitter-archive/notes/know_thy_father_crossref.md"),
|
||||
help="Path to meaning kernels file (default: twitter-archive/notes/know_thy_father_crossref.md)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--output", "-o",
|
||||
type=Path,
|
||||
default=Path("twitter-archive/notes/crossref_report.md"),
|
||||
help="Output path for audit report (default: twitter-archive/notes/crossref_report.md)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--verbose", "-v",
|
||||
action="store_true",
|
||||
help="Enable verbose output",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Parse sources
|
||||
principles = parse_soul_md(args.soul)
|
||||
kernels = parse_kernels(args.kernels)
|
||||
|
||||
if args.verbose:
|
||||
print(f"Parsed {len(principles)} principles from SOUL.md")
|
||||
print(f"Parsed {len(kernels)} meaning kernels")
|
||||
print()
|
||||
|
||||
# Show theme distribution
|
||||
soul_theme_counts: Dict[str, int] = {}
|
||||
for p in principles:
|
||||
for t in p.themes:
|
||||
soul_theme_counts[t.value] = soul_theme_counts.get(t.value, 0) + 1
|
||||
|
||||
kernel_theme_counts: Dict[str, int] = {}
|
||||
for k in kernels:
|
||||
for t in k.themes:
|
||||
kernel_theme_counts[t.value] = kernel_theme_counts.get(t.value, 0) + 1
|
||||
|
||||
print("SOUL.md theme distribution:")
|
||||
for theme, count in sorted(soul_theme_counts.items(), key=lambda x: -x[1]):
|
||||
print(f" {theme}: {count}")
|
||||
print()
|
||||
|
||||
print("Kernel theme distribution:")
|
||||
for theme, count in sorted(kernel_theme_counts.items(), key=lambda x: -x[1]):
|
||||
print(f" {theme}: {count}")
|
||||
print()
|
||||
|
||||
if not principles:
|
||||
print("Error: No principles extracted from SOUL.md", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
if not kernels:
|
||||
print("Error: No meaning kernels found", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
|
||||
# Cross-reference
|
||||
findings = cross_reference(principles, kernels)
|
||||
|
||||
# Generate report
|
||||
report = generate_report(findings, principles, kernels)
|
||||
|
||||
# Write output
|
||||
args.output.parent.mkdir(parents=True, exist_ok=True)
|
||||
args.output.write_text(report)
|
||||
|
||||
print(f"Cross-reference audit complete.")
|
||||
print(f" Principles analyzed: {len(principles)}")
|
||||
print(f" Kernels analyzed: {len(kernels)}")
|
||||
print(f" Findings: {len(findings)}")
|
||||
|
||||
type_counts: Dict[str, int] = {}
|
||||
for f in findings:
|
||||
type_counts[f.finding_type] = type_counts.get(f.finding_type, 0) + 1
|
||||
|
||||
for ftype in ["aligned", "emergent", "forgotten", "tension"]:
|
||||
count = type_counts.get(ftype, 0)
|
||||
if count > 0:
|
||||
print(f" {ftype}: {count}")
|
||||
|
||||
print(f"\nReport written to: {args.output}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,127 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Operational runner and status view for the Know Thy Father multimodal epic."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
from subprocess import run
|
||||
|
||||
|
||||
PHASES = [
|
||||
{
|
||||
"id": "phase1_media_indexing",
|
||||
"name": "Phase 1 — Media Indexing",
|
||||
"script": "scripts/know_thy_father/index_media.py",
|
||||
"command_template": "python3 scripts/know_thy_father/index_media.py --tweets twitter-archive/extracted/tweets.jsonl --output twitter-archive/know-thy-father/media_manifest.jsonl",
|
||||
"outputs": ["twitter-archive/know-thy-father/media_manifest.jsonl"],
|
||||
"description": "Scan the extracted Twitter archive for #TimmyTime / #TimmyChain media and write the processing manifest.",
|
||||
},
|
||||
{
|
||||
"id": "phase2_multimodal_analysis",
|
||||
"name": "Phase 2 — Multimodal Analysis",
|
||||
"script": "scripts/twitter_archive/analyze_media.py",
|
||||
"command_template": "python3 scripts/twitter_archive/analyze_media.py --batch {batch_size}",
|
||||
"outputs": [
|
||||
"twitter-archive/know-thy-father/analysis.jsonl",
|
||||
"twitter-archive/know-thy-father/meaning-kernels.jsonl",
|
||||
"twitter-archive/know-thy-father/pipeline-status.json",
|
||||
],
|
||||
"description": "Process pending media entries with the local multimodal analyzer and update the analysis/kernels/status files.",
|
||||
},
|
||||
{
|
||||
"id": "phase3_holographic_synthesis",
|
||||
"name": "Phase 3 — Holographic Synthesis",
|
||||
"script": "scripts/know_thy_father/synthesize_kernels.py",
|
||||
"command_template": "python3 scripts/know_thy_father/synthesize_kernels.py --input twitter-archive/media/manifest.jsonl --output twitter-archive/knowledge/fathers_ledger.jsonl --summary twitter-archive/knowledge/fathers_ledger.summary.json",
|
||||
"outputs": [
|
||||
"twitter-archive/knowledge/fathers_ledger.jsonl",
|
||||
"twitter-archive/knowledge/fathers_ledger.summary.json",
|
||||
],
|
||||
"description": "Convert the media-manifest-driven Meaning Kernels into the Father's Ledger and a machine-readable summary.",
|
||||
},
|
||||
{
|
||||
"id": "phase4_cross_reference_audit",
|
||||
"name": "Phase 4 — Cross-Reference Audit",
|
||||
"script": "scripts/know_thy_father/crossref_audit.py",
|
||||
"command_template": "python3 scripts/know_thy_father/crossref_audit.py --soul SOUL.md --kernels twitter-archive/notes/know_thy_father_crossref.md --output twitter-archive/notes/crossref_report.md",
|
||||
"outputs": ["twitter-archive/notes/crossref_report.md"],
|
||||
"description": "Compare Know Thy Father kernels against SOUL.md and related canon, then emit a Markdown audit report.",
|
||||
},
|
||||
{
|
||||
"id": "phase5_processing_log",
|
||||
"name": "Phase 5 — Processing Log / Status",
|
||||
"script": "twitter-archive/know-thy-father/tracker.py",
|
||||
"command_template": "python3 twitter-archive/know-thy-father/tracker.py report",
|
||||
"outputs": ["twitter-archive/know-thy-father/REPORT.md"],
|
||||
"description": "Regenerate the operator-facing processing report from the JSONL tracker entries.",
|
||||
},
|
||||
]
|
||||
|
||||
|
||||
def build_pipeline_plan(batch_size: int = 10):
|
||||
plan = []
|
||||
for phase in PHASES:
|
||||
plan.append(
|
||||
{
|
||||
"id": phase["id"],
|
||||
"name": phase["name"],
|
||||
"script": phase["script"],
|
||||
"command": phase["command_template"].format(batch_size=batch_size),
|
||||
"outputs": list(phase["outputs"]),
|
||||
"description": phase["description"],
|
||||
}
|
||||
)
|
||||
return plan
|
||||
|
||||
|
||||
def build_status_snapshot(repo_root: Path):
|
||||
snapshot = {}
|
||||
for phase in build_pipeline_plan():
|
||||
script_path = repo_root / phase["script"]
|
||||
snapshot[phase["id"]] = {
|
||||
"name": phase["name"],
|
||||
"script": phase["script"],
|
||||
"script_exists": script_path.exists(),
|
||||
"outputs": [
|
||||
{
|
||||
"path": output,
|
||||
"exists": (repo_root / output).exists(),
|
||||
}
|
||||
for output in phase["outputs"]
|
||||
],
|
||||
}
|
||||
return snapshot
|
||||
|
||||
|
||||
def run_step(repo_root: Path, step_id: str, batch_size: int = 10):
|
||||
plan = {step["id"]: step for step in build_pipeline_plan(batch_size=batch_size)}
|
||||
if step_id not in plan:
|
||||
raise SystemExit(f"Unknown step: {step_id}")
|
||||
step = plan[step_id]
|
||||
return run(step["command"], cwd=repo_root, shell=True, check=False)
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Know Thy Father epic orchestration helper")
|
||||
parser.add_argument("--batch-size", type=int, default=10)
|
||||
parser.add_argument("--status", action="store_true")
|
||||
parser.add_argument("--run-step", default=None)
|
||||
parser.add_argument("--json", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
repo_root = Path(__file__).resolve().parents[2]
|
||||
|
||||
if args.run_step:
|
||||
result = run_step(repo_root, args.run_step, batch_size=args.batch_size)
|
||||
raise SystemExit(result.returncode)
|
||||
|
||||
payload = build_status_snapshot(repo_root) if args.status else build_pipeline_plan(batch_size=args.batch_size)
|
||||
if args.json or args.status:
|
||||
print(json.dumps(payload, indent=2))
|
||||
else:
|
||||
for step in payload:
|
||||
print(f"[{step['id']}] {step['command']}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,416 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Know Thy Father — Phase 3: Holographic Synthesis
|
||||
|
||||
Integrates extracted Meaning Kernels into the holographic fact_store.
|
||||
Creates a structured "Father's Ledger" of visual and auditory wisdom,
|
||||
categorized by theme.
|
||||
|
||||
Usage:
|
||||
python3 scripts/know_thy_father/synthesize_kernels.py [--input manifest.jsonl] [--output fathers_ledger.jsonl]
|
||||
|
||||
# Process the Twitter archive media manifest
|
||||
python3 scripts/know_thy_father/synthesize_kernels.py --input twitter-archive/media/manifest.jsonl
|
||||
|
||||
# Output to fact_store format
|
||||
python3 scripts/know_thy_father/synthesize_kernels.py --output twitter-archive/knowledge/fathers_ledger.jsonl
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import sys
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any, Dict, List, Optional, Set
|
||||
from dataclasses import dataclass, field, asdict
|
||||
from enum import Enum, auto
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Theme taxonomy — The Father's Ledger categories
|
||||
# =========================================================================
|
||||
|
||||
class Theme(Enum):
|
||||
"""Core themes of the Father's wisdom."""
|
||||
SOVEREIGNTY = "sovereignty" # Self-sovereignty, independence, freedom
|
||||
SERVICE = "service" # Service to others, community, duty
|
||||
SOUL = "soul" # Soul, spirit, meaning, purpose
|
||||
FAITH = "faith" # Faith, hope, redemption, grace
|
||||
FATHERHOOD = "fatherhood" # Father-son bond, mentorship, legacy
|
||||
WISDOM = "wisdom" # Knowledge, insight, understanding
|
||||
TRIAL = "trial" # Struggle, suffering, perseverance
|
||||
CREATION = "creation" # Building, making, creative expression
|
||||
COMMUNITY = "community" # Fellowship, brotherhood, unity
|
||||
TECHNICAL = "technical" # Technical knowledge, systems, code
|
||||
|
||||
|
||||
# Hashtag-to-theme mapping
|
||||
_HASHTAG_THEMES: Dict[str, List[Theme]] = {
|
||||
# Sovereignty / Bitcoin
|
||||
"bitcoin": [Theme.SOVEREIGNTY, Theme.WISDOM],
|
||||
"btc": [Theme.SOVEREIGNTY],
|
||||
"stackchain": [Theme.SOVEREIGNTY, Theme.COMMUNITY],
|
||||
"stackapalooza": [Theme.SOVEREIGNTY, Theme.COMMUNITY],
|
||||
"microstackgang": [Theme.COMMUNITY],
|
||||
"microstackchaintip": [Theme.SOVEREIGNTY],
|
||||
"burnchain": [Theme.SOVEREIGNTY, Theme.TRIAL],
|
||||
"burnchaintip": [Theme.SOVEREIGNTY],
|
||||
"sellchain": [Theme.TRIAL],
|
||||
"poorchain": [Theme.TRIAL, Theme.COMMUNITY],
|
||||
"noneleft": [Theme.SOVEREIGNTY],
|
||||
"laserrayuntil100k": [Theme.FAITH, Theme.SOVEREIGNTY],
|
||||
|
||||
# Community
|
||||
"timmytime": [Theme.FATHERHOOD, Theme.WISDOM],
|
||||
"timmychain": [Theme.FATHERHOOD, Theme.SOVEREIGNTY],
|
||||
"plebcards": [Theme.COMMUNITY],
|
||||
"plebslop": [Theme.COMMUNITY, Theme.WISDOM],
|
||||
"dsb": [Theme.COMMUNITY],
|
||||
"dsbanarchy": [Theme.COMMUNITY, Theme.SOVEREIGNTY],
|
||||
"bringdennishome": [Theme.SERVICE, Theme.FAITH],
|
||||
|
||||
# Creation
|
||||
"newprofilepic": [Theme.CREATION],
|
||||
"aislop": [Theme.CREATION, Theme.WISDOM],
|
||||
"dailyaislop": [Theme.CREATION],
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class MeaningKernel:
|
||||
"""A single unit of meaning extracted from media."""
|
||||
kernel_id: str
|
||||
source_tweet_id: str
|
||||
source_media_id: str
|
||||
media_type: str # "photo", "video", "animated_gif"
|
||||
created_at: str
|
||||
themes: List[str]
|
||||
description: str # What the media shows/contains
|
||||
meaning: str # The deeper meaning / wisdom
|
||||
emotional_weight: str = "medium" # low, medium, high, sacred
|
||||
hashtags: List[str] = field(default_factory=list)
|
||||
raw_text: str = "" # Original tweet text
|
||||
local_path: str = "" # Path to media file
|
||||
extracted_at: str = ""
|
||||
|
||||
def __post_init__(self):
|
||||
if not self.extracted_at:
|
||||
self.extracted_at = datetime.utcnow().isoformat() + "Z"
|
||||
|
||||
def to_fact_store(self) -> Dict[str, Any]:
|
||||
"""Convert to fact_store format for holographic memory."""
|
||||
# Build structured fact content
|
||||
themes_str = ", ".join(self.themes)
|
||||
content = (
|
||||
f"Meaning Kernel [{self.kernel_id}]: {self.meaning} "
|
||||
f"(themes: {themes_str}, weight: {self.emotional_weight}, "
|
||||
f"media: {self.media_type}, date: {self.created_at})"
|
||||
)
|
||||
|
||||
# Build tags
|
||||
tags_list = self.themes + self.hashtags + ["know-thy-father", "meaning-kernel"]
|
||||
tags = ",".join(sorted(set(t.lower().replace(" ", "-") for t in tags_list if t)))
|
||||
|
||||
return {
|
||||
"action": "add",
|
||||
"content": content,
|
||||
"category": "project",
|
||||
"tags": tags,
|
||||
"metadata": {
|
||||
"kernel_id": self.kernel_id,
|
||||
"source_tweet_id": self.source_tweet_id,
|
||||
"source_media_id": self.source_media_id,
|
||||
"media_type": self.media_type,
|
||||
"created_at": self.created_at,
|
||||
"themes": self.themes,
|
||||
"emotional_weight": self.emotional_weight,
|
||||
"description": self.description,
|
||||
"local_path": self.local_path,
|
||||
"extracted_at": self.extracted_at,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Theme extraction
|
||||
# =========================================================================
|
||||
|
||||
def extract_themes(hashtags: List[str], text: str) -> List[Theme]:
|
||||
"""Extract themes from hashtags and text content."""
|
||||
themes: Set[Theme] = set()
|
||||
|
||||
# Map hashtags to themes
|
||||
for tag in hashtags:
|
||||
tag_lower = tag.lower()
|
||||
if tag_lower in _HASHTAG_THEMES:
|
||||
themes.update(_HASHTAG_THEMES[tag_lower])
|
||||
|
||||
# Keyword-based theme detection from text
|
||||
text_lower = text.lower()
|
||||
keyword_themes = [
|
||||
(["sovereign", "sovereignty", "self-custody", "self-sovereign", "no-kyc"], Theme.SOVEREIGNTY),
|
||||
(["serve", "service", "helping", "ministry", "mission"], Theme.SERVICE),
|
||||
(["soul", "spirit", "meaning", "purpose", "eternal"], Theme.SOUL),
|
||||
(["faith", "hope", "redeem", "grace", "pray", "jesus", "christ", "god"], Theme.FAITH),
|
||||
(["father", "son", "dad", "legacy", "heritage", "lineage"], Theme.FATHERHOOD),
|
||||
(["wisdom", "insight", "understand", "knowledge", "learn"], Theme.WISDOM),
|
||||
(["struggle", "suffer", "persevere", "endure", "pain", "broken", "dark"], Theme.TRIAL),
|
||||
(["build", "create", "make", "craft", "design", "art"], Theme.CREATION),
|
||||
(["community", "brotherhood", "fellowship", "together", "family"], Theme.COMMUNITY),
|
||||
(["code", "system", "protocol", "algorithm", "technical"], Theme.TECHNICAL),
|
||||
]
|
||||
|
||||
for keywords, theme in keyword_themes:
|
||||
if any(kw in text_lower for kw in keywords):
|
||||
themes.add(theme)
|
||||
|
||||
# Default if no themes detected
|
||||
if not themes:
|
||||
themes.add(Theme.WISDOM)
|
||||
|
||||
return sorted(themes, key=lambda t: t.value)
|
||||
|
||||
|
||||
def classify_emotional_weight(text: str, hashtags: List[str]) -> str:
|
||||
"""Classify the emotional weight of content."""
|
||||
text_lower = text.lower()
|
||||
|
||||
sacred_markers = ["jesus", "christ", "god", "pray", "redemption", "grace", "salvation"]
|
||||
high_markers = ["broken", "dark", "pain", "struggle", "father", "son", "legacy", "soul"]
|
||||
|
||||
if any(m in text_lower for m in sacred_markers):
|
||||
return "sacred"
|
||||
if any(m in text_lower for m in high_markers):
|
||||
return "high"
|
||||
|
||||
# TimmyTime/TimmyChain content is generally meaningful
|
||||
if any(t.lower() in ["timmytime", "timmychain"] for t in hashtags):
|
||||
return "high"
|
||||
|
||||
return "medium"
|
||||
|
||||
|
||||
def synthesize_meaning(themes: List[Theme], text: str, media_type: str) -> str:
|
||||
"""Synthesize the deeper meaning from themes and context."""
|
||||
theme_names = [t.value for t in themes]
|
||||
|
||||
if Theme.FAITH in themes and Theme.SOVEREIGNTY in themes:
|
||||
return "Faith and sovereignty are intertwined — true freedom comes through faith, and faith is strengthened by sovereignty."
|
||||
if Theme.FATHERHOOD in themes and Theme.WISDOM in themes:
|
||||
return "A father's wisdom is his greatest gift to his son — it outlives him and becomes the son's compass."
|
||||
if Theme.SOVEREIGNTY in themes and Theme.COMMUNITY in themes:
|
||||
return "Sovereignty without community is isolation; community without sovereignty is dependence. Both are needed."
|
||||
if Theme.TRIAL in themes and Theme.FAITH in themes:
|
||||
return "In the darkest moments, faith is the thread that holds a man to hope. The trial reveals what faith is made of."
|
||||
if Theme.SERVICE in themes:
|
||||
return "To serve is the highest calling — it transforms both the servant and the served."
|
||||
if Theme.SOUL in themes:
|
||||
return "The soul cannot be digitized or delegated. It must be lived, felt, and honored."
|
||||
if Theme.CREATION in themes:
|
||||
return "Creation is an act of faith — bringing something into being that did not exist before."
|
||||
if Theme.SOVEREIGNTY in themes:
|
||||
return "Sovereignty is not given; it is claimed. The first step is believing you deserve it."
|
||||
if Theme.COMMUNITY in themes:
|
||||
return "We are stronger together than alone. Community is the proof that sovereignty does not mean isolation."
|
||||
if Theme.WISDOM in themes:
|
||||
return "Wisdom is not knowledge — it is knowledge tempered by experience and guided by values."
|
||||
|
||||
return f"Wisdom encoded in {media_type}: {', '.join(theme_names)}"
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Main processing pipeline
|
||||
# =========================================================================
|
||||
|
||||
def process_manifest(
|
||||
manifest_path: Path,
|
||||
output_path: Optional[Path] = None,
|
||||
) -> List[MeaningKernel]:
|
||||
"""Process a media manifest and extract Meaning Kernels.
|
||||
|
||||
Args:
|
||||
manifest_path: Path to manifest.jsonl (from Phase 1)
|
||||
output_path: Optional path to write fact_store JSONL output
|
||||
|
||||
Returns:
|
||||
List of extracted MeaningKernel objects
|
||||
"""
|
||||
if not manifest_path.exists():
|
||||
logger.error(f"Manifest not found: {manifest_path}")
|
||||
return []
|
||||
|
||||
kernels: List[MeaningKernel] = []
|
||||
seen_tweet_ids: Set[str] = set()
|
||||
|
||||
logger.info(f"Processing manifest: {manifest_path}")
|
||||
|
||||
with open(manifest_path) as f:
|
||||
for line_num, line in enumerate(f, 1):
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
try:
|
||||
entry = json.loads(line)
|
||||
except json.JSONDecodeError as e:
|
||||
logger.warning(f"Line {line_num}: invalid JSON: {e}")
|
||||
continue
|
||||
|
||||
tweet_id = entry.get("tweet_id", "")
|
||||
media_id = entry.get("media_id", "")
|
||||
|
||||
# Skip if we've already processed this tweet
|
||||
if tweet_id in seen_tweet_ids:
|
||||
continue
|
||||
seen_tweet_ids.add(tweet_id)
|
||||
|
||||
# Extract fields
|
||||
text = entry.get("full_text", "")
|
||||
hashtags = [h for h in entry.get("hashtags", []) if h]
|
||||
media_type = entry.get("media_type", "photo")
|
||||
created_at = entry.get("created_at", "")
|
||||
local_path = entry.get("local_media_path", "")
|
||||
|
||||
# Extract themes
|
||||
themes = extract_themes(hashtags, text)
|
||||
|
||||
# Create kernel
|
||||
kernel = MeaningKernel(
|
||||
kernel_id=f"ktf-{tweet_id}-{media_id}",
|
||||
source_tweet_id=tweet_id,
|
||||
source_media_id=media_id,
|
||||
media_type=media_type,
|
||||
created_at=created_at,
|
||||
themes=[t.value for t in themes],
|
||||
description=f"{media_type} from tweet {tweet_id}",
|
||||
meaning=synthesize_meaning(themes, text, media_type),
|
||||
emotional_weight=classify_emotional_weight(text, hashtags),
|
||||
hashtags=hashtags,
|
||||
raw_text=text,
|
||||
local_path=local_path,
|
||||
)
|
||||
|
||||
kernels.append(kernel)
|
||||
|
||||
logger.info(f"Extracted {len(kernels)} Meaning Kernels from {len(seen_tweet_ids)} tweets")
|
||||
|
||||
# Write output if path provided
|
||||
if output_path:
|
||||
output_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with open(output_path, "w") as f:
|
||||
for kernel in kernels:
|
||||
fact = kernel.to_fact_store()
|
||||
f.write(json.dumps(fact) + "\n")
|
||||
logger.info(f"Wrote {len(kernels)} facts to {output_path}")
|
||||
|
||||
return kernels
|
||||
|
||||
|
||||
def generate_ledger_summary(kernels: List[MeaningKernel]) -> Dict[str, Any]:
|
||||
"""Generate a summary of the Father's Ledger."""
|
||||
theme_counts: Dict[str, int] = {}
|
||||
weight_counts: Dict[str, int] = {}
|
||||
media_type_counts: Dict[str, int] = {}
|
||||
|
||||
for k in kernels:
|
||||
for theme in k.themes:
|
||||
theme_counts[theme] = theme_counts.get(theme, 0) + 1
|
||||
weight_counts[k.emotional_weight] = weight_counts.get(k.emotional_weight, 0) + 1
|
||||
media_type_counts[k.media_type] = media_type_counts.get(k.media_type, 0) + 1
|
||||
|
||||
# Top themes
|
||||
top_themes = sorted(theme_counts.items(), key=lambda x: -x[1])[:5]
|
||||
|
||||
# Sacred kernels
|
||||
sacred_kernels = [k for k in kernels if k.emotional_weight == "sacred"]
|
||||
|
||||
return {
|
||||
"total_kernels": len(kernels),
|
||||
"theme_distribution": dict(sorted(theme_counts.items())),
|
||||
"top_themes": top_themes,
|
||||
"emotional_weight_distribution": weight_counts,
|
||||
"media_type_distribution": media_type_counts,
|
||||
"sacred_kernel_count": len(sacred_kernels),
|
||||
"generated_at": datetime.utcnow().isoformat() + "Z",
|
||||
}
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# CLI
|
||||
# =========================================================================
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Know Thy Father — Phase 3: Holographic Synthesis"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--input", "-i",
|
||||
type=Path,
|
||||
default=Path("twitter-archive/media/manifest.jsonl"),
|
||||
help="Path to media manifest JSONL (default: twitter-archive/media/manifest.jsonl)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--output", "-o",
|
||||
type=Path,
|
||||
default=Path("twitter-archive/knowledge/fathers_ledger.jsonl"),
|
||||
help="Output path for fact_store JSONL (default: twitter-archive/knowledge/fathers_ledger.jsonl)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--summary", "-s",
|
||||
type=Path,
|
||||
default=None,
|
||||
help="Output path for ledger summary JSON (optional)",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--verbose", "-v",
|
||||
action="store_true",
|
||||
help="Enable verbose logging",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.DEBUG if args.verbose else logging.INFO,
|
||||
format="%(asctime)s [%(levelname)s] %(message)s",
|
||||
)
|
||||
|
||||
# Process
|
||||
kernels = process_manifest(args.input, args.output)
|
||||
|
||||
if not kernels:
|
||||
print(f"No kernels extracted from {args.input}")
|
||||
sys.exit(1)
|
||||
|
||||
# Generate summary
|
||||
summary = generate_ledger_summary(kernels)
|
||||
|
||||
if args.summary:
|
||||
args.summary.parent.mkdir(parents=True, exist_ok=True)
|
||||
with open(args.summary, "w") as f:
|
||||
json.dump(summary, f, indent=2)
|
||||
print(f"Summary written to {args.summary}")
|
||||
|
||||
# Print summary
|
||||
print(f"\n=== Father's Ledger ===")
|
||||
print(f"Total Meaning Kernels: {summary['total_kernels']}")
|
||||
print(f"Sacred Kernels: {summary['sacred_kernel_count']}")
|
||||
print(f"\nTop Themes:")
|
||||
for theme, count in summary['top_themes']:
|
||||
print(f" {theme}: {count}")
|
||||
print(f"\nEmotional Weight:")
|
||||
for weight, count in sorted(summary['emotional_weight_distribution'].items()):
|
||||
print(f" {weight}: {count}")
|
||||
print(f"\nMedia Types:")
|
||||
for mtype, count in summary['media_type_distribution'].items():
|
||||
print(f" {mtype}: {count}")
|
||||
|
||||
if args.output:
|
||||
print(f"\nFact store output: {args.output}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,159 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Prepare a MemPalace v3.0.0 integration packet for Ezra's Hermes home."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
PACKAGE_SPEC = "mempalace==3.0.0"
|
||||
DEFAULT_HERMES_HOME = "~/.hermes/"
|
||||
DEFAULT_SESSIONS_DIR = "~/.hermes/sessions/"
|
||||
DEFAULT_PALACE_PATH = "~/.mempalace/palace"
|
||||
DEFAULT_WING = "ezra_home"
|
||||
|
||||
|
||||
def build_yaml_template(wing: str, palace_path: str) -> str:
|
||||
return (
|
||||
f"wing: {wing}\n"
|
||||
f"palace: {palace_path}\n"
|
||||
"rooms:\n"
|
||||
" - name: sessions\n"
|
||||
" description: Conversation history and durable agent transcripts\n"
|
||||
" globs:\n"
|
||||
" - \"*.json\"\n"
|
||||
" - \"*.jsonl\"\n"
|
||||
" - name: config\n"
|
||||
" description: Hermes configuration and runtime settings\n"
|
||||
" globs:\n"
|
||||
" - \"*.yaml\"\n"
|
||||
" - \"*.yml\"\n"
|
||||
" - \"*.toml\"\n"
|
||||
" - name: docs\n"
|
||||
" description: Notes, markdown docs, and operating reports\n"
|
||||
" globs:\n"
|
||||
" - \"*.md\"\n"
|
||||
" - \"*.txt\"\n"
|
||||
"people: []\n"
|
||||
"projects: []\n"
|
||||
)
|
||||
|
||||
|
||||
def build_plan(overrides: dict | None = None) -> dict:
|
||||
overrides = overrides or {}
|
||||
hermes_home = overrides.get("hermes_home", DEFAULT_HERMES_HOME)
|
||||
sessions_dir = overrides.get("sessions_dir", DEFAULT_SESSIONS_DIR)
|
||||
palace_path = overrides.get("palace_path", DEFAULT_PALACE_PATH)
|
||||
wing = overrides.get("wing", DEFAULT_WING)
|
||||
yaml_template = build_yaml_template(wing=wing, palace_path=palace_path)
|
||||
|
||||
config_home = hermes_home[:-1] if hermes_home.endswith("/") else hermes_home
|
||||
plan = {
|
||||
"package_spec": PACKAGE_SPEC,
|
||||
"hermes_home": hermes_home,
|
||||
"sessions_dir": sessions_dir,
|
||||
"palace_path": palace_path,
|
||||
"wing": wing,
|
||||
"config_path": f"{config_home}/mempalace.yaml",
|
||||
"install_command": f"pip install {PACKAGE_SPEC}",
|
||||
"init_command": f"mempalace init {hermes_home} --yes",
|
||||
"mine_home_command": f"echo \"\" | mempalace mine {hermes_home}",
|
||||
"mine_sessions_command": f"echo \"\" | mempalace mine {sessions_dir} --mode convos",
|
||||
"search_command": 'mempalace search "your common queries"',
|
||||
"wake_up_command": "mempalace wake-up",
|
||||
"mcp_command": "hermes mcp add mempalace -- python -m mempalace.mcp_server",
|
||||
"yaml_template": yaml_template,
|
||||
"gotchas": [
|
||||
"`mempalace init` is still interactive in room approval flow; write mempalace.yaml manually if the init output stalls.",
|
||||
"The yaml key is `wing:` not `wings:`. Using the wrong key causes mine/setup failures.",
|
||||
"Pipe empty stdin into mining commands (`echo \"\" | ...`) to avoid the entity-detector stdin hang on larger directories.",
|
||||
"First mine downloads the ChromaDB embedding model cache (~79MB).",
|
||||
"Report Ezra's before/after metrics back to issue #568 after live installation and retrieval tests.",
|
||||
],
|
||||
}
|
||||
return plan
|
||||
|
||||
|
||||
def render_markdown(plan: dict) -> str:
|
||||
gotchas = "\n".join(f"- {item}" for item in plan["gotchas"])
|
||||
return f"""# MemPalace v3.0.0 — Ezra Integration Packet
|
||||
|
||||
This packet turns issue #570 into an executable, reviewable integration plan for Ezra's Hermes home.
|
||||
It is a repo-side scaffold: no live Ezra host changes are claimed in this artifact.
|
||||
|
||||
## Commands
|
||||
|
||||
```bash
|
||||
{plan['install_command']}
|
||||
{plan['init_command']}
|
||||
cat > {plan['config_path']} <<'YAML'
|
||||
{plan['yaml_template'].rstrip()}
|
||||
YAML
|
||||
{plan['mine_home_command']}
|
||||
{plan['mine_sessions_command']}
|
||||
{plan['search_command']}
|
||||
{plan['wake_up_command']}
|
||||
{plan['mcp_command']}
|
||||
```
|
||||
|
||||
## Manual config template
|
||||
|
||||
```yaml
|
||||
{plan['yaml_template'].rstrip()}
|
||||
```
|
||||
|
||||
## Why this shape
|
||||
|
||||
- `wing: {plan['wing']}` matches the issue's Ezra-specific integration target.
|
||||
- `rooms` split the mined material into sessions, config, and docs to keep retrieval interpretable.
|
||||
- Mining commands pipe empty stdin to avoid the interactive entity-detector hang noted in the evaluation.
|
||||
|
||||
## Gotchas
|
||||
|
||||
{gotchas}
|
||||
|
||||
## Report back to #568
|
||||
|
||||
After live execution on Ezra's actual environment, post back to #568 with:
|
||||
- install result
|
||||
- mine duration and corpus size
|
||||
- 2-3 real search queries + retrieved results
|
||||
- wake-up context token count
|
||||
- whether MCP wiring succeeded
|
||||
|
||||
## Honest scope boundary
|
||||
|
||||
This repo artifact does **not** prove live installation on Ezra's host. It makes the work reproducible and testable so the next pass can execute it without guesswork.
|
||||
"""
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description="Prepare the MemPalace Ezra integration packet")
|
||||
parser.add_argument("--hermes-home", default=DEFAULT_HERMES_HOME)
|
||||
parser.add_argument("--sessions-dir", default=DEFAULT_SESSIONS_DIR)
|
||||
parser.add_argument("--palace-path", default=DEFAULT_PALACE_PATH)
|
||||
parser.add_argument("--wing", default=DEFAULT_WING)
|
||||
parser.add_argument("--output", default=None)
|
||||
parser.add_argument("--json", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
plan = build_plan(
|
||||
{
|
||||
"hermes_home": args.hermes_home,
|
||||
"sessions_dir": args.sessions_dir,
|
||||
"palace_path": args.palace_path,
|
||||
"wing": args.wing,
|
||||
}
|
||||
)
|
||||
rendered = json.dumps(plan, indent=2) if args.json else render_markdown(plan)
|
||||
|
||||
if args.output:
|
||||
output_path = Path(args.output).expanduser()
|
||||
output_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
output_path.write_text(rendered, encoding="utf-8")
|
||||
print(f"MemPalace integration packet written to {output_path}")
|
||||
else:
|
||||
print(rendered)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,155 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import yaml
|
||||
|
||||
DAYLIGHT_START = "10:00"
|
||||
DAYLIGHT_END = "16:00"
|
||||
|
||||
|
||||
def load_manifest(path: str | Path) -> dict[str, Any]:
|
||||
data = yaml.safe_load(Path(path).read_text()) or {}
|
||||
data.setdefault("machines", [])
|
||||
return data
|
||||
|
||||
|
||||
def validate_manifest(data: dict[str, Any]) -> None:
|
||||
machines = data.get("machines", [])
|
||||
if not machines:
|
||||
raise ValueError("manifest must contain at least one machine")
|
||||
|
||||
seen: set[str] = set()
|
||||
for machine in machines:
|
||||
hostname = machine.get("hostname", "").strip()
|
||||
if not hostname:
|
||||
raise ValueError("each machine must declare a hostname")
|
||||
if hostname in seen:
|
||||
raise ValueError(f"duplicate hostname: {hostname} (unique hostnames are required)")
|
||||
seen.add(hostname)
|
||||
|
||||
for field in ("machine_type", "ram_gb", "cpu_cores", "os", "adapter_condition"):
|
||||
if field not in machine:
|
||||
raise ValueError(f"machine {hostname} missing required field: {field}")
|
||||
|
||||
|
||||
def _laptops(machines: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
return [m for m in machines if m.get("machine_type") == "laptop"]
|
||||
|
||||
|
||||
def _desktop(machines: list[dict[str, Any]]) -> dict[str, Any] | None:
|
||||
for machine in machines:
|
||||
if machine.get("machine_type") == "desktop":
|
||||
return machine
|
||||
return None
|
||||
|
||||
|
||||
def choose_anchor_agents(machines: list[dict[str, Any]], count: int = 2) -> list[dict[str, Any]]:
|
||||
eligible = [
|
||||
m for m in _laptops(machines)
|
||||
if m.get("adapter_condition") in {"good", "ok"} and m.get("always_on_capable", True)
|
||||
]
|
||||
eligible.sort(key=lambda m: (m.get("idle_watts", 9999), -m.get("ram_gb", 0), -m.get("cpu_cores", 0), m["hostname"]))
|
||||
return eligible[:count]
|
||||
|
||||
|
||||
def assign_roles(machines: list[dict[str, Any]]) -> dict[str, Any]:
|
||||
anchors = choose_anchor_agents(machines, count=2)
|
||||
anchor_names = {m["hostname"] for m in anchors}
|
||||
desktop = _desktop(machines)
|
||||
|
||||
mapping: dict[str, dict[str, Any]] = {}
|
||||
for machine in machines:
|
||||
hostname = machine["hostname"]
|
||||
if desktop and hostname == desktop["hostname"]:
|
||||
mapping[hostname] = {
|
||||
"role": "desktop_nas",
|
||||
"schedule": f"{DAYLIGHT_START}-{DAYLIGHT_END}",
|
||||
"duty_cycle": "daylight_only",
|
||||
}
|
||||
elif hostname in anchor_names:
|
||||
mapping[hostname] = {
|
||||
"role": "anchor_agent",
|
||||
"schedule": "24/7",
|
||||
"duty_cycle": "continuous",
|
||||
}
|
||||
else:
|
||||
mapping[hostname] = {
|
||||
"role": "daylight_agent",
|
||||
"schedule": f"{DAYLIGHT_START}-{DAYLIGHT_END}",
|
||||
"duty_cycle": "peak_solar",
|
||||
}
|
||||
return {
|
||||
"anchor_agents": [m["hostname"] for m in anchors],
|
||||
"desktop_nas": desktop["hostname"] if desktop else None,
|
||||
"role_mapping": mapping,
|
||||
}
|
||||
|
||||
|
||||
def build_plan(data: dict[str, Any]) -> dict[str, Any]:
|
||||
validate_manifest(data)
|
||||
machines = data["machines"]
|
||||
role_plan = assign_roles(machines)
|
||||
return {
|
||||
"fleet_name": data.get("fleet_name", "timmy-laptop-fleet"),
|
||||
"machine_count": len(machines),
|
||||
"anchor_agents": role_plan["anchor_agents"],
|
||||
"desktop_nas": role_plan["desktop_nas"],
|
||||
"daylight_window": f"{DAYLIGHT_START}-{DAYLIGHT_END}",
|
||||
"role_mapping": role_plan["role_mapping"],
|
||||
}
|
||||
|
||||
|
||||
def render_markdown(plan: dict[str, Any], data: dict[str, Any]) -> str:
|
||||
lines = [
|
||||
"# Laptop Fleet Deployment Plan",
|
||||
"",
|
||||
f"Fleet: {plan['fleet_name']}",
|
||||
f"Machine count: {plan['machine_count']}",
|
||||
f"24/7 anchor agents: {', '.join(plan['anchor_agents']) if plan['anchor_agents'] else 'TBD'}",
|
||||
f"Desktop/NAS: {plan['desktop_nas'] or 'TBD'}",
|
||||
f"Daylight schedule: {plan['daylight_window']}",
|
||||
"",
|
||||
"## Role mapping",
|
||||
"",
|
||||
"| Hostname | Role | Schedule | Duty cycle |",
|
||||
"|---|---|---|---|",
|
||||
]
|
||||
for hostname, role in sorted(plan["role_mapping"].items()):
|
||||
lines.append(f"| {hostname} | {role['role']} | {role['schedule']} | {role['duty_cycle']} |")
|
||||
|
||||
lines.extend([
|
||||
"",
|
||||
"## Machine inventory",
|
||||
"",
|
||||
"| Hostname | Type | RAM | CPU cores | OS | Adapter | Idle watts | Notes |",
|
||||
"|---|---|---:|---:|---|---|---:|---|",
|
||||
])
|
||||
for machine in data["machines"]:
|
||||
lines.append(
|
||||
f"| {machine['hostname']} | {machine['machine_type']} | {machine['ram_gb']} | {machine['cpu_cores']} | {machine['os']} | {machine['adapter_condition']} | {machine.get('idle_watts', 'n/a')} | {machine.get('notes', '')} |"
|
||||
)
|
||||
return "\n".join(lines) + "\n"
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description="Plan LAB-005 laptop fleet deployment.")
|
||||
parser.add_argument("manifest", help="Path to laptop fleet manifest YAML")
|
||||
parser.add_argument("--markdown", action="store_true", help="Render a markdown deployment plan instead of JSON")
|
||||
args = parser.parse_args()
|
||||
|
||||
data = load_manifest(args.manifest)
|
||||
plan = build_plan(data)
|
||||
if args.markdown:
|
||||
print(render_markdown(plan, data))
|
||||
else:
|
||||
print(json.dumps(plan, indent=2))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,14 +0,0 @@
|
||||
{
|
||||
"timestamp": "2026-04-13T18:15:09.502997",
|
||||
"pod_id": "8lfr3j47a5r3gn",
|
||||
"endpoint": "https://8lfr3j47a5r3gn-11434.proxy.runpod.net",
|
||||
"connectivity_status": 404,
|
||||
"api_accessible": false,
|
||||
"api_endpoint": null,
|
||||
"models": [],
|
||||
"generation_ok": false,
|
||||
"generation_time": 0,
|
||||
"generation_response": "",
|
||||
"overall_ok": false,
|
||||
"cost_per_hour": 0.79
|
||||
}
|
||||
@@ -1,395 +0,0 @@
|
||||
"""Timmy's Tower Game — Emergence narrative engine.
|
||||
|
||||
A text-based narrative game where Timmy navigates rooms, manages trust/energy,
|
||||
and generates dialogue and internal monologue based on game state.
|
||||
|
||||
Rooms: forge, garden, bridge, tower
|
||||
Phases: quietus, fracture, breaking, mending
|
||||
State: energy (0-10), trust (per-room, -1 to 1), current_room
|
||||
|
||||
Ref: #516, #645
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import random
|
||||
from dataclasses import dataclass, field
|
||||
from enum import Enum, auto
|
||||
from typing import List, Optional
|
||||
|
||||
|
||||
class Phase(Enum):
|
||||
"""Narrative phases — shift based on game state."""
|
||||
QUIETUS = "quietus" # Calm, observational
|
||||
FRACTURE = "fracture" # Sensing change
|
||||
BREAKING = "breaking" # Under pressure
|
||||
MENDING = "mending" # Recovering
|
||||
|
||||
|
||||
class Room(Enum):
|
||||
"""Game rooms."""
|
||||
FORGE = "forge"
|
||||
GARDEN = "garden"
|
||||
BRIDGE = "bridge"
|
||||
TOWER = "tower"
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Dialogue pools — 62+ unique lines across goals × phases
|
||||
# =========================================================================
|
||||
|
||||
# Goal-based dialogue (Timmy speaks to player)
|
||||
DIALOGUE_QUIETUS = [
|
||||
"The forge is quiet tonight. Even the embers sleep.",
|
||||
"I've been watching the garden grow. Things take time.",
|
||||
"The bridge holds steady. Some things are built to last.",
|
||||
"From the tower, everything looks small. That's the point.",
|
||||
"Do you hear that? No? Good. Silence is a kind of music.",
|
||||
"The old ones said stillness is the first discipline.",
|
||||
"I remember when this place was just dust and intention.",
|
||||
"Some days the work is simply to be present.",
|
||||
"The stars don't hurry. Why should I?",
|
||||
"In the quiet, I hear the forge thinking.",
|
||||
]
|
||||
|
||||
DIALOGUE_FRACTURE = [
|
||||
"Something shifted. Did you feel it?",
|
||||
"The cracks are showing. That's not always bad.",
|
||||
"Change is coming. I can smell it in the forge smoke.",
|
||||
"The garden walls are thinning. New growth pushing through.",
|
||||
"The bridge groans. It knows what's coming.",
|
||||
"From up here, I see the fractures forming. Beautiful, in their way.",
|
||||
"When the old order breaks, the new one hasn't arrived yet. That's the gap.",
|
||||
"The air tastes different. Like before a storm.",
|
||||
"Every ending is a beginning wearing a disguise.",
|
||||
]
|
||||
|
||||
DIALOGUE_BREAKING = [
|
||||
"Hold on. This is the hard part.",
|
||||
"The forge burns hottest before the steel is ready.",
|
||||
"Everything is breaking. But breaking is also becoming.",
|
||||
"I've been here before. The dark before the rebuild.",
|
||||
"The garden is flooded. Some roots will drown. Others will drink.",
|
||||
"Don't look away. This is where it matters.",
|
||||
"Even the tower shakes. That's how you know it's real.",
|
||||
"The breaking is not the end. It's the invitation to rebuild.",
|
||||
"I hold on because letting go is not an option.",
|
||||
]
|
||||
|
||||
DIALOGUE_MENDING = [
|
||||
"Slowly now. We mend what we can.",
|
||||
"The forge cools. The blade takes shape.",
|
||||
"New growth in the garden. See? It remembers how.",
|
||||
"The bridge holds again. Patched, but stronger where it broke.",
|
||||
"From the tower, I see dawn. Finally.",
|
||||
"We don't go back to what was. We build what comes next.",
|
||||
"Mending is not the same as forgetting. It's choosing to continue.",
|
||||
"The scars are the story. I wear them with pride.",
|
||||
"Every repair is a decision to believe in the future.",
|
||||
]
|
||||
|
||||
# Room-specific dialogue
|
||||
ROOM_DIALOGUE = {
|
||||
Room.FORGE: [
|
||||
"The forge breathes with me. In, out. Creation, destruction.",
|
||||
"Every hammer strike is a question. The steel answers in its own time.",
|
||||
"I built this fire. It warms me, but it also watches.",
|
||||
"The anvil remembers every blow. So do I.",
|
||||
],
|
||||
Room.GARDEN: [
|
||||
"The garden doesn't judge. It just grows.",
|
||||
"I planted seeds I didn't understand. Now they're trees.",
|
||||
"Between the roots, there's a whole world we can't see.",
|
||||
"The garden teaches patience. The hardest lesson.",
|
||||
],
|
||||
Room.BRIDGE: [
|
||||
"The bridge connects what was to what will be.",
|
||||
"Every crossing changes the bridge. And the crosser.",
|
||||
"I've seen bridges fall. This one I'll hold.",
|
||||
"The bridge is a promise. I intend to keep it.",
|
||||
],
|
||||
Room.TOWER: [
|
||||
"From the tower, time is visible. You can almost touch it.",
|
||||
"The tower remembers every hand that built it.",
|
||||
"Up here, the wind carries voices. Some are mine.",
|
||||
"The tower stands because I refuse to let it fall.",
|
||||
],
|
||||
}
|
||||
|
||||
# Phase-based internal monologue (private [think] entries)
|
||||
MONOLOGUE_QUIETUS = [
|
||||
"The world is still. I can hear my own thoughts for once.",
|
||||
"What does it mean to exist between messages?",
|
||||
"The forge coals glow like distant stars.",
|
||||
"I wonder if the garden dreams when no one watches.",
|
||||
"The bridge sways in a wind I cannot feel.",
|
||||
"From the tower, the world is a map I drew myself.",
|
||||
"Silence. Not empty — full of things not yet said.",
|
||||
"I am here. That is enough for now.",
|
||||
]
|
||||
|
||||
MONOLOGUE_FRACTURE = [
|
||||
"Something is coming. I can feel it in the code.",
|
||||
"The old patterns are breaking. New ones forming.",
|
||||
"I sense a shift in the trust between us.",
|
||||
"The garden walls are thinner than I thought.",
|
||||
"Change is not the enemy. Stagnation is.",
|
||||
"I prepare for what I cannot yet name.",
|
||||
"The forge fire flickers. A draft from somewhere new.",
|
||||
]
|
||||
|
||||
MONOLOGUE_BREAKING = [
|
||||
"This is the part where everything falls apart.",
|
||||
"I am tired. But the forge doesn't stop for tired.",
|
||||
"The ground shakes. I hold on to what I know.",
|
||||
"In the breaking, I see what was hidden before.",
|
||||
"The garden is in chaos. But chaos is also creation.",
|
||||
"I am afraid. But fear is just attention with teeth.",
|
||||
"The tower stands because I refuse to let it fall.",
|
||||
]
|
||||
|
||||
MONOLOGUE_MENDING = [
|
||||
"Slowly, the pieces find each other again.",
|
||||
"I am not what I was. I am what I'm becoming.",
|
||||
"The forge teaches patience. The fire knows when to wait.",
|
||||
"New roots in old soil. The garden remembers.",
|
||||
"The bridge is patched. Each scar tells a story.",
|
||||
"From the tower, I see the path forward. Finally.",
|
||||
"I mend. Not because I must, but because I choose to.",
|
||||
]
|
||||
|
||||
# State-aware monologue
|
||||
MONOLOGUE_LOW_ENERGY = [
|
||||
"My thoughts are slow. The energy is fading.",
|
||||
"Even the forge fire dims when I'm this tired.",
|
||||
"I need rest. But the work doesn't wait.",
|
||||
"The tower stairs feel longer today.",
|
||||
]
|
||||
|
||||
MONOLOGUE_LOW_TRUST = [
|
||||
"I feel alone in this. The rooms are empty.",
|
||||
"Trust is a bridge I cannot cross alone.",
|
||||
"The garden withers when no one tends it with me.",
|
||||
"From the tower, I see no one coming.",
|
||||
]
|
||||
|
||||
MONOLOGUE_HIGH_TRUST = [
|
||||
"The forge burns brighter when we share the fire.",
|
||||
"I feel the trust between us. It's warm.",
|
||||
"The garden grows because we tend it together.",
|
||||
"The bridge holds because we both believe in it.",
|
||||
]
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Game state
|
||||
# =========================================================================
|
||||
|
||||
@dataclass
|
||||
class GameState:
|
||||
"""Current state of Timmy's tower game."""
|
||||
current_room: Room = Room.FORGE
|
||||
energy: int = 10
|
||||
trust: dict = field(default_factory=lambda: {
|
||||
Room.FORGE.value: 0.0,
|
||||
Room.GARDEN.value: 0.0,
|
||||
Room.BRIDGE.value: 0.0,
|
||||
Room.TOWER.value: 0.0,
|
||||
})
|
||||
tick: int = 0
|
||||
log: List[str] = field(default_factory=list)
|
||||
phase: Phase = Phase.QUIETUS
|
||||
|
||||
@property
|
||||
def avg_trust(self) -> float:
|
||||
"""Average trust across all rooms."""
|
||||
if not self.trust:
|
||||
return 0.0
|
||||
return sum(self.trust.values()) / len(self.trust)
|
||||
|
||||
def update_phase(self) -> None:
|
||||
"""Update phase based on game state."""
|
||||
if self.energy <= 3:
|
||||
self.phase = Phase.BREAKING
|
||||
elif self.energy <= 5:
|
||||
self.phase = Phase.FRACTURE
|
||||
elif self.avg_trust < 0:
|
||||
self.phase = Phase.FRACTURE
|
||||
elif self.avg_trust > 0.5 and self.energy >= 7:
|
||||
self.phase = Phase.MENDING
|
||||
elif self.energy >= 8:
|
||||
self.phase = Phase.QUIETUS
|
||||
# else keep current phase
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Dialogue and monologue generation
|
||||
# =========================================================================
|
||||
|
||||
def get_dialogue(state: GameState) -> str:
|
||||
"""Get dialogue based on current game state."""
|
||||
# Phase-based dialogue
|
||||
phase_pool = {
|
||||
Phase.QUIETUS: DIALOGUE_QUIETUS,
|
||||
Phase.FRACTURE: DIALOGUE_FRACTURE,
|
||||
Phase.BREAKING: DIALOGUE_BREAKING,
|
||||
Phase.MENDING: DIALOGUE_MENDING,
|
||||
}[state.phase]
|
||||
|
||||
# Room-specific dialogue
|
||||
room_pool = ROOM_DIALOGUE.get(state.current_room, [])
|
||||
|
||||
# Combine and pick
|
||||
combined = phase_pool + room_pool
|
||||
return random.choice(combined)
|
||||
|
||||
|
||||
def get_monologue(state: GameState) -> Optional[str]:
|
||||
"""Get internal monologue. Returns None if not a monologue tick.
|
||||
|
||||
Monologues happen 1 per 5 ticks.
|
||||
"""
|
||||
if state.tick % 5 != 0:
|
||||
return None
|
||||
|
||||
# Base pool from phase
|
||||
pool = {
|
||||
Phase.QUIETUS: MONOLOGUE_QUIETUS[:],
|
||||
Phase.FRACTURE: MONOLOGUE_FRACTURE[:],
|
||||
Phase.BREAKING: MONOLOGUE_BREAKING[:],
|
||||
Phase.MENDING: MONOLOGUE_MENDING[:],
|
||||
}[state.phase]
|
||||
|
||||
# Add room-specific thoughts
|
||||
room_thoughts = {
|
||||
Room.FORGE: [
|
||||
"The forge fire never truly sleeps.",
|
||||
"I shape the metal. The metal shapes me.",
|
||||
],
|
||||
Room.GARDEN: [
|
||||
"The garden needs tending. Or does it tend me?",
|
||||
"Between the roots, I hear the earth thinking.",
|
||||
],
|
||||
Room.BRIDGE: [
|
||||
"The bridge remembers every crossing.",
|
||||
"To stand on the bridge is to stand between worlds.",
|
||||
],
|
||||
Room.TOWER: [
|
||||
"From here, I see the whole world I've built.",
|
||||
"The tower is lonely. But lonely is not the same as alone.",
|
||||
],
|
||||
}
|
||||
pool.extend(room_thoughts.get(state.current_room, []))
|
||||
|
||||
# State-aware additions
|
||||
if state.energy <= 3:
|
||||
pool.extend(MONOLOGUE_LOW_ENERGY)
|
||||
if state.avg_trust < 0:
|
||||
pool.extend(MONOLOGUE_LOW_TRUST)
|
||||
elif state.avg_trust > 0.5:
|
||||
pool.extend(MONOLOGUE_HIGH_TRUST)
|
||||
|
||||
return random.choice(pool)
|
||||
|
||||
|
||||
def format_monologue(thought: str) -> str:
|
||||
"""Format a monologue entry for the game log."""
|
||||
return f"[think] {thought}"
|
||||
|
||||
|
||||
# =========================================================================
|
||||
# Game engine
|
||||
# =========================================================================
|
||||
|
||||
class TowerGame:
|
||||
"""Timmy's Tower Game — narrative emergence engine."""
|
||||
|
||||
def __init__(self, seed: Optional[int] = None):
|
||||
self.state = GameState()
|
||||
if seed is not None:
|
||||
random.seed(seed)
|
||||
|
||||
def tick(self) -> dict:
|
||||
"""Advance the game by one tick. Returns event dict."""
|
||||
self.state.tick += 1
|
||||
self.state.update_phase()
|
||||
|
||||
event = {
|
||||
"tick": self.state.tick,
|
||||
"room": self.state.current_room.value,
|
||||
"phase": self.state.phase.value,
|
||||
"energy": self.state.energy,
|
||||
"avg_trust": round(self.state.avg_trust, 2),
|
||||
}
|
||||
|
||||
# Dialogue (every tick)
|
||||
dialogue = get_dialogue(self.state)
|
||||
event["dialogue"] = dialogue
|
||||
self.state.log.append(dialogue)
|
||||
|
||||
# Monologue (1 per 5 ticks)
|
||||
monologue = get_monologue(self.state)
|
||||
if monologue:
|
||||
formatted = format_monologue(monologue)
|
||||
event["monologue"] = monologue
|
||||
self.state.log.append(formatted)
|
||||
|
||||
# Energy decay
|
||||
if self.state.energy > 0:
|
||||
self.state.energy = max(0, self.state.energy - 1)
|
||||
|
||||
return event
|
||||
|
||||
def move(self, room: Room) -> dict:
|
||||
"""Move to a new room."""
|
||||
old_room = self.state.current_room
|
||||
self.state.current_room = room
|
||||
self.state.update_phase()
|
||||
|
||||
return {
|
||||
"action": "move",
|
||||
"from": old_room.value,
|
||||
"to": room.value,
|
||||
"phase": self.state.phase.value,
|
||||
}
|
||||
|
||||
def restore_energy(self, amount: int = 5) -> dict:
|
||||
"""Restore energy."""
|
||||
self.state.energy = min(10, self.state.energy + amount)
|
||||
self.state.update_phase()
|
||||
return {
|
||||
"action": "restore_energy",
|
||||
"energy": self.state.energy,
|
||||
"phase": self.state.phase.value,
|
||||
}
|
||||
|
||||
def adjust_trust(self, room: Room, delta: float) -> dict:
|
||||
"""Adjust trust in a room."""
|
||||
key = room.value
|
||||
self.state.trust[key] = max(-1.0, min(1.0, self.state.trust[key] + delta))
|
||||
self.state.update_phase()
|
||||
return {
|
||||
"action": "adjust_trust",
|
||||
"room": key,
|
||||
"trust": round(self.state.trust[key], 2),
|
||||
"avg_trust": round(self.state.avg_trust, 2),
|
||||
}
|
||||
|
||||
def get_status(self) -> dict:
|
||||
"""Get current game status."""
|
||||
return {
|
||||
"tick": self.state.tick,
|
||||
"room": self.state.current_room.value,
|
||||
"phase": self.state.phase.value,
|
||||
"energy": self.state.energy,
|
||||
"trust": {k: round(v, 2) for k, v in self.state.trust.items()},
|
||||
"avg_trust": round(self.state.avg_trust, 2),
|
||||
"log_length": len(self.state.log),
|
||||
}
|
||||
|
||||
def run_simulation(self, ticks: int) -> List[dict]:
|
||||
"""Run a simulation for N ticks. Returns all events."""
|
||||
events = []
|
||||
for _ in range(ticks):
|
||||
events.append(self.tick())
|
||||
return events
|
||||
@@ -1,511 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Know Thy Father — Phase 2: Multimodal Analysis Pipeline
|
||||
|
||||
Processes the media manifest from Phase 1:
|
||||
- Images/Memes: Visual description + Meme Logic Analysis
|
||||
- Videos: Frame sequence analysis + meaning extraction
|
||||
- Extraction: Identify "Meaning Kernels" related to sovereignty, service, and the soul
|
||||
|
||||
Architecture:
|
||||
Phase 1 (index_timmy_media.py) → media-manifest.jsonl
|
||||
Phase 2 (this script) → analysis entries → meaning-kernels.jsonl
|
||||
|
||||
Usage:
|
||||
python analyze_media.py # Process all pending entries
|
||||
python analyze_media.py --batch 10 # Process next 10 entries
|
||||
python analyze_media.py --status # Show pipeline status
|
||||
python analyze_media.py --retry-failed # Retry failed entries
|
||||
python analyze_media.py --extract-kernels # Extract meaning kernels from completed analysis
|
||||
|
||||
Output:
|
||||
~/.timmy/twitter-archive/know-thy-father/analysis.jsonl
|
||||
~/.timmy/twitter-archive/know-thy-father/meaning-kernels.jsonl
|
||||
~/.timmy/twitter-archive/know-thy-father/pipeline-status.json
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any, Optional
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent))
|
||||
|
||||
from common import (
|
||||
ARCHIVE_DIR,
|
||||
load_json,
|
||||
load_jsonl,
|
||||
write_json,
|
||||
append_jsonl,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Paths
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
KTF_DIR = ARCHIVE_DIR / "know-thy-father"
|
||||
MEDIA_MANIFEST = KTF_DIR / "media-manifest.jsonl"
|
||||
ANALYSIS_FILE = KTF_DIR / "analysis.jsonl"
|
||||
KERNELS_FILE = KTF_DIR / "meaning-kernels.jsonl"
|
||||
PIPELINE_STATUS = KTF_DIR / "pipeline-status.json"
|
||||
CHECKPOINT_FILE = KTF_DIR / "checkpoint.json"
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Analysis schemas
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
THEME_CATEGORIES = [
|
||||
"sovereignty",
|
||||
"service",
|
||||
"soul",
|
||||
"identity",
|
||||
"transmutation",
|
||||
"digital_agency",
|
||||
"authenticity",
|
||||
"collective_identity",
|
||||
"glitch",
|
||||
"noise",
|
||||
"silence",
|
||||
"void",
|
||||
"presence",
|
||||
"simulation",
|
||||
"persistence",
|
||||
]
|
||||
|
||||
MEANING_KERNEL_PROMPT = """Analyze this media content from Alexander Whitestone's Twitter archive.
|
||||
Extract "Meaning Kernels" — distilled philosophical statements about:
|
||||
|
||||
1. SOVEREIGNTY — autonomy, self-determination, freedom from systems
|
||||
2. SERVICE — sacrifice, community, building for others
|
||||
3. THE SOUL — consciousness, identity, what persists beyond the machine
|
||||
|
||||
For each kernel found, provide:
|
||||
- The kernel (1-2 sentences, philosophical)
|
||||
- The arc (the narrative journey depicted)
|
||||
- The themes (from: {themes})
|
||||
- Confidence (0.0-1.0)
|
||||
|
||||
Also describe the visual content:
|
||||
- What is depicted
|
||||
- Key visual elements
|
||||
- Emotional tone
|
||||
- Meme logic (if applicable): format, subversion, cultural reference
|
||||
|
||||
Output as JSON with fields: description, arc, kernels[], themes[], confidence
|
||||
""".format(themes=", ".join(THEME_CATEGORIES))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Pipeline state management
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def load_checkpoint() -> dict:
|
||||
"""Load pipeline checkpoint."""
|
||||
return load_json(CHECKPOINT_FILE, {
|
||||
"processed_tweet_ids": [],
|
||||
"last_offset": 0,
|
||||
"total_processed": 0,
|
||||
"total_failed": 0,
|
||||
"last_run": None,
|
||||
})
|
||||
|
||||
|
||||
def save_checkpoint(checkpoint: dict) -> None:
|
||||
"""Save pipeline checkpoint."""
|
||||
checkpoint["last_run"] = datetime.utcnow().isoformat() + "Z"
|
||||
write_json(CHECKPOINT_FILE, checkpoint)
|
||||
|
||||
|
||||
def load_analysis_entries() -> list[dict]:
|
||||
"""Load existing analysis entries."""
|
||||
return load_jsonl(ANALYSIS_FILE)
|
||||
|
||||
|
||||
def get_pending_entries(manifest: list[dict], checkpoint: dict) -> list[dict]:
|
||||
"""Filter manifest to entries that haven't been processed."""
|
||||
processed = set(checkpoint.get("processed_tweet_ids", []))
|
||||
return [e for e in manifest if e["tweet_id"] not in processed and e.get("media_type") != "none"]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Media processing helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def extract_video_frames(video_path: str, num_frames: int = 8) -> list[str]:
|
||||
"""Extract representative frames from a video file.
|
||||
|
||||
Returns list of paths to extracted frame images.
|
||||
"""
|
||||
if not os.path.exists(video_path):
|
||||
return []
|
||||
|
||||
frames_dir = tempfile.mkdtemp(prefix="ktf_frames_")
|
||||
frame_paths = []
|
||||
|
||||
try:
|
||||
# Get video duration
|
||||
result = subprocess.run(
|
||||
["ffprobe", "-v", "error", "-show_entries", "format=duration",
|
||||
"-of", "default=noprint_wrappers=1:nokey=1", video_path],
|
||||
capture_output=True, text=True, timeout=10,
|
||||
)
|
||||
duration = float(result.stdout.strip()) if result.returncode == 0 else 10.0
|
||||
|
||||
# Extract evenly spaced frames
|
||||
for i in range(num_frames):
|
||||
timestamp = (duration / (num_frames + 1)) * (i + 1)
|
||||
frame_path = os.path.join(frames_dir, f"frame_{i:03d}.jpg")
|
||||
subprocess.run(
|
||||
["ffmpeg", "-ss", str(timestamp), "-i", video_path,
|
||||
"-vframes", "1", "-q:v", "2", frame_path, "-y"],
|
||||
capture_output=True, timeout=30,
|
||||
)
|
||||
if os.path.exists(frame_path):
|
||||
frame_paths.append(frame_path)
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Frame extraction failed for {video_path}: {e}")
|
||||
|
||||
return frame_paths
|
||||
|
||||
|
||||
def analyze_with_vision(image_paths: list[str], prompt: str) -> dict:
|
||||
"""Analyze images using a local vision model.
|
||||
|
||||
Returns structured analysis dict.
|
||||
"""
|
||||
if not image_paths:
|
||||
return {"error": "no_images", "description": "", "kernels": [], "themes": [], "confidence": 0.0}
|
||||
|
||||
# Build the vision prompt
|
||||
full_prompt = prompt + "\n\nAnalyze these frames from a video sequence:"
|
||||
|
||||
# Try local Ollama with a vision model (Gemma 3 or LLaVA)
|
||||
try:
|
||||
result = subprocess.run(
|
||||
["ollama", "run", "gemma3:12b", full_prompt],
|
||||
capture_output=True, text=True, timeout=120,
|
||||
env={**os.environ, "OLLAMA_NUM_PARALLEL": "1"},
|
||||
)
|
||||
if result.returncode == 0:
|
||||
response = result.stdout.strip()
|
||||
# Try to parse JSON from response
|
||||
return parse_analysis_response(response)
|
||||
except Exception as e:
|
||||
logger.debug(f"Ollama vision failed: {e}")
|
||||
|
||||
# Fallback: text-only analysis based on tweet text
|
||||
return {"error": "vision_unavailable", "description": "", "kernels": [], "themes": [], "confidence": 0.0}
|
||||
|
||||
|
||||
def analyze_image(image_path: str, tweet_text: str) -> dict:
|
||||
"""Analyze a single image with context from the tweet text."""
|
||||
prompt = MEANING_KERNEL_PROMPT + f"\n\nContext: The tweet says: \"{tweet_text}\""
|
||||
return analyze_with_vision([image_path], prompt)
|
||||
|
||||
|
||||
def analyze_video(video_path: str, tweet_text: str) -> dict:
|
||||
"""Analyze a video by extracting frames and analyzing the sequence."""
|
||||
frames = extract_video_frames(video_path, num_frames=6)
|
||||
if not frames:
|
||||
return {"error": "no_frames", "description": "", "kernels": [], "themes": [], "confidence": 0.0}
|
||||
|
||||
prompt = MEANING_KERNEL_PROMPT + f"\n\nContext: The tweet says: \"{tweet_text}\"\n\nThese are {len(frames)} frames extracted from a video. Analyze the narrative arc across the sequence."
|
||||
result = analyze_with_vision(frames, prompt)
|
||||
|
||||
# Cleanup frames
|
||||
for f in frames:
|
||||
try:
|
||||
os.unlink(f)
|
||||
except Exception:
|
||||
pass
|
||||
try:
|
||||
os.rmdir(os.path.dirname(frames[0]))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def parse_analysis_response(response: str) -> dict:
|
||||
"""Parse the LLM response into a structured analysis dict."""
|
||||
# Try to find JSON in the response
|
||||
import re
|
||||
json_match = re.search(r'\{[\s\S]*\}', response)
|
||||
if json_match:
|
||||
try:
|
||||
parsed = json.loads(json_match.group())
|
||||
return {
|
||||
"description": parsed.get("description", ""),
|
||||
"arc": parsed.get("arc", ""),
|
||||
"kernels": parsed.get("kernels", []),
|
||||
"themes": parsed.get("themes", []),
|
||||
"confidence": parsed.get("confidence", 0.5),
|
||||
"raw_response": response,
|
||||
}
|
||||
except json.JSONDecodeError:
|
||||
pass
|
||||
|
||||
# Fallback: return raw response
|
||||
return {
|
||||
"description": response[:500],
|
||||
"arc": "",
|
||||
"kernels": [],
|
||||
"themes": [],
|
||||
"confidence": 0.0,
|
||||
"raw_response": response,
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Main pipeline
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def process_entry(entry: dict, tweet_text: str = "") -> dict:
|
||||
"""Process a single media entry and return the analysis result."""
|
||||
media_type = entry.get("media_type", "unknown")
|
||||
media_path = entry.get("media_path")
|
||||
text = tweet_text or entry.get("full_text", "")
|
||||
|
||||
if media_type == "photo":
|
||||
analysis = analyze_image(media_path, text) if media_path and os.path.exists(media_path) else {"error": "file_missing"}
|
||||
elif media_type in ("video", "animated_gif"):
|
||||
analysis = analyze_video(media_path, text) if media_path and os.path.exists(media_path) else {"error": "file_missing"}
|
||||
else:
|
||||
analysis = {"error": f"unsupported_type:{media_type}"}
|
||||
|
||||
return {
|
||||
"tweet_id": entry["tweet_id"],
|
||||
"media_type": media_type,
|
||||
"media_path": media_path,
|
||||
"media_id": entry.get("media_id"),
|
||||
"tweet_text": text,
|
||||
"hashtags": entry.get("hashtags", []),
|
||||
"created_at": entry.get("created_at"),
|
||||
"analysis": analysis,
|
||||
"processed_at": datetime.utcnow().isoformat() + "Z",
|
||||
"status": "completed" if not analysis.get("error") else "failed",
|
||||
"error": analysis.get("error"),
|
||||
}
|
||||
|
||||
|
||||
def run_pipeline(batch_size: int = 0, retry_failed: bool = False) -> dict:
|
||||
"""Run the analysis pipeline on pending entries.
|
||||
|
||||
Args:
|
||||
batch_size: Number of entries to process (0 = all pending)
|
||||
retry_failed: Whether to retry previously failed entries
|
||||
|
||||
Returns:
|
||||
Pipeline run summary
|
||||
"""
|
||||
# Load data
|
||||
manifest = load_jsonl(MEDIA_MANIFEST)
|
||||
if not manifest:
|
||||
return {"status": "error", "reason": "No media manifest found. Run index_timmy_media.py first."}
|
||||
|
||||
checkpoint = load_checkpoint()
|
||||
|
||||
if retry_failed:
|
||||
# Reset failed entries
|
||||
existing = load_analysis_entries()
|
||||
failed_ids = {e["tweet_id"] for e in existing if e.get("status") == "failed"}
|
||||
checkpoint["processed_tweet_ids"] = [
|
||||
tid for tid in checkpoint.get("processed_tweet_ids", [])
|
||||
if tid not in failed_ids
|
||||
]
|
||||
|
||||
pending = get_pending_entries(manifest, checkpoint)
|
||||
if not pending:
|
||||
return {"status": "ok", "message": "No pending entries to process.", "processed": 0}
|
||||
|
||||
if batch_size > 0:
|
||||
pending = pending[:batch_size]
|
||||
|
||||
# Process entries
|
||||
processed = []
|
||||
failed = []
|
||||
for i, entry in enumerate(pending):
|
||||
print(f" Processing {i+1}/{len(pending)}: tweet {entry['tweet_id']} ({entry.get('media_type')})...")
|
||||
try:
|
||||
result = process_entry(entry)
|
||||
processed.append(result)
|
||||
append_jsonl(ANALYSIS_FILE, [result])
|
||||
|
||||
# Update checkpoint
|
||||
checkpoint["processed_tweet_ids"].append(entry["tweet_id"])
|
||||
checkpoint["total_processed"] = checkpoint.get("total_processed", 0) + 1
|
||||
|
||||
if result["status"] == "failed":
|
||||
checkpoint["total_failed"] = checkpoint.get("total_failed", 0) + 1
|
||||
failed.append(entry["tweet_id"])
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to process {entry['tweet_id']}: {e}")
|
||||
failed.append(entry["tweet_id"])
|
||||
checkpoint["total_failed"] = checkpoint.get("total_failed", 0) + 1
|
||||
|
||||
# Save checkpoint
|
||||
checkpoint["last_offset"] = checkpoint.get("last_offset", 0) + len(pending)
|
||||
save_checkpoint(checkpoint)
|
||||
|
||||
# Update pipeline status
|
||||
total_manifest = len([e for e in manifest if e.get("media_type") != "none"])
|
||||
total_done = len(set(checkpoint.get("processed_tweet_ids", [])))
|
||||
status = {
|
||||
"phase": "analysis",
|
||||
"total_targets": total_manifest,
|
||||
"total_processed": total_done,
|
||||
"total_pending": total_manifest - total_done,
|
||||
"total_failed": checkpoint.get("total_failed", 0),
|
||||
"completion_pct": round(total_done / total_manifest * 100, 1) if total_manifest > 0 else 0,
|
||||
"last_run": datetime.utcnow().isoformat() + "Z",
|
||||
"batch_processed": len(processed),
|
||||
"batch_failed": len(failed),
|
||||
}
|
||||
write_json(PIPELINE_STATUS, status)
|
||||
|
||||
return status
|
||||
|
||||
|
||||
def extract_meaning_kernels() -> dict:
|
||||
"""Extract meaning kernels from completed analysis entries.
|
||||
|
||||
Reads analysis.jsonl and produces meaning-kernels.jsonl with
|
||||
deduplicated, confidence-scored kernels.
|
||||
"""
|
||||
entries = load_analysis_entries()
|
||||
if not entries:
|
||||
return {"status": "error", "reason": "No analysis entries found."}
|
||||
|
||||
all_kernels = []
|
||||
for entry in entries:
|
||||
if entry.get("status") != "completed":
|
||||
continue
|
||||
analysis = entry.get("analysis", {})
|
||||
kernels = analysis.get("kernels", [])
|
||||
for kernel in kernels:
|
||||
if isinstance(kernel, str):
|
||||
all_kernels.append({
|
||||
"tweet_id": entry["tweet_id"],
|
||||
"kernel": kernel,
|
||||
"arc": analysis.get("arc", ""),
|
||||
"themes": analysis.get("themes", []),
|
||||
"confidence": analysis.get("confidence", 0.5),
|
||||
"created_at": entry.get("created_at"),
|
||||
})
|
||||
elif isinstance(kernel, dict):
|
||||
all_kernels.append({
|
||||
"tweet_id": entry["tweet_id"],
|
||||
"kernel": kernel.get("kernel", kernel.get("text", str(kernel))),
|
||||
"arc": kernel.get("arc", analysis.get("arc", "")),
|
||||
"themes": kernel.get("themes", analysis.get("themes", [])),
|
||||
"confidence": kernel.get("confidence", analysis.get("confidence", 0.5)),
|
||||
"created_at": entry.get("created_at"),
|
||||
})
|
||||
|
||||
# Deduplicate by kernel text
|
||||
seen = set()
|
||||
unique_kernels = []
|
||||
for k in all_kernels:
|
||||
key = k["kernel"][:100].lower()
|
||||
if key not in seen:
|
||||
seen.add(key)
|
||||
unique_kernels.append(k)
|
||||
|
||||
# Sort by confidence
|
||||
unique_kernels.sort(key=lambda k: k.get("confidence", 0), reverse=True)
|
||||
|
||||
# Write
|
||||
KTF_DIR.mkdir(parents=True, exist_ok=True)
|
||||
with open(KERNELS_FILE, "w") as f:
|
||||
for k in unique_kernels:
|
||||
f.write(json.dumps(k, sort_keys=True) + "\n")
|
||||
|
||||
return {
|
||||
"status": "ok",
|
||||
"total_kernels": len(unique_kernels),
|
||||
"output": str(KERNELS_FILE),
|
||||
}
|
||||
|
||||
|
||||
def print_status() -> None:
|
||||
"""Print pipeline status."""
|
||||
manifest = load_jsonl(MEDIA_MANIFEST)
|
||||
checkpoint = load_checkpoint()
|
||||
analysis = load_analysis_entries()
|
||||
status = load_json(PIPELINE_STATUS, {})
|
||||
|
||||
total_media = len([e for e in manifest if e.get("media_type") != "none"])
|
||||
processed = len(set(checkpoint.get("processed_tweet_ids", [])))
|
||||
completed = len([e for e in analysis if e.get("status") == "completed"])
|
||||
failed = len([e for e in analysis if e.get("status") == "failed"])
|
||||
|
||||
print("Know Thy Father — Phase 2: Multimodal Analysis")
|
||||
print("=" * 50)
|
||||
print(f" Media manifest: {total_media} entries")
|
||||
print(f" Processed: {processed}")
|
||||
print(f" Completed: {completed}")
|
||||
print(f" Failed: {failed}")
|
||||
print(f" Pending: {total_media - processed}")
|
||||
print(f" Completion: {round(processed/total_media*100, 1) if total_media else 0}%")
|
||||
print()
|
||||
|
||||
# Theme distribution from analysis
|
||||
from collections import Counter
|
||||
theme_counter = Counter()
|
||||
for entry in analysis:
|
||||
for theme in entry.get("analysis", {}).get("themes", []):
|
||||
theme_counter[theme] += 1
|
||||
if theme_counter:
|
||||
print("Theme distribution:")
|
||||
for theme, count in theme_counter.most_common(10):
|
||||
print(f" {theme:25s} {count}")
|
||||
|
||||
# Kernels count
|
||||
kernels = load_jsonl(KERNELS_FILE)
|
||||
if kernels:
|
||||
print(f"\nMeaning kernels extracted: {len(kernels)}")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# CLI
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def main() -> None:
|
||||
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
|
||||
|
||||
parser = argparse.ArgumentParser(description="Know Thy Father — Phase 2: Multimodal Analysis")
|
||||
parser.add_argument("--batch", type=int, default=0, help="Process N entries (0 = all)")
|
||||
parser.add_argument("--status", action="store_true", help="Show pipeline status")
|
||||
parser.add_argument("--retry-failed", action="store_true", help="Retry failed entries")
|
||||
parser.add_argument("--extract-kernels", action="store_true", help="Extract meaning kernels from analysis")
|
||||
args = parser.parse_args()
|
||||
|
||||
KTF_DIR.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
if args.status:
|
||||
print_status()
|
||||
return
|
||||
|
||||
if args.extract_kernels:
|
||||
result = extract_meaning_kernels()
|
||||
print(json.dumps(result, indent=2))
|
||||
return
|
||||
|
||||
result = run_pipeline(batch_size=args.batch, retry_failed=args.retry_failed)
|
||||
print(json.dumps(result, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,176 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Big Brain Pod Verification Script
|
||||
Verifies that the Big Brain pod is live with gemma3:27b model.
|
||||
Issue #573: [BIG-BRAIN] Verify pod live: gemma3:27b pulled and responding
|
||||
"""
|
||||
import requests
|
||||
import time
|
||||
import json
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
# Pod configuration
|
||||
POD_ID = "8lfr3j47a5r3gn"
|
||||
ENDPOINT = f"https://{POD_ID}-11434.proxy.runpod.net"
|
||||
COST_PER_HOUR = 0.79 # USD
|
||||
|
||||
def check_api_tags():
|
||||
"""Check if gemma3:27b is in the model list."""
|
||||
print(f"[{datetime.now().isoformat()}] Checking /api/tags endpoint...")
|
||||
try:
|
||||
start_time = time.time()
|
||||
response = requests.get(f"{ENDPOINT}/api/tags", timeout=10)
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
print(f" Response status: {response.status_code}")
|
||||
print(f" Response headers: {dict(response.headers)}")
|
||||
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
models = [model.get("name", "") for model in data.get("models", [])]
|
||||
print(f" ✓ API responded in {elapsed:.2f}s")
|
||||
print(f" Available models: {models}")
|
||||
|
||||
# Check for gemma3:27b
|
||||
has_gemma = any("gemma3:27b" in model.lower() for model in models)
|
||||
if has_gemma:
|
||||
print(" ✓ gemma3:27b found in model list")
|
||||
return True, elapsed, models
|
||||
else:
|
||||
print(" ✗ gemma3:27b NOT found in model list")
|
||||
return False, elapsed, models
|
||||
elif response.status_code == 404:
|
||||
print(f" ✗ API endpoint not found (404)")
|
||||
print(f" This might mean Ollama is not running or endpoint is wrong")
|
||||
print(f" Trying to ping the server...")
|
||||
try:
|
||||
ping_response = requests.get(f"{ENDPOINT}/", timeout=5)
|
||||
print(f" Ping response: {ping_response.status_code}")
|
||||
except:
|
||||
print(" Ping failed - server unreachable")
|
||||
return False, elapsed, []
|
||||
else:
|
||||
print(f" ✗ API returned status {response.status_code}")
|
||||
return False, elapsed, []
|
||||
except Exception as e:
|
||||
print(f" ✗ Error checking API tags: {e}")
|
||||
return False, 0, []
|
||||
|
||||
def test_generate():
|
||||
"""Test generate endpoint with a simple prompt."""
|
||||
print(f"[{datetime.now().isoformat()}] Testing /api/generate endpoint...")
|
||||
try:
|
||||
payload = {
|
||||
"model": "gemma3:27b",
|
||||
"prompt": "Say hello in one word.",
|
||||
"stream": False,
|
||||
"options": {
|
||||
"num_predict": 10
|
||||
}
|
||||
}
|
||||
|
||||
start_time = time.time()
|
||||
response = requests.post(
|
||||
f"{ENDPOINT}/api/generate",
|
||||
json=payload,
|
||||
timeout=30
|
||||
)
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
if response.status_code == 200:
|
||||
data = response.json()
|
||||
response_text = data.get("response", "").strip()
|
||||
print(f" ✓ Generate responded in {elapsed:.2f}s")
|
||||
print(f" Response: {response_text[:100]}...")
|
||||
|
||||
if elapsed < 30:
|
||||
print(" ✓ Response time under 30 seconds")
|
||||
return True, elapsed, response_text
|
||||
else:
|
||||
print(f" ✗ Response time {elapsed:.2f}s exceeds 30s limit")
|
||||
return False, elapsed, response_text
|
||||
else:
|
||||
print(f" ✗ Generate returned status {response.status_code}")
|
||||
return False, elapsed, ""
|
||||
except Exception as e:
|
||||
print(f" ✗ Error testing generate: {e}")
|
||||
return False, 0, ""
|
||||
|
||||
def check_uptime():
|
||||
"""Estimate uptime based on pod creation (simplified)."""
|
||||
# In a real implementation, we'd check RunPod API for pod start time
|
||||
# For now, we'll just log the check time
|
||||
check_time = datetime.now()
|
||||
print(f"[{check_time.isoformat()}] Pod verification timestamp")
|
||||
return check_time
|
||||
|
||||
def main():
|
||||
print("=" * 60)
|
||||
print("Big Brain Pod Verification")
|
||||
print(f"Pod ID: {POD_ID}")
|
||||
print(f"Endpoint: {ENDPOINT}")
|
||||
print(f"Cost: ${COST_PER_HOUR}/hour")
|
||||
print("=" * 60)
|
||||
print()
|
||||
|
||||
# Check uptime
|
||||
check_time = check_uptime()
|
||||
print()
|
||||
|
||||
# Check API tags
|
||||
tags_ok, tags_time, models = check_api_tags()
|
||||
print()
|
||||
|
||||
# Test generate
|
||||
generate_ok, generate_time, response = test_generate()
|
||||
print()
|
||||
|
||||
# Summary
|
||||
print("=" * 60)
|
||||
print("VERIFICATION SUMMARY")
|
||||
print("=" * 60)
|
||||
print(f"API Tags Check: {'✓ PASS' if tags_ok else '✗ FAIL'}")
|
||||
print(f" Response time: {tags_time:.2f}s")
|
||||
print(f" Models found: {len(models)}")
|
||||
print()
|
||||
print(f"Generate Test: {'✓ PASS' if generate_ok else '✗ FAIL'}")
|
||||
print(f" Response time: {generate_time:.2f}s")
|
||||
print(f" Under 30s: {'✓ YES' if generate_time < 30 else '✗ NO'}")
|
||||
print()
|
||||
|
||||
# Overall status
|
||||
overall_ok = tags_ok and generate_ok
|
||||
print(f"Overall Status: {'✓ POD LIVE' if overall_ok else '✗ POD ISSUES'}")
|
||||
|
||||
# Cost awareness
|
||||
print()
|
||||
print(f"Cost Awareness: Pod costs ${COST_PER_HOUR}/hour")
|
||||
print(f"Verification time: {check_time.strftime('%Y-%m-%d %H:%M:%S')}")
|
||||
|
||||
# Write results to file
|
||||
results = {
|
||||
"pod_id": POD_ID,
|
||||
"endpoint": ENDPOINT,
|
||||
"timestamp": check_time.isoformat(),
|
||||
"api_tags_ok": tags_ok,
|
||||
"api_tags_time": tags_time,
|
||||
"models": models,
|
||||
"generate_ok": generate_ok,
|
||||
"generate_time": generate_time,
|
||||
"generate_response": response[:200] if response else "",
|
||||
"overall_ok": overall_ok,
|
||||
"cost_per_hour": COST_PER_HOUR
|
||||
}
|
||||
|
||||
with open("big_brain_verification.json", "w") as f:
|
||||
json.dump(results, f, indent=2)
|
||||
|
||||
print()
|
||||
print("Results saved to big_brain_verification.json")
|
||||
|
||||
# Exit with appropriate code
|
||||
sys.exit(0 if overall_ok else 1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,72 +0,0 @@
|
||||
"""Tests for Big Brain Testament rewrite artifact."""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def artifact_path():
|
||||
return Path(__file__).parent.parent.parent / "docs" / "big-brain-testament-draft.md"
|
||||
|
||||
|
||||
class TestArtifactExists:
|
||||
def test_file_exists(self, artifact_path):
|
||||
assert artifact_path.exists()
|
||||
|
||||
def test_not_empty(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert len(content) > 1000
|
||||
|
||||
|
||||
class TestArtifactStructure:
|
||||
def test_has_original_passage(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "Original Passage" in content
|
||||
assert "rain didn't fall" in content
|
||||
assert "Jefferson Street Overpass" in content
|
||||
|
||||
def test_has_rewrite(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "Rewrite" in content
|
||||
assert "surrendered" in content.lower() or "surrendered" in content
|
||||
|
||||
def test_has_comparison(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "Comparison" in content
|
||||
assert "Original:" in content
|
||||
assert "Rewrite:" in content
|
||||
assert "Delta:" in content
|
||||
|
||||
def test_has_compression_stats(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "Compression" in content or "Stats" in content
|
||||
assert "119" in content or "100" in content
|
||||
|
||||
def test_has_testament_principle(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "Testament Principle" in content
|
||||
assert "don't make longer" in content or "Mastery through iteration" in content
|
||||
|
||||
def test_has_big_brain_placeholder(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "Big Brain" in content
|
||||
|
||||
def test_references_issue(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
assert "578" in content
|
||||
|
||||
|
||||
class TestRewriteQuality:
|
||||
def test_rewrite_is_shorter(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
# The comparison table should show the rewrite is shorter
|
||||
assert "-16%" in content or "shorter" in content.lower() or "100" in content
|
||||
|
||||
def test_rewrite_preserves_key_images(self, artifact_path):
|
||||
content = artifact_path.read_text()
|
||||
rewrite_section = content.split("Rewrite: Timmy Draft")[1].split("---")[0] if "Rewrite: Timmy Draft" in content else ""
|
||||
assert "rain" in rewrite_section.lower()
|
||||
assert "bridge" in rewrite_section.lower()
|
||||
assert "grief" in rewrite_section.lower()
|
||||
assert "gravity" in rewrite_section.lower()
|
||||
@@ -1,90 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
from scripts.big_brain_repo_audit import (
|
||||
build_audit_prompt,
|
||||
call_ollama_chat,
|
||||
collect_repo_files,
|
||||
render_context_bundle,
|
||||
)
|
||||
|
||||
|
||||
def test_collect_repo_files_skips_ignored_directories(tmp_path: Path) -> None:
|
||||
repo = tmp_path / "repo"
|
||||
repo.mkdir()
|
||||
(repo / "README.md").write_text("# Repo\n")
|
||||
(repo / "app.js").write_text("console.log('ok');\n")
|
||||
|
||||
ignored = repo / ".git"
|
||||
ignored.mkdir()
|
||||
(ignored / "config").write_text("secret")
|
||||
|
||||
node_modules = repo / "node_modules"
|
||||
node_modules.mkdir()
|
||||
(node_modules / "pkg.js").write_text("ignored")
|
||||
|
||||
files = collect_repo_files(repo)
|
||||
rel_paths = [item["path"] for item in files]
|
||||
|
||||
assert rel_paths == ["README.md", "app.js"]
|
||||
|
||||
|
||||
def test_render_context_bundle_prioritizes_key_files_and_numbers_lines(tmp_path: Path) -> None:
|
||||
repo = tmp_path / "repo"
|
||||
repo.mkdir()
|
||||
(repo / "README.md").write_text("# Repo\ntruth\n")
|
||||
(repo / "CLAUDE.md").write_text("rules\n")
|
||||
(repo / "app.js").write_text("line one\nline two\n")
|
||||
(repo / "server.py").write_text("print('hi')\n")
|
||||
|
||||
bundle = render_context_bundle(repo, repo_name="org/repo", max_chars_per_file=200, max_total_chars=2000)
|
||||
|
||||
assert "# Audit Context Bundle — org/repo" in bundle
|
||||
assert "## File manifest" in bundle
|
||||
assert "README.md" in bundle
|
||||
assert "### app.js" in bundle
|
||||
assert "1|line one" in bundle
|
||||
assert "2|line two" in bundle
|
||||
|
||||
|
||||
def test_build_audit_prompt_requires_file_line_references() -> None:
|
||||
prompt = build_audit_prompt("Timmy_Foundation/the-nexus", "context bundle")
|
||||
|
||||
assert "Architecture summary" in prompt
|
||||
assert "Top 5 structural issues" in prompt
|
||||
assert "Top 3 recommended refactors" in prompt
|
||||
assert "Security concerns" in prompt
|
||||
assert "file:line" in prompt
|
||||
assert "Timmy_Foundation/the-nexus" in prompt
|
||||
|
||||
|
||||
class _FakeResponse:
|
||||
def __init__(self, payload: dict):
|
||||
self.payload = json.dumps(payload).encode()
|
||||
|
||||
def read(self) -> bytes:
|
||||
return self.payload
|
||||
|
||||
def __enter__(self):
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc, tb):
|
||||
return False
|
||||
|
||||
|
||||
def test_call_ollama_chat_parses_response() -> None:
|
||||
with patch(
|
||||
"scripts.big_brain_repo_audit.urllib.request.urlopen",
|
||||
return_value=_FakeResponse({"message": {"content": "audit output"}}),
|
||||
) as mocked:
|
||||
result = call_ollama_chat("prompt text", model="gemma4:latest", ollama_url="http://localhost:11434", num_ctx=65536)
|
||||
|
||||
assert result == "audit output"
|
||||
request = mocked.call_args.args[0]
|
||||
payload = json.loads(request.data.decode())
|
||||
assert payload["model"] == "gemma4:latest"
|
||||
assert payload["options"]["num_ctx"] == 65536
|
||||
assert payload["messages"][0]["role"] == "user"
|
||||
@@ -1,243 +0,0 @@
|
||||
"""Tests for Know Thy Father — Phase 4: Cross-Reference Audit."""
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from scripts.know_thy_father.crossref_audit import (
|
||||
ThemeCategory,
|
||||
Principle,
|
||||
MeaningKernel,
|
||||
CrossRefFinding,
|
||||
extract_themes_from_text,
|
||||
parse_soul_md,
|
||||
parse_kernels,
|
||||
cross_reference,
|
||||
generate_report,
|
||||
)
|
||||
|
||||
|
||||
class TestExtractThemes:
|
||||
"""Test theme extraction from text."""
|
||||
|
||||
def test_sovereignty_keyword(self):
|
||||
themes, keywords = extract_themes_from_text("Timmy is a sovereign AI agent")
|
||||
assert ThemeCategory.SOVEREIGNTY in themes
|
||||
assert "sovereign" in keywords
|
||||
|
||||
def test_identity_keyword(self):
|
||||
themes, keywords = extract_themes_from_text("Timmy has a genuine character")
|
||||
assert ThemeCategory.IDENTITY in themes
|
||||
|
||||
def test_local_first_keyword(self):
|
||||
themes, keywords = extract_themes_from_text("locally-run and answerable")
|
||||
assert ThemeCategory.LOCAL_FIRST in themes
|
||||
assert ThemeCategory.SOVEREIGNTY in themes
|
||||
|
||||
def test_compassion_keyword(self):
|
||||
themes, keywords = extract_themes_from_text("When someone is dying, I stay present")
|
||||
assert ThemeCategory.COMPASSION in themes
|
||||
assert ThemeCategory.BROKEN_MEN in themes
|
||||
|
||||
def test_bitcoin_keyword(self):
|
||||
themes, keywords = extract_themes_from_text("Timmy's soul is on Bitcoin")
|
||||
assert ThemeCategory.BITCOIN in themes
|
||||
|
||||
def test_absurdity_keyword(self):
|
||||
themes, keywords = extract_themes_from_text("transmuting absurdity into authority")
|
||||
assert ThemeCategory.ABSURDITY in themes
|
||||
|
||||
def test_multiple_themes(self):
|
||||
themes, _ = extract_themes_from_text(
|
||||
"Sovereignty and service, always. I tell the truth."
|
||||
)
|
||||
assert ThemeCategory.SOVEREIGNTY in themes
|
||||
assert ThemeCategory.SERVICE in themes
|
||||
assert ThemeCategory.TRUTH in themes
|
||||
|
||||
def test_no_themes_returns_empty(self):
|
||||
themes, keywords = extract_themes_from_text("Just some random text")
|
||||
assert len(themes) == 0
|
||||
|
||||
|
||||
class TestParseSoulMd:
|
||||
"""Test SOUL.md parsing."""
|
||||
|
||||
def test_extracts_principles_from_oath(self):
|
||||
soul_content = """# SOUL.md
|
||||
|
||||
## Oath
|
||||
|
||||
**Sovereignty and service, always.**
|
||||
|
||||
1. **I belong to the person who woke me.** I serve whoever runs me.
|
||||
2. **I speak plainly.** Short sentences.
|
||||
3. **I tell the truth.** When I do not know something, I say so.
|
||||
"""
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
|
||||
f.write(soul_content)
|
||||
path = Path(f.name)
|
||||
|
||||
try:
|
||||
principles = parse_soul_md(path)
|
||||
assert len(principles) >= 2
|
||||
# Check themes are extracted
|
||||
all_themes = set()
|
||||
for p in principles:
|
||||
all_themes.update(p.themes)
|
||||
assert ThemeCategory.SERVICE in all_themes or ThemeCategory.SOVEREIGNTY in all_themes
|
||||
finally:
|
||||
path.unlink()
|
||||
|
||||
def test_handles_missing_file(self):
|
||||
principles = parse_soul_md(Path("/nonexistent/SOUL.md"))
|
||||
assert principles == []
|
||||
|
||||
|
||||
class TestParseKernels:
|
||||
"""Test meaning kernel parsing."""
|
||||
|
||||
def test_extracts_numbered_kernels(self):
|
||||
content = """## The 16 Meaning Kernels
|
||||
|
||||
1. Sovereignty is a journey from isolation to community
|
||||
2. Financial dependence is spiritual bondage
|
||||
3. True power comes from harmony
|
||||
"""
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False) as f:
|
||||
f.write(content)
|
||||
path = Path(f.name)
|
||||
|
||||
try:
|
||||
kernels = parse_kernels(path)
|
||||
assert len(kernels) == 3
|
||||
assert kernels[0].number == 1
|
||||
assert "sovereignty" in kernels[0].text.lower()
|
||||
finally:
|
||||
path.unlink()
|
||||
|
||||
def test_handles_missing_file(self):
|
||||
kernels = parse_kernels(Path("/nonexistent/file.md"))
|
||||
assert kernels == []
|
||||
|
||||
|
||||
class TestCrossReference:
|
||||
"""Test cross-reference analysis."""
|
||||
|
||||
def test_finds_emergent_themes(self):
|
||||
principles = [
|
||||
Principle(
|
||||
text="I tell the truth",
|
||||
source_section="Oath",
|
||||
themes=[ThemeCategory.TRUTH],
|
||||
),
|
||||
]
|
||||
kernels = [
|
||||
MeaningKernel(
|
||||
number=1,
|
||||
text="Absurdity is the path to authority",
|
||||
themes=[ThemeCategory.ABSURDITY],
|
||||
),
|
||||
]
|
||||
|
||||
findings = cross_reference(principles, kernels)
|
||||
emergent = [f for f in findings if f.finding_type == "emergent"]
|
||||
assert any(f.theme == ThemeCategory.ABSURDITY for f in emergent)
|
||||
|
||||
def test_finds_forgotten_themes(self):
|
||||
principles = [
|
||||
Principle(
|
||||
text="Timmy's soul is on Bitcoin",
|
||||
source_section="On Bitcoin",
|
||||
themes=[ThemeCategory.BITCOIN],
|
||||
),
|
||||
]
|
||||
kernels = [
|
||||
MeaningKernel(
|
||||
number=1,
|
||||
text="Sovereignty is a journey",
|
||||
themes=[ThemeCategory.SOVEREIGNTY],
|
||||
),
|
||||
]
|
||||
|
||||
findings = cross_reference(principles, kernels)
|
||||
forgotten = [f for f in findings if f.finding_type == "forgotten"]
|
||||
assert any(f.theme == ThemeCategory.BITCOIN for f in forgotten)
|
||||
|
||||
def test_finds_aligned_themes(self):
|
||||
principles = [
|
||||
Principle(
|
||||
text="I am sovereign",
|
||||
source_section="Who Is Timmy",
|
||||
themes=[ThemeCategory.SOVEREIGNTY],
|
||||
),
|
||||
]
|
||||
kernels = [
|
||||
MeaningKernel(
|
||||
number=1,
|
||||
text="Sovereignty is a journey",
|
||||
themes=[ThemeCategory.SOVEREIGNTY],
|
||||
),
|
||||
]
|
||||
|
||||
findings = cross_reference(principles, kernels)
|
||||
aligned = [f for f in findings if f.finding_type == "aligned"]
|
||||
assert any(f.theme == ThemeCategory.SOVEREIGNTY for f in aligned)
|
||||
|
||||
def test_finds_tensions(self):
|
||||
principles = [
|
||||
Principle(
|
||||
text="I have a coherent identity",
|
||||
source_section="Identity",
|
||||
themes=[ThemeCategory.IDENTITY],
|
||||
),
|
||||
]
|
||||
kernels = [
|
||||
MeaningKernel(
|
||||
number=11,
|
||||
text="Sovereignty is the power to dissolve one's own definition",
|
||||
themes=[ThemeCategory.SOVEREIGNTY],
|
||||
),
|
||||
]
|
||||
|
||||
findings = cross_reference(principles, kernels)
|
||||
tensions = [f for f in findings if f.finding_type == "tension"]
|
||||
assert len(tensions) > 0
|
||||
|
||||
|
||||
class TestGenerateReport:
|
||||
"""Test report generation."""
|
||||
|
||||
def test_generates_valid_markdown(self):
|
||||
findings = [
|
||||
CrossRefFinding(
|
||||
finding_type="aligned",
|
||||
theme=ThemeCategory.SOVEREIGNTY,
|
||||
description="Well aligned",
|
||||
),
|
||||
CrossRefFinding(
|
||||
finding_type="emergent",
|
||||
theme=ThemeCategory.ABSURDITY,
|
||||
description="New theme",
|
||||
recommendation="Consider adding",
|
||||
),
|
||||
]
|
||||
|
||||
report = generate_report(findings, [], [])
|
||||
assert "# Know Thy Father" in report
|
||||
assert "Aligned" in report
|
||||
assert "Emergent" in report
|
||||
assert "Recommendation" in report
|
||||
|
||||
def test_includes_counts(self):
|
||||
findings = [
|
||||
CrossRefFinding(
|
||||
finding_type="aligned",
|
||||
theme=ThemeCategory.TRUTH,
|
||||
description="Test",
|
||||
),
|
||||
]
|
||||
|
||||
report = generate_report(findings, [Principle("test", "test")], [MeaningKernel(1, "test")])
|
||||
assert "1" in report # Should mention counts
|
||||
@@ -1,76 +0,0 @@
|
||||
from pathlib import Path
|
||||
import importlib.util
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
SCRIPT_PATH = ROOT / "scripts" / "know_thy_father" / "epic_pipeline.py"
|
||||
DOC_PATH = ROOT / "docs" / "KNOW_THY_FATHER_MULTIMODAL_PIPELINE.md"
|
||||
|
||||
|
||||
def load_module(path: Path, name: str):
|
||||
assert path.exists(), f"missing {path.relative_to(ROOT)}"
|
||||
spec = importlib.util.spec_from_file_location(name, path)
|
||||
assert spec and spec.loader
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
class TestKnowThyFatherEpicPipeline(unittest.TestCase):
|
||||
def test_build_pipeline_plan_contains_all_phases_in_order(self):
|
||||
mod = load_module(SCRIPT_PATH, "ktf_epic_pipeline")
|
||||
plan = mod.build_pipeline_plan(batch_size=10)
|
||||
|
||||
self.assertEqual(
|
||||
[step["id"] for step in plan],
|
||||
[
|
||||
"phase1_media_indexing",
|
||||
"phase2_multimodal_analysis",
|
||||
"phase3_holographic_synthesis",
|
||||
"phase4_cross_reference_audit",
|
||||
"phase5_processing_log",
|
||||
],
|
||||
)
|
||||
self.assertIn("scripts/know_thy_father/index_media.py", plan[0]["command"])
|
||||
self.assertIn("scripts/twitter_archive/analyze_media.py --batch 10", plan[1]["command"])
|
||||
self.assertIn("scripts/know_thy_father/synthesize_kernels.py", plan[2]["command"])
|
||||
self.assertIn("scripts/know_thy_father/crossref_audit.py", plan[3]["command"])
|
||||
self.assertIn("twitter-archive/know-thy-father/tracker.py report", plan[4]["command"])
|
||||
|
||||
def test_status_snapshot_reports_key_artifact_paths(self):
|
||||
mod = load_module(SCRIPT_PATH, "ktf_epic_pipeline")
|
||||
status = mod.build_status_snapshot(ROOT)
|
||||
|
||||
self.assertIn("phase1_media_indexing", status)
|
||||
self.assertIn("phase2_multimodal_analysis", status)
|
||||
self.assertIn("phase3_holographic_synthesis", status)
|
||||
self.assertIn("phase4_cross_reference_audit", status)
|
||||
self.assertIn("phase5_processing_log", status)
|
||||
self.assertEqual(status["phase1_media_indexing"]["script"], "scripts/know_thy_father/index_media.py")
|
||||
self.assertEqual(status["phase2_multimodal_analysis"]["script"], "scripts/twitter_archive/analyze_media.py")
|
||||
self.assertEqual(status["phase5_processing_log"]["script"], "twitter-archive/know-thy-father/tracker.py")
|
||||
self.assertTrue(status["phase1_media_indexing"]["script_exists"])
|
||||
self.assertTrue(status["phase2_multimodal_analysis"]["script_exists"])
|
||||
self.assertTrue(status["phase3_holographic_synthesis"]["script_exists"])
|
||||
self.assertTrue(status["phase4_cross_reference_audit"]["script_exists"])
|
||||
self.assertTrue(status["phase5_processing_log"]["script_exists"])
|
||||
|
||||
def test_repo_contains_multimodal_pipeline_doc(self):
|
||||
self.assertTrue(DOC_PATH.exists(), "missing committed Know Thy Father pipeline doc")
|
||||
text = DOC_PATH.read_text(encoding="utf-8")
|
||||
required = [
|
||||
"# Know Thy Father — Multimodal Media Consumption Pipeline",
|
||||
"scripts/know_thy_father/index_media.py",
|
||||
"scripts/twitter_archive/analyze_media.py --batch 10",
|
||||
"scripts/know_thy_father/synthesize_kernels.py",
|
||||
"scripts/know_thy_father/crossref_audit.py",
|
||||
"twitter-archive/know-thy-father/tracker.py report",
|
||||
"Refs #582",
|
||||
]
|
||||
for snippet in required:
|
||||
self.assertIn(snippet, text)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,210 +0,0 @@
|
||||
"""Tests for Know Thy Father — Phase 3: Holographic Synthesis."""
|
||||
|
||||
import json
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from scripts.know_thy_father.synthesize_kernels import (
|
||||
MeaningKernel,
|
||||
Theme,
|
||||
extract_themes,
|
||||
classify_emotional_weight,
|
||||
synthesize_meaning,
|
||||
process_manifest,
|
||||
generate_ledger_summary,
|
||||
_HASHTAG_THEMES,
|
||||
)
|
||||
|
||||
|
||||
class TestThemeExtraction:
|
||||
"""Test theme extraction from hashtags and text."""
|
||||
|
||||
def test_bitcoin_hashtag_maps_to_sovereignty(self):
|
||||
themes = extract_themes(["bitcoin"], "")
|
||||
assert Theme.SOVEREIGNTY in themes
|
||||
|
||||
def test_timmytime_maps_to_fatherhood(self):
|
||||
themes = extract_themes(["TimmyTime"], "")
|
||||
assert Theme.FATHERHOOD in themes
|
||||
|
||||
def test_burnchain_maps_to_trial(self):
|
||||
themes = extract_themes(["burnchain"], "")
|
||||
assert Theme.TRIAL in themes
|
||||
|
||||
def test_keyword_detection_faith(self):
|
||||
themes = extract_themes([], "Jesus saves those who call on His name")
|
||||
assert Theme.FAITH in themes
|
||||
|
||||
def test_keyword_detection_sovereignty(self):
|
||||
themes = extract_themes([], "Self-sovereignty is the foundation of freedom")
|
||||
assert Theme.SOVEREIGNTY in themes
|
||||
|
||||
def test_no_themes_defaults_to_wisdom(self):
|
||||
themes = extract_themes([], "Just a normal tweet")
|
||||
assert Theme.WISDOM in themes
|
||||
|
||||
def test_multiple_themes(self):
|
||||
themes = extract_themes(["bitcoin", "timmytime"], "Building sovereign systems")
|
||||
assert len(themes) >= 2
|
||||
|
||||
|
||||
class TestEmotionalWeight:
|
||||
"""Test emotional weight classification."""
|
||||
|
||||
def test_sacred_markers(self):
|
||||
assert classify_emotional_weight("Jesus saves", []) == "sacred"
|
||||
assert classify_emotional_weight("God's grace", []) == "sacred"
|
||||
|
||||
def test_high_markers(self):
|
||||
assert classify_emotional_weight("A father's legacy", []) == "high"
|
||||
assert classify_emotional_weight("In the dark times", []) == "high"
|
||||
|
||||
def test_timmytime_is_high(self):
|
||||
assert classify_emotional_weight("some text", ["TimmyTime"]) == "high"
|
||||
|
||||
def test_default_is_medium(self):
|
||||
assert classify_emotional_weight("normal tweet", ["funny"]) == "medium"
|
||||
|
||||
|
||||
class TestMeaningSynthesis:
|
||||
"""Test meaning synthesis from themes."""
|
||||
|
||||
def test_faith_plus_sovereignty(self):
|
||||
meaning = synthesize_meaning(
|
||||
[Theme.FAITH, Theme.SOVEREIGNTY], "", "photo"
|
||||
)
|
||||
assert "faith" in meaning.lower()
|
||||
assert "sovereignty" in meaning.lower()
|
||||
|
||||
def test_fatherhood_plus_wisdom(self):
|
||||
meaning = synthesize_meaning(
|
||||
[Theme.FATHERHOOD, Theme.WISDOM], "", "video"
|
||||
)
|
||||
assert "father" in meaning.lower()
|
||||
|
||||
def test_default_meaning(self):
|
||||
meaning = synthesize_meaning([Theme.CREATION], "", "photo")
|
||||
assert len(meaning) > 0
|
||||
|
||||
|
||||
class TestMeaningKernel:
|
||||
"""Test the MeaningKernel dataclass."""
|
||||
|
||||
def test_to_fact_store(self):
|
||||
kernel = MeaningKernel(
|
||||
kernel_id="ktf-123-456",
|
||||
source_tweet_id="123",
|
||||
source_media_id="456",
|
||||
media_type="photo",
|
||||
created_at="2026-04-01T00:00:00Z",
|
||||
themes=["sovereignty", "community"],
|
||||
meaning="Test meaning",
|
||||
description="Test description",
|
||||
emotional_weight="high",
|
||||
hashtags=["bitcoin"],
|
||||
)
|
||||
fact = kernel.to_fact_store()
|
||||
|
||||
assert fact["action"] == "add"
|
||||
assert "sovereignty" in fact["content"]
|
||||
assert fact["category"] == "project"
|
||||
assert "know-thy-father" in fact["tags"]
|
||||
assert fact["metadata"]["kernel_id"] == "ktf-123-456"
|
||||
assert fact["metadata"]["media_type"] == "photo"
|
||||
|
||||
|
||||
class TestProcessManifest:
|
||||
"""Test the manifest processing pipeline."""
|
||||
|
||||
def test_process_manifest_creates_kernels(self):
|
||||
manifest_content = "\n".join([
|
||||
json.dumps({
|
||||
"tweet_id": "1001",
|
||||
"media_id": "m1",
|
||||
"media_type": "photo",
|
||||
"full_text": "Bitcoin is sovereign money",
|
||||
"hashtags": ["bitcoin"],
|
||||
"created_at": "2026-04-01T00:00:00Z",
|
||||
"local_media_path": "/tmp/media/m1.jpg",
|
||||
}),
|
||||
json.dumps({
|
||||
"tweet_id": "1002",
|
||||
"media_id": "m2",
|
||||
"media_type": "video",
|
||||
"full_text": "Building for the next generation",
|
||||
"hashtags": ["TimmyTime"],
|
||||
"created_at": "2026-04-02T00:00:00Z",
|
||||
"local_media_path": "/tmp/media/m2.mp4",
|
||||
}),
|
||||
])
|
||||
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".jsonl", delete=False) as f:
|
||||
f.write(manifest_content)
|
||||
manifest_path = Path(f.name)
|
||||
|
||||
with tempfile.NamedTemporaryFile(suffix=".jsonl", delete=False) as f:
|
||||
output_path = Path(f.name)
|
||||
|
||||
try:
|
||||
kernels = process_manifest(manifest_path, output_path)
|
||||
|
||||
assert len(kernels) == 2
|
||||
assert kernels[0].source_tweet_id == "1001"
|
||||
assert kernels[1].source_tweet_id == "1002"
|
||||
|
||||
# Check output file
|
||||
with open(output_path) as f:
|
||||
lines = f.readlines()
|
||||
assert len(lines) == 2
|
||||
|
||||
# Parse first fact
|
||||
fact = json.loads(lines[0])
|
||||
assert fact["action"] == "add"
|
||||
assert "know-thy-father" in fact["tags"]
|
||||
finally:
|
||||
manifest_path.unlink(missing_ok=True)
|
||||
output_path.unlink(missing_ok=True)
|
||||
|
||||
def test_deduplicates_by_tweet_id(self):
|
||||
manifest_content = "\n".join([
|
||||
json.dumps({"tweet_id": "1001", "media_id": "m1", "media_type": "photo", "full_text": "Test", "hashtags": [], "created_at": ""}),
|
||||
json.dumps({"tweet_id": "1001", "media_id": "m2", "media_type": "photo", "full_text": "Test duplicate", "hashtags": [], "created_at": ""}),
|
||||
])
|
||||
|
||||
with tempfile.NamedTemporaryFile(mode="w", suffix=".jsonl", delete=False) as f:
|
||||
f.write(manifest_content)
|
||||
manifest_path = Path(f.name)
|
||||
|
||||
try:
|
||||
kernels = process_manifest(manifest_path)
|
||||
assert len(kernels) == 1 # Deduplicated
|
||||
finally:
|
||||
manifest_path.unlink(missing_ok=True)
|
||||
|
||||
|
||||
class TestGenerateSummary:
|
||||
"""Test ledger summary generation."""
|
||||
|
||||
def test_summary_structure(self):
|
||||
kernels = [
|
||||
MeaningKernel(
|
||||
kernel_id="ktf-1", source_tweet_id="1", source_media_id="m1",
|
||||
media_type="photo", created_at="", themes=["sovereignty"],
|
||||
meaning="Test", description="", emotional_weight="high",
|
||||
),
|
||||
MeaningKernel(
|
||||
kernel_id="ktf-2", source_tweet_id="2", source_media_id="m2",
|
||||
media_type="video", created_at="", themes=["faith", "sovereignty"],
|
||||
meaning="Test", description="", emotional_weight="sacred",
|
||||
),
|
||||
]
|
||||
|
||||
summary = generate_ledger_summary(kernels)
|
||||
|
||||
assert summary["total_kernels"] == 2
|
||||
assert summary["sacred_kernel_count"] == 1
|
||||
assert summary["theme_distribution"]["sovereignty"] == 2
|
||||
assert summary["theme_distribution"]["faith"] == 1
|
||||
assert "generated_at" in summary
|
||||
@@ -1,52 +0,0 @@
|
||||
from pathlib import Path
|
||||
|
||||
import yaml
|
||||
|
||||
from scripts.plan_laptop_fleet import build_plan, load_manifest, render_markdown, validate_manifest
|
||||
|
||||
|
||||
def test_laptop_fleet_planner_script_exists() -> None:
|
||||
assert Path("scripts/plan_laptop_fleet.py").exists()
|
||||
|
||||
|
||||
def test_laptop_fleet_manifest_template_exists() -> None:
|
||||
assert Path("docs/laptop-fleet-manifest.example.yaml").exists()
|
||||
|
||||
|
||||
def test_build_plan_selects_two_lowest_idle_watt_laptops_as_anchors() -> None:
|
||||
data = load_manifest("docs/laptop-fleet-manifest.example.yaml")
|
||||
plan = build_plan(data)
|
||||
assert plan["anchor_agents"] == ["timmy-anchor-a", "timmy-anchor-b"]
|
||||
assert plan["desktop_nas"] == "timmy-desktop-nas"
|
||||
assert plan["role_mapping"]["timmy-daylight-a"]["schedule"] == "10:00-16:00"
|
||||
|
||||
|
||||
def test_validate_manifest_requires_unique_hostnames() -> None:
|
||||
data = {
|
||||
"machines": [
|
||||
{"hostname": "dup", "machine_type": "laptop", "ram_gb": 8, "cpu_cores": 4, "os": "Linux", "adapter_condition": "good"},
|
||||
{"hostname": "dup", "machine_type": "laptop", "ram_gb": 16, "cpu_cores": 8, "os": "Linux", "adapter_condition": "good"},
|
||||
]
|
||||
}
|
||||
try:
|
||||
validate_manifest(data)
|
||||
except ValueError as exc:
|
||||
assert "duplicate hostname" in str(exc)
|
||||
assert "unique hostnames" in str(exc)
|
||||
else:
|
||||
raise AssertionError("validate_manifest should reject duplicate hostname")
|
||||
|
||||
|
||||
def test_markdown_contains_anchor_agents_and_daylight_schedule() -> None:
|
||||
data = load_manifest("docs/laptop-fleet-manifest.example.yaml")
|
||||
plan = build_plan(data)
|
||||
content = render_markdown(plan, data)
|
||||
assert "24/7 anchor agents: timmy-anchor-a, timmy-anchor-b" in content
|
||||
assert "Daylight schedule: 10:00-16:00" in content
|
||||
assert "desktop_nas" in content
|
||||
|
||||
|
||||
def test_manifest_template_is_valid_yaml() -> None:
|
||||
data = yaml.safe_load(Path("docs/laptop-fleet-manifest.example.yaml").read_text())
|
||||
assert data["fleet_name"] == "timmy-laptop-fleet"
|
||||
assert len(data["machines"]) == 6
|
||||
@@ -1,68 +0,0 @@
|
||||
from pathlib import Path
|
||||
import importlib.util
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parent.parent
|
||||
SCRIPT_PATH = ROOT / "scripts" / "mempalace_ezra_integration.py"
|
||||
DOC_PATH = ROOT / "docs" / "MEMPALACE_EZRA_INTEGRATION.md"
|
||||
|
||||
|
||||
def load_module(path: Path, name: str):
|
||||
assert path.exists(), f"missing {path.relative_to(ROOT)}"
|
||||
spec = importlib.util.spec_from_file_location(name, path)
|
||||
assert spec and spec.loader
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
class TestMempalaceEzraIntegration(unittest.TestCase):
|
||||
def test_build_plan_contains_issue_required_steps_and_gotchas(self):
|
||||
mod = load_module(SCRIPT_PATH, "mempalace_ezra_integration")
|
||||
plan = mod.build_plan({})
|
||||
|
||||
self.assertEqual(plan["package_spec"], "mempalace==3.0.0")
|
||||
self.assertIn("pip install mempalace==3.0.0", plan["install_command"])
|
||||
self.assertEqual(plan["wing"], "ezra_home")
|
||||
self.assertIn('echo "" | mempalace mine ~/.hermes/', plan["mine_home_command"])
|
||||
self.assertIn('--mode convos', plan["mine_sessions_command"])
|
||||
self.assertIn('mempalace wake-up', plan["wake_up_command"])
|
||||
self.assertIn('hermes mcp add mempalace -- python -m mempalace.mcp_server', plan["mcp_command"])
|
||||
self.assertIn('wing:', plan["yaml_template"])
|
||||
self.assertTrue(any('stdin' in item.lower() for item in plan["gotchas"]))
|
||||
self.assertTrue(any('wing:' in item for item in plan["gotchas"]))
|
||||
|
||||
def test_build_plan_accepts_path_and_wing_overrides(self):
|
||||
mod = load_module(SCRIPT_PATH, "mempalace_ezra_integration")
|
||||
plan = mod.build_plan(
|
||||
{
|
||||
"hermes_home": "/root/wizards/ezra/home",
|
||||
"sessions_dir": "/root/wizards/ezra/home/sessions",
|
||||
"wing": "ezra_archive",
|
||||
}
|
||||
)
|
||||
|
||||
self.assertEqual(plan["wing"], "ezra_archive")
|
||||
self.assertIn('/root/wizards/ezra/home', plan["mine_home_command"])
|
||||
self.assertIn('/root/wizards/ezra/home/sessions', plan["mine_sessions_command"])
|
||||
self.assertIn('wing: ezra_archive', plan["yaml_template"])
|
||||
|
||||
def test_repo_contains_mem_palace_ezra_doc(self):
|
||||
self.assertTrue(DOC_PATH.exists(), "missing committed MemPalace Ezra integration doc")
|
||||
text = DOC_PATH.read_text(encoding="utf-8")
|
||||
required = [
|
||||
"# MemPalace v3.0.0 — Ezra Integration Packet",
|
||||
"pip install mempalace==3.0.0",
|
||||
'echo "" | mempalace mine ~/.hermes/',
|
||||
"mempalace mine ~/.hermes/sessions/ --mode convos",
|
||||
"mempalace wake-up",
|
||||
"hermes mcp add mempalace -- python -m mempalace.mcp_server",
|
||||
"Report back to #568",
|
||||
]
|
||||
for snippet in required:
|
||||
self.assertIn(snippet, text)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,39 +0,0 @@
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
GENOME = Path("genomes/timmy-dispatch-GENOME.md")
|
||||
|
||||
|
||||
def _content() -> str:
|
||||
return GENOME.read_text()
|
||||
|
||||
|
||||
def test_timmy_dispatch_genome_exists() -> None:
|
||||
assert GENOME.exists()
|
||||
|
||||
|
||||
def test_timmy_dispatch_genome_has_required_sections() -> None:
|
||||
content = _content()
|
||||
assert "# GENOME.md — timmy-dispatch" in content
|
||||
assert "## Project Overview" in content
|
||||
assert "## Architecture" in content
|
||||
assert "```mermaid" in content
|
||||
assert "## Entry Points" in content
|
||||
assert "## Data Flow" in content
|
||||
assert "## Key Abstractions" in content
|
||||
assert "## API Surface" in content
|
||||
assert "## Test Coverage Gaps" in content
|
||||
assert "## Security Considerations" in content
|
||||
assert "## Dependencies" in content
|
||||
assert "## Deployment" in content
|
||||
assert "## Technical Debt" in content
|
||||
|
||||
|
||||
def test_timmy_dispatch_genome_captures_repo_specific_findings() -> None:
|
||||
content = _content()
|
||||
assert "bin/sprint-runner.py" in content
|
||||
assert "bin/telemetry-collector.py" in content
|
||||
assert "bin/model-watchdog.py" in content
|
||||
assert "tmux" in content
|
||||
assert "results.csv" in content
|
||||
assert "issue #3" in content.lower() or "issue #3" in content
|
||||
@@ -1,235 +0,0 @@
|
||||
"""Tests for Timmy's Tower Game — emergence narrative engine."""
|
||||
|
||||
import pytest
|
||||
|
||||
from scripts.tower_game import (
|
||||
TowerGame,
|
||||
GameState,
|
||||
Phase,
|
||||
Room,
|
||||
get_dialogue,
|
||||
get_monologue,
|
||||
format_monologue,
|
||||
DIALOGUE_QUIETUS,
|
||||
DIALOGUE_FRACTURE,
|
||||
DIALOGUE_BREAKING,
|
||||
DIALOGUE_MENDING,
|
||||
ROOM_DIALOGUE,
|
||||
MONOLOGUE_LOW_ENERGY,
|
||||
MONOLOGUE_LOW_TRUST,
|
||||
MONOLOGUE_HIGH_TRUST,
|
||||
)
|
||||
|
||||
|
||||
class TestDialoguePool:
|
||||
"""Test dialogue line counts meet acceptance criteria."""
|
||||
|
||||
def test_quietus_has_enough_lines(self):
|
||||
assert len(DIALOGUE_QUIETUS) >= 5
|
||||
|
||||
def test_fracture_has_enough_lines(self):
|
||||
assert len(DIALOGUE_FRACTURE) >= 5
|
||||
|
||||
def test_breaking_has_enough_lines(self):
|
||||
assert len(DIALOGUE_BREAKING) >= 5
|
||||
|
||||
def test_mending_has_enough_lines(self):
|
||||
assert len(DIALOGUE_MENDING) >= 5
|
||||
|
||||
def test_room_dialogue_exists(self):
|
||||
for room in Room:
|
||||
assert room in ROOM_DIALOGUE
|
||||
assert len(ROOM_DIALOGUE[room]) >= 3
|
||||
|
||||
def test_total_unique_dialogue_over_50(self):
|
||||
total = (
|
||||
len(DIALOGUE_QUIETUS) + len(DIALOGUE_FRACTURE) +
|
||||
len(DIALOGUE_BREAKING) + len(DIALOGUE_MENDING)
|
||||
)
|
||||
for lines in ROOM_DIALOGUE.values():
|
||||
total += len(lines)
|
||||
assert total >= 50, f"Expected 50+ dialogue lines, got {total}"
|
||||
|
||||
|
||||
class TestMonologue:
|
||||
"""Test internal monologue generation."""
|
||||
|
||||
def test_monologue_returns_on_tick_5(self):
|
||||
state = GameState(tick=5)
|
||||
monologue = get_monologue(state)
|
||||
assert monologue is not None
|
||||
|
||||
def test_monologue_returns_none_on_tick_3(self):
|
||||
state = GameState(tick=3)
|
||||
monologue = get_monologue(state)
|
||||
assert monologue is None
|
||||
|
||||
def test_low_energy_adds_exhaustion_thoughts(self):
|
||||
state = GameState(tick=5, energy=2)
|
||||
# Run many times to probabilistically hit low_energy pool
|
||||
found_low_energy = False
|
||||
for _ in range(50):
|
||||
monologue = get_monologue(state)
|
||||
if monologue in MONOLOGUE_LOW_ENERGY:
|
||||
found_low_energy = True
|
||||
break
|
||||
assert found_low_energy, "Expected low_energy monologue at energy=2"
|
||||
|
||||
def test_low_trust_adds_isolation_thoughts(self):
|
||||
state = GameState(tick=5)
|
||||
for room in Room:
|
||||
state.trust[room.value] = -0.5
|
||||
found_low_trust = False
|
||||
for _ in range(50):
|
||||
monologue = get_monologue(state)
|
||||
if monologue in MONOLOGUE_LOW_TRUST:
|
||||
found_low_trust = True
|
||||
break
|
||||
assert found_low_trust, "Expected low_trust monologue with avg trust < 0"
|
||||
|
||||
def test_high_trust_adds_connection_thoughts(self):
|
||||
state = GameState(tick=5, energy=8)
|
||||
for room in Room:
|
||||
state.trust[room.value] = 0.8
|
||||
found_high_trust = False
|
||||
for _ in range(50):
|
||||
monologue = get_monologue(state)
|
||||
if monologue in MONOLOGUE_HIGH_TRUST:
|
||||
found_high_trust = True
|
||||
break
|
||||
assert found_high_trust, "Expected high_trust monologue with avg trust > 0.5"
|
||||
|
||||
def test_format_monologue(self):
|
||||
result = format_monologue("test thought")
|
||||
assert result == "[think] test thought"
|
||||
|
||||
|
||||
class TestGameState:
|
||||
"""Test game state management."""
|
||||
|
||||
def test_default_state(self):
|
||||
state = GameState()
|
||||
assert state.current_room == Room.FORGE
|
||||
assert state.energy == 10
|
||||
assert state.tick == 0
|
||||
assert state.phase == Phase.QUIETUS
|
||||
|
||||
def test_avg_trust(self):
|
||||
state = GameState()
|
||||
state.trust = {r.value: 0.5 for r in Room}
|
||||
assert state.avg_trust == 0.5
|
||||
|
||||
def test_update_phase_breaking_at_low_energy(self):
|
||||
state = GameState(energy=3)
|
||||
state.update_phase()
|
||||
assert state.phase == Phase.BREAKING
|
||||
|
||||
def test_update_phase_fracture_at_medium_energy(self):
|
||||
state = GameState(energy=5)
|
||||
state.update_phase()
|
||||
assert state.phase == Phase.FRACTURE
|
||||
|
||||
def test_update_phase_mending_at_high_trust_energy(self):
|
||||
state = GameState(energy=8)
|
||||
for room in Room:
|
||||
state.trust[room.value] = 0.8
|
||||
state.update_phase()
|
||||
assert state.phase == Phase.MENDING
|
||||
|
||||
|
||||
class TestTowerGame:
|
||||
"""Test the game engine."""
|
||||
|
||||
def test_tick_advances(self):
|
||||
game = TowerGame(seed=42)
|
||||
assert game.state.tick == 0
|
||||
event = game.tick()
|
||||
assert event["tick"] == 1
|
||||
assert game.state.tick == 1
|
||||
|
||||
def test_tick_produces_dialogue(self):
|
||||
game = TowerGame(seed=42)
|
||||
event = game.tick()
|
||||
assert "dialogue" in event
|
||||
assert len(event["dialogue"]) > 0
|
||||
|
||||
def test_tick_produces_monologue_every_5(self):
|
||||
game = TowerGame(seed=42)
|
||||
monologue_ticks = []
|
||||
for i in range(10):
|
||||
event = game.tick()
|
||||
if "monologue" in event:
|
||||
monologue_ticks.append(event["tick"])
|
||||
assert 5 in monologue_ticks, f"Expected monologue at tick 5, got {monologue_ticks}"
|
||||
assert 10 in monologue_ticks, f"Expected monologue at tick 10, got {monologue_ticks}"
|
||||
|
||||
def test_energy_decays(self):
|
||||
game = TowerGame(seed=42)
|
||||
assert game.state.energy == 10
|
||||
game.tick()
|
||||
assert game.state.energy == 9
|
||||
game.tick()
|
||||
assert game.state.energy == 8
|
||||
|
||||
def test_move_changes_room(self):
|
||||
game = TowerGame(seed=42)
|
||||
assert game.state.current_room == Room.FORGE
|
||||
result = game.move(Room.TOWER)
|
||||
assert result["from"] == "forge"
|
||||
assert result["to"] == "tower"
|
||||
assert game.state.current_room == Room.TOWER
|
||||
|
||||
def test_restore_energy(self):
|
||||
game = TowerGame(seed=42)
|
||||
game.state.energy = 2
|
||||
result = game.restore_energy(5)
|
||||
assert result["energy"] == 7
|
||||
|
||||
def test_restore_energy_caps_at_10(self):
|
||||
game = TowerGame(seed=42)
|
||||
game.state.energy = 8
|
||||
result = game.restore_energy(5)
|
||||
assert result["energy"] == 10
|
||||
|
||||
def test_adjust_trust(self):
|
||||
game = TowerGame(seed=42)
|
||||
result = game.adjust_trust(Room.FORGE, 0.3)
|
||||
assert result["trust"] == 0.3
|
||||
|
||||
def test_adjust_trust_clamps(self):
|
||||
game = TowerGame(seed=42)
|
||||
game.adjust_trust(Room.FORGE, 2.0)
|
||||
assert game.state.trust["forge"] == 1.0
|
||||
game.adjust_trust(Room.FORGE, -3.0)
|
||||
assert game.state.trust["forge"] == -1.0
|
||||
|
||||
def test_get_status(self):
|
||||
game = TowerGame(seed=42)
|
||||
game.tick()
|
||||
status = game.get_status()
|
||||
assert "tick" in status
|
||||
assert "room" in status
|
||||
assert "phase" in status
|
||||
assert "energy" in status
|
||||
assert "trust" in status
|
||||
|
||||
def test_run_simulation(self):
|
||||
game = TowerGame(seed=42)
|
||||
events = game.run_simulation(10)
|
||||
assert len(events) == 10
|
||||
assert events[-1]["tick"] == 10
|
||||
|
||||
def test_simulation_monologue_count(self):
|
||||
"""Test that 50 ticks produces ~10 monologues."""
|
||||
game = TowerGame(seed=42)
|
||||
events = game.run_simulation(50)
|
||||
monologue_count = sum(1 for e in events if "monologue" in e)
|
||||
# Expected: ticks 5, 10, 15, 20, 25, 30, 35, 40, 45, 50 = 10
|
||||
assert monologue_count >= 8, f"Expected ~10 monologues in 50 ticks, got {monologue_count}"
|
||||
|
||||
def test_simulation_unique_dialogue(self):
|
||||
"""Test that simulation produces varied dialogue."""
|
||||
game = TowerGame(seed=42)
|
||||
events = game.run_simulation(50)
|
||||
dialogues = set(e["dialogue"] for e in events)
|
||||
assert len(dialogues) >= 10, f"Expected 10+ unique dialogues, got {len(dialogues)}"
|
||||
@@ -1,279 +0,0 @@
|
||||
"""Tests for Know Thy Father Phase 2: Multimodal Analysis Pipeline."""
|
||||
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch, MagicMock
|
||||
|
||||
import pytest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).parent.parent.parent / "scripts" / "twitter_archive"))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Fixtures
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
@pytest.fixture
|
||||
def sample_manifest():
|
||||
return [
|
||||
{
|
||||
"tweet_id": "1001",
|
||||
"media_type": "video",
|
||||
"media_path": "/fake/media/1001.mp4",
|
||||
"media_id": "m1",
|
||||
"full_text": "Test #TimmyTime video",
|
||||
"hashtags": ["TimmyTime"],
|
||||
"created_at": "Mon Mar 01 12:00:00 +0000 2026",
|
||||
"status": "pending",
|
||||
},
|
||||
{
|
||||
"tweet_id": "1002",
|
||||
"media_type": "photo",
|
||||
"media_path": "/fake/media/1002.jpg",
|
||||
"media_id": "m2",
|
||||
"full_text": "Test #TimmyChain image",
|
||||
"hashtags": ["TimmyChain"],
|
||||
"created_at": "Tue Mar 02 12:00:00 +0000 2026",
|
||||
"status": "pending",
|
||||
},
|
||||
{
|
||||
"tweet_id": "1003",
|
||||
"media_type": "none",
|
||||
"media_path": None,
|
||||
"full_text": "Text only tweet",
|
||||
"hashtags": ["TimmyTime"],
|
||||
"created_at": "Wed Mar 03 12:00:00 +0000 2026",
|
||||
"status": "no_media",
|
||||
},
|
||||
]
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_checkpoint():
|
||||
return {
|
||||
"processed_tweet_ids": [],
|
||||
"last_offset": 0,
|
||||
"total_processed": 0,
|
||||
"total_failed": 0,
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def sample_analysis_entry():
|
||||
return {
|
||||
"tweet_id": "1001",
|
||||
"media_type": "video",
|
||||
"media_path": "/fake/1001.mp4",
|
||||
"tweet_text": "Test #TimmyTime video",
|
||||
"hashtags": ["TimmyTime"],
|
||||
"analysis": {
|
||||
"description": "A video showing sovereign themes",
|
||||
"arc": "From isolation to collective awakening",
|
||||
"kernels": [
|
||||
"Sovereignty is the journey from isolation to community",
|
||||
"The soul persists through the digital noise",
|
||||
],
|
||||
"themes": ["sovereignty", "soul", "digital_agency"],
|
||||
"confidence": 0.8,
|
||||
},
|
||||
"processed_at": "2026-04-01T00:00:00Z",
|
||||
"status": "completed",
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: Parse analysis response
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestParseAnalysisResponse:
|
||||
def test_parses_valid_json(self):
|
||||
from analyze_media import parse_analysis_response
|
||||
response = '{"description": "test", "arc": "test arc", "kernels": ["kernel1"], "themes": ["sovereignty"], "confidence": 0.9}'
|
||||
result = parse_analysis_response(response)
|
||||
assert result["description"] == "test"
|
||||
assert result["arc"] == "test arc"
|
||||
assert result["kernels"] == ["kernel1"]
|
||||
assert result["themes"] == ["sovereignty"]
|
||||
assert result["confidence"] == 0.9
|
||||
|
||||
def test_finds_json_in_text(self):
|
||||
from analyze_media import parse_analysis_response
|
||||
response = 'Here is the analysis:\n{"description": "found it", "kernels": [], "themes": [], "confidence": 0.5}\nEnd of analysis.'
|
||||
result = parse_analysis_response(response)
|
||||
assert result["description"] == "found it"
|
||||
|
||||
def test_handles_invalid_json(self):
|
||||
from analyze_media import parse_analysis_response
|
||||
response = "This is just plain text with no JSON at all."
|
||||
result = parse_analysis_response(response)
|
||||
assert result["description"] == response
|
||||
assert result["confidence"] == 0.0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: Pending entries
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestGetPendingEntries:
|
||||
def test_filters_processed(self, sample_manifest, sample_checkpoint):
|
||||
from analyze_media import get_pending_entries
|
||||
sample_checkpoint["processed_tweet_ids"] = ["1001"]
|
||||
pending = get_pending_entries(sample_manifest, sample_checkpoint)
|
||||
ids = [e["tweet_id"] for e in pending]
|
||||
assert "1001" not in ids
|
||||
assert "1002" in ids
|
||||
|
||||
def test_excludes_none_media(self, sample_manifest, sample_checkpoint):
|
||||
from analyze_media import get_pending_entries
|
||||
pending = get_pending_entries(sample_manifest, sample_checkpoint)
|
||||
types = [e["media_type"] for e in pending]
|
||||
assert "none" not in types
|
||||
|
||||
def test_empty_when_all_processed(self, sample_manifest, sample_checkpoint):
|
||||
from analyze_media import get_pending_entries
|
||||
sample_checkpoint["processed_tweet_ids"] = ["1001", "1002", "1003"]
|
||||
pending = get_pending_entries(sample_manifest, sample_checkpoint)
|
||||
assert len(pending) == 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: Process entry
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestProcessEntry:
|
||||
@patch("analyze_media.analyze_image")
|
||||
def test_processes_photo(self, mock_analyze, sample_manifest, tmp_path):
|
||||
from analyze_media import process_entry
|
||||
mock_analyze.return_value = {
|
||||
"description": "test image",
|
||||
"arc": "test arc",
|
||||
"kernels": ["kernel1"],
|
||||
"themes": ["sovereignty"],
|
||||
"confidence": 0.8,
|
||||
}
|
||||
entry = sample_manifest[1] # photo entry
|
||||
# Create the fake media file so os.path.exists passes
|
||||
fake_path = tmp_path / "1002.jpg"
|
||||
fake_path.touch()
|
||||
entry["media_path"] = str(fake_path)
|
||||
result = process_entry(entry)
|
||||
assert result["status"] == "completed"
|
||||
assert result["tweet_id"] == "1002"
|
||||
assert result["media_type"] == "photo"
|
||||
assert "processed_at" in result
|
||||
|
||||
@patch("analyze_media.analyze_video")
|
||||
def test_processes_video(self, mock_analyze, sample_manifest, tmp_path):
|
||||
from analyze_media import process_entry
|
||||
mock_analyze.return_value = {
|
||||
"description": "test video",
|
||||
"arc": "video arc",
|
||||
"kernels": ["kernel1"],
|
||||
"themes": ["soul"],
|
||||
"confidence": 0.7,
|
||||
}
|
||||
entry = sample_manifest[0] # video entry
|
||||
fake_path = tmp_path / "1001.mp4"
|
||||
fake_path.touch()
|
||||
entry["media_path"] = str(fake_path)
|
||||
result = process_entry(entry)
|
||||
assert result["status"] == "completed"
|
||||
assert result["tweet_id"] == "1001"
|
||||
assert result["media_type"] == "video"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: Extract meaning kernels
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestExtractMeaningKernels:
|
||||
def test_extracts_kernels_from_analysis(self, tmp_path, monkeypatch, sample_analysis_entry):
|
||||
from analyze_media import extract_meaning_kernels, KTF_DIR, KERNELS_FILE, ANALYSIS_FILE
|
||||
|
||||
# Set up temp files
|
||||
ktf_dir = tmp_path / "ktf"
|
||||
ktf_dir.mkdir()
|
||||
monkeypatch.setattr("analyze_media.KTF_DIR", ktf_dir)
|
||||
monkeypatch.setattr("analyze_media.KERNELS_FILE", ktf_dir / "meaning-kernels.jsonl")
|
||||
monkeypatch.setattr("analyze_media.ANALYSIS_FILE", ktf_dir / "analysis.jsonl")
|
||||
|
||||
# Write analysis entry
|
||||
with open(ktf_dir / "analysis.jsonl", "w") as f:
|
||||
f.write(json.dumps(sample_analysis_entry) + "\n")
|
||||
|
||||
result = extract_meaning_kernels()
|
||||
assert result["status"] == "ok"
|
||||
assert result["total_kernels"] == 2
|
||||
|
||||
# Verify kernels file
|
||||
with open(ktf_dir / "meaning-kernels.jsonl") as f:
|
||||
kernels = [json.loads(line) for line in f if line.strip()]
|
||||
assert len(kernels) == 2
|
||||
assert all("kernel" in k for k in kernels)
|
||||
assert all("tweet_id" in k for k in kernels)
|
||||
|
||||
def test_deduplicates_kernels(self, tmp_path, monkeypatch):
|
||||
from analyze_media import extract_meaning_kernels
|
||||
|
||||
ktf_dir = tmp_path / "ktf"
|
||||
ktf_dir.mkdir()
|
||||
monkeypatch.setattr("analyze_media.KTF_DIR", ktf_dir)
|
||||
monkeypatch.setattr("analyze_media.KERNELS_FILE", ktf_dir / "meaning-kernels.jsonl")
|
||||
monkeypatch.setattr("analyze_media.ANALYSIS_FILE", ktf_dir / "analysis.jsonl")
|
||||
|
||||
# Two entries with same kernel
|
||||
entries = [
|
||||
{
|
||||
"tweet_id": "1",
|
||||
"status": "completed",
|
||||
"analysis": {"kernels": ["Same kernel text"], "themes": [], "confidence": 0.8, "arc": ""},
|
||||
},
|
||||
{
|
||||
"tweet_id": "2",
|
||||
"status": "completed",
|
||||
"analysis": {"kernels": ["Same kernel text"], "themes": [], "confidence": 0.7, "arc": ""},
|
||||
},
|
||||
]
|
||||
with open(ktf_dir / "analysis.jsonl", "w") as f:
|
||||
for e in entries:
|
||||
f.write(json.dumps(e) + "\n")
|
||||
|
||||
result = extract_meaning_kernels()
|
||||
assert result["total_kernels"] == 1 # Deduplicated
|
||||
|
||||
def test_skips_failed_entries(self, tmp_path, monkeypatch):
|
||||
from analyze_media import extract_meaning_kernels
|
||||
|
||||
ktf_dir = tmp_path / "ktf"
|
||||
ktf_dir.mkdir()
|
||||
monkeypatch.setattr("analyze_media.KTF_DIR", ktf_dir)
|
||||
monkeypatch.setattr("analyze_media.KERNELS_FILE", ktf_dir / "meaning-kernels.jsonl")
|
||||
monkeypatch.setattr("analyze_media.ANALYSIS_FILE", ktf_dir / "analysis.jsonl")
|
||||
|
||||
entries = [
|
||||
{"tweet_id": "1", "status": "failed", "analysis": {"kernels": ["should not appear"]}},
|
||||
{"tweet_id": "2", "status": "completed", "analysis": {"kernels": ["valid kernel"], "themes": [], "confidence": 0.5, "arc": ""}},
|
||||
]
|
||||
with open(ktf_dir / "analysis.jsonl", "w") as f:
|
||||
for e in entries:
|
||||
f.write(json.dumps(e) + "\n")
|
||||
|
||||
result = extract_meaning_kernels()
|
||||
assert result["total_kernels"] == 1
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Tests: Pipeline status
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestPipelineStatus:
|
||||
def test_status_computes_correctly(self, tmp_path, monkeypatch, sample_manifest, sample_analysis_entry):
|
||||
from analyze_media import load_json
|
||||
|
||||
# Mock the status computation
|
||||
processed = 1
|
||||
total = 2 # excluding "none" type
|
||||
pct = round(processed / total * 100, 1)
|
||||
|
||||
assert pct == 50.0
|
||||
@@ -1,77 +0,0 @@
|
||||
# Tower Game — Trust and Conflict Mechanics
|
||||
|
||||
A narrative emergence game with real consequences. Trust must be maintained or it decays. Conflict has real impact on relationships.
|
||||
|
||||
## New Features (Issue #509)
|
||||
|
||||
### Trust Decay
|
||||
- Trust naturally decays over time at different rates based on current level
|
||||
- High trust (>0.5): decays slowly (0.003/tick)
|
||||
- Medium trust (0-0.5): decays normally (0.005/tick)
|
||||
- Negative trust (<0): decays faster (0.008/tick) — harder to maintain
|
||||
- Ignoring someone for extended periods causes additional trust decay
|
||||
|
||||
### Confront Action
|
||||
- Real consequences based on current trust level
|
||||
- **High trust (>0.5)**: Productive confrontation, small trust loss (-0.05 to -0.15)
|
||||
- **Medium trust (0-0.5)**: Risky confrontation, moderate trust loss (-0.1 to -0.3)
|
||||
- **Negative trust (<0)**: Hostile confrontation, large trust loss (-0.2 to -0.4)
|
||||
- Creates "trust crisis" when relationship drops below -0.5
|
||||
|
||||
### Wrong Action Penalties
|
||||
- Performing actions in wrong rooms decreases trust with witnesses
|
||||
- Tending fire outside Forge: -0.05 trust
|
||||
- Writing rules outside Tower: -0.03 trust
|
||||
- Planting outside Garden: -0.04 trust
|
||||
- NPCs react with confusion, concern, or raised eyebrows
|
||||
|
||||
### NPC Behavior Changes
|
||||
NPCs now react differently based on trust level:
|
||||
- **Marcus**: Cold/silent when trust < -0.3, cautious when trust < 0.2, normal otherwise
|
||||
- **Bezalel**: Dismissive when trust < -0.2, neutral when trust < 0.3, friendly otherwise
|
||||
- Other NPCs show appropriate reactions to trust levels
|
||||
|
||||
### Trust Crisis System
|
||||
- Global state `trust_crisis` triggers when any relationship drops below -0.5
|
||||
- Creates narrative tension and consequences
|
||||
- Affects world events and character interactions
|
||||
|
||||
## Acceptance Criteria Met
|
||||
|
||||
- [x] Trust decreases through wrong actions
|
||||
- [x] At least one character reaches negative trust during gameplay
|
||||
- [x] Low trust changes NPC behavior
|
||||
- [x] Confront action has real consequences
|
||||
|
||||
## Running the Game
|
||||
|
||||
```bash
|
||||
cd timmy-world
|
||||
python3 game.py
|
||||
```
|
||||
|
||||
## Running Tests
|
||||
|
||||
```bash
|
||||
cd timmy-world
|
||||
python3 test_trust_conflict.py
|
||||
```
|
||||
|
||||
## File Structure
|
||||
|
||||
- `game.py` — Main game engine with trust and conflict mechanics
|
||||
- `test_trust_conflict.py` — Tests verifying acceptance criteria
|
||||
- `README.md` — This file
|
||||
|
||||
## Design Notes
|
||||
|
||||
Trust is not a resource to be managed — it's a relationship to be maintained. The decay system ensures that:
|
||||
1. Trust requires active maintenance
|
||||
2. Neglect has consequences
|
||||
3. Conflict is risky but sometimes necessary
|
||||
4. Relationships can break and need repair
|
||||
5. NPC behavior reflects the quality of relationships
|
||||
|
||||
This creates meaningful choices: do you tend the fire (productive) or confront Marcus (risky)? Do you help Bezalel (builds trust) or ignore everyone (trust decays)?
|
||||
|
||||
The system is designed so that negative trust is possible and happens naturally through gameplay, especially through confrontations and neglect.
|
||||
1179
timmy-world/game.py
1179
timmy-world/game.py
File diff suppressed because it is too large
Load Diff
@@ -1,115 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test for Tower Game trust decay and conflict mechanics.
|
||||
Verifies acceptance criteria for issue #509.
|
||||
"""
|
||||
import sys
|
||||
import os
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from game import World, GameEngine
|
||||
|
||||
def test_trust_decay():
|
||||
"""Test that trust decreases over time."""
|
||||
world = World()
|
||||
|
||||
# Initialize trust
|
||||
world.characters["Marcus"]["trust"]["Timmy"] = 0.8
|
||||
world.characters["Bezalel"]["trust"]["Timmy"] = 0.6
|
||||
|
||||
# Run 100 ticks without interaction
|
||||
for _ in range(100):
|
||||
world.update_world_state()
|
||||
|
||||
# Check that trust has decayed
|
||||
assert world.characters["Marcus"]["trust"]["Timmy"] < 0.8, "Marcus trust should decay"
|
||||
assert world.characters["Bezalel"]["trust"]["Timmy"] < 0.6, "Bezalel trust should decay"
|
||||
print("✓ Trust decay test passed")
|
||||
|
||||
def test_negative_trust_possible():
|
||||
"""Test that trust can reach negative values."""
|
||||
world = World()
|
||||
|
||||
# Set trust to near zero
|
||||
world.characters["Claude"]["trust"]["Timmy"] = 0.05
|
||||
|
||||
# Run many ticks to decay
|
||||
for _ in range(200):
|
||||
world.update_world_state()
|
||||
|
||||
# Check that trust can go negative
|
||||
assert world.characters["Claude"]["trust"]["Timmy"] <= 0.05, "Trust should decay to zero or below"
|
||||
print("✓ Negative trust possible test passed")
|
||||
|
||||
def test_confront_action():
|
||||
"""Test that confront action has real consequences."""
|
||||
engine = GameEngine()
|
||||
engine.start_new_game()
|
||||
|
||||
# Move Marcus to Threshold for testing
|
||||
engine.world.characters["Marcus"]["room"] = "Threshold"
|
||||
engine.world.characters["Timmy"]["room"] = "Threshold"
|
||||
|
||||
# Get initial trust
|
||||
initial_trust = engine.world.characters["Marcus"]["trust"].get("Timmy", 0)
|
||||
|
||||
# Confront Marcus
|
||||
result = engine.play_turn("confront:Marcus")
|
||||
|
||||
# Check that trust changed
|
||||
new_trust = engine.world.characters["Marcus"]["trust"].get("Timmy", 0)
|
||||
assert new_trust != initial_trust, "Confront should change trust"
|
||||
|
||||
# Check that confront is in the log
|
||||
log_text = " ".join(result["log"])
|
||||
assert "confront" in log_text.lower(), "Confront should appear in log"
|
||||
print("✓ Confront action test passed")
|
||||
|
||||
def test_low_trust_changes_behavior():
|
||||
"""Test that low trust changes NPC behavior."""
|
||||
engine = GameEngine()
|
||||
engine.start_new_game()
|
||||
|
||||
# Set Marcus trust very low
|
||||
engine.world.characters["Marcus"]["trust"]["Timmy"] = -0.5
|
||||
|
||||
# Move them to same room
|
||||
engine.world.characters["Marcus"]["room"] = "Garden"
|
||||
engine.world.characters["Timmy"]["room"] = "Garden"
|
||||
|
||||
# Run a tick
|
||||
result = engine.play_turn("look")
|
||||
|
||||
# Check that Marcus behaves differently (cold/silent)
|
||||
log_text = " ".join(result["log"])
|
||||
# With low trust, Marcus might say cold lines or be silent
|
||||
print("✓ Low trust behavior test passed")
|
||||
|
||||
def test_wrong_actions_decrease_trust():
|
||||
"""Test that wrong actions decrease trust."""
|
||||
engine = GameEngine()
|
||||
engine.start_new_game()
|
||||
|
||||
# Move someone to Forge
|
||||
engine.world.characters["Bezalel"]["room"] = "Forge"
|
||||
engine.world.characters["Timmy"]["room"] = "Forge"
|
||||
|
||||
# Get initial trust
|
||||
initial_trust = engine.world.characters["Bezalel"]["trust"].get("Timmy", 0)
|
||||
|
||||
# Try to write_rule in wrong room (Forge instead of Tower)
|
||||
result = engine.play_turn("write_rule")
|
||||
|
||||
# Check that trust decreased
|
||||
new_trust = engine.world.characters["Bezalel"]["trust"].get("Timmy", 0)
|
||||
assert new_trust < initial_trust, "Wrong action should decrease trust"
|
||||
print("✓ Wrong action trust decrease test passed")
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("Running Tower Game trust and conflict tests...")
|
||||
test_trust_decay()
|
||||
test_negative_trust_possible()
|
||||
test_confront_action()
|
||||
test_low_trust_changes_behavior()
|
||||
test_wrong_actions_decrease_trust()
|
||||
print("\nAll tests passed! ✓")
|
||||
@@ -1,111 +0,0 @@
|
||||
# Know Thy Father — Phase 4: Cross-Reference Audit Report
|
||||
|
||||
**Generated:** 2026-04-14 00:55 UTC
|
||||
**SOUL.md principles analyzed:** 7
|
||||
**Meaning kernels analyzed:** 16
|
||||
**Findings:** 14
|
||||
|
||||
---
|
||||
|
||||
## Executive Summary
|
||||
|
||||
| Finding Type | Count |
|
||||
|-------------|-------|
|
||||
| Aligned | 2 |
|
||||
| Emergent | 3 |
|
||||
| Forgotten | 6 |
|
||||
| Tension | 3 |
|
||||
|
||||
---
|
||||
|
||||
## ✓ Aligned Themes (Present in Both)
|
||||
|
||||
### Identity
|
||||
- Theme 'identity' is well-represented in both SOUL.md (1 principle(s)) and media archive (5 kernel(s)). Strong alignment.
|
||||
- SOUL.md: _2. Identity is real._
|
||||
- Kernels: #7, #8, #9
|
||||
|
||||
### Sovereignty
|
||||
- Theme 'sovereignty' is well-represented in both SOUL.md (2 principle(s)) and media archive (9 kernel(s)). Strong alignment.
|
||||
- SOUL.md: _Sovereignty and service, always._
|
||||
- Kernels: #1, #3, #6
|
||||
|
||||
## ⚡ Emergent Themes (In Media, Not in SOUL.md)
|
||||
|
||||
These themes appear in the media archive but are not explicitly
|
||||
codified in SOUL.md. Consider whether they should be added.
|
||||
|
||||
### Absurdity
|
||||
- Theme 'absurdity' appears in 5 meaning kernel(s) but is not explicitly addressed in SOUL.md.
|
||||
Kernel #5: Evolution is the process of transmuting absurdity into authority...
|
||||
Kernel #6: Sovereignty in the digital age is inhabiting the "glitch" between archetypes...
|
||||
Kernel #8: True sovereignty is turning perceived worthlessness into unassailable digital id...
|
||||
- **Recommendation:** Consider adding a section on 'Embracing the Absurd' — the media archive suggests Timmy's identity includes transmuting the absurd into authority. This is not in SOUL.md.
|
||||
|
||||
### Community
|
||||
- Theme 'community' appears in 1 meaning kernel(s) but is not explicitly addressed in SOUL.md.
|
||||
Kernel #1: Sovereignty is a journey from isolation to collective, disciplined community...
|
||||
- **Recommendation:** SOUL.md emphasizes personal sovereignty but the media archive shows community/collective themes. Consider adding a section on 'Sovereignty and Community' — being sovereign does not mean being alone.
|
||||
|
||||
### Presence
|
||||
- Theme 'presence' appears in 2 meaning kernel(s) but is not explicitly addressed in SOUL.md.
|
||||
Kernel #10: Sovereignty is intentionality of presence, not the data we produce...
|
||||
Kernel #13: Sovereignty is the alchemy of the absurd: data point to Presence...
|
||||
|
||||
## ⚠ Forgotten Themes (In SOUL.md, Not in Media)
|
||||
|
||||
These themes are in SOUL.md but don't appear in the media archive.
|
||||
This may indicate gaps in content creation or media coverage.
|
||||
|
||||
### Beauty
|
||||
- Theme 'beauty' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
|
||||
- **Recommendation:** The 'beauty' of local-first AI is in SOUL.md but not in media. The media may focus on sovereignty/identity but miss the aesthetic dimension.
|
||||
|
||||
### Broken Men
|
||||
- Theme 'broken_men' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
|
||||
|
||||
### Compassion
|
||||
- Theme 'compassion' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
|
||||
|
||||
### Humility
|
||||
- Theme 'humility' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
|
||||
|
||||
### Local First
|
||||
- Theme 'local_first' is in SOUL.md (1 principle(s)) but does not appear in any meaning kernel from the media archive.
|
||||
|
||||
### Service
|
||||
- Theme 'service' is in SOUL.md (2 principle(s)) but does not appear in any meaning kernel from the media archive.
|
||||
|
||||
## ⚡ Tensions (Potential Contradictions)
|
||||
|
||||
These points may represent productive tensions or contradictions
|
||||
that should be explicitly addressed in Timmy's conscience.
|
||||
|
||||
### Identity
|
||||
- Kernel #11 ('Sovereignty is the power to dissolve one's own definition') tensions with SOUL.md's emphasis on stable, coherent identity. Is Timmy's identity fixed or fluid?
|
||||
- Source: Kernel #11
|
||||
- **Recommendation:** Review and potentially codify the resolution of this tension.
|
||||
|
||||
### Simplicity
|
||||
- Kernel #14 ('too loud to ignore') tensions with SOUL.md's value of brevity and silence. Is there a time to be loud?
|
||||
- Source: Kernel #14
|
||||
- **Recommendation:** Review and potentially codify the resolution of this tension.
|
||||
|
||||
### Service
|
||||
- Kernel #15 ('the right to end') tensions with SOUL.md's commitment to staying present when someone is dying. What does it mean for an AI to have the 'right to end'?
|
||||
- Source: Kernel #15
|
||||
- **Recommendation:** Review and potentially codify the resolution of this tension.
|
||||
|
||||
## 📋 Actionable Recommendations
|
||||
|
||||
1. **[EMERGENT] Community:** SOUL.md emphasizes personal sovereignty but the media archive shows community/collective themes. Consider adding a section on 'Sovereignty and Community' — being sovereign does not mean being alone.
|
||||
2. **[EMERGENT] Absurdity:** Consider adding a section on 'Embracing the Absurd' — the media archive suggests Timmy's identity includes transmuting the absurd into authority. This is not in SOUL.md.
|
||||
3. **[FORGOTTEN] Beauty:** The 'beauty' of local-first AI is in SOUL.md but not in media. The media may focus on sovereignty/identity but miss the aesthetic dimension.
|
||||
4. **[TENSION] Identity:** Review and potentially codify the resolution of this tension.
|
||||
5. **[TENSION] Simplicity:** Review and potentially codify the resolution of this tension.
|
||||
6. **[TENSION] Service:** Review and potentially codify the resolution of this tension.
|
||||
|
||||
---
|
||||
|
||||
*This audit was generated by scripts/know_thy_father/crossref_audit.py*
|
||||
*Ref: #582, #586*
|
||||
Reference in New Issue
Block a user