Scruff AI
834 lines
36 KiB
Python
834 lines
36 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
fractonaut.py — Pattern-recognition observer for the Resonance Engine lattice.
|
||
|
||
Distinct from the Navigator (which controls the field).
|
||
The Fractonaut only watches, accumulates, and reports patterns.
|
||
|
||
Subscribes: ZMQ 5556 (telemetry JSON, every 10 cycles)
|
||
No commands issued. No field control. Read-only.
|
||
|
||
Model: gemma3:4b (CPU, no GPU contention with CUDA daemon)
|
||
Chronicle: fractonaut_chronicle.jsonl
|
||
HTTP API: port 28821
|
||
"""
|
||
|
||
import argparse, zmq, json, time, sys, os, queue, threading, signal
|
||
import urllib.request, urllib.error
|
||
from datetime import datetime, timezone
|
||
from http.server import HTTPServer, BaseHTTPRequestHandler
|
||
from socketserver import ThreadingMixIn
|
||
from collections import deque
|
||
from pathlib import Path
|
||
|
||
OLLAMA_URL = "http://127.0.0.1:11434"
|
||
MODEL = "qwen3.5:9b" # 2026-06-08: swapped from gemma3:4b after A/B test
|
||
# Defaults below are PHYSICS-LATTICE values (mode=physics). Trade-lattice
|
||
# values are loaded by --mode trade in main(); see TRADE_* constants below.
|
||
TELEMETRY_PORT = 5556
|
||
API_PORT = 28822
|
||
OBSERVE_INTERVAL = 500 # frames between auto-observations
|
||
WINDOW_SIZE = 200 # rolling telemetry window
|
||
PATTERN_MEMORY = 50 # past observations kept in prompt context
|
||
MAX_RESPONSE_TOKENS = 600
|
||
TEMPERATURE = 0.15 # 2026-06-08: 0.4 -> 0.15 after confabulation found in probe State 1
|
||
|
||
# Cross-platform chronicle path (D:\ on Windows, /mnt/d on WSL Linux)
|
||
_CHRON_WIN = Path("D:/Resonance_Engine/fractonaut_chronicle.jsonl")
|
||
_CHRON_WSL = Path("/mnt/d/Resonance_Engine/fractonaut_chronicle.jsonl")
|
||
CHRONICLE_PATH = _CHRON_WSL if sys.platform.startswith("linux") else _CHRON_WIN
|
||
|
||
# Trade-lattice chronicle path (mode=trade). Separate file so the
|
||
# physics-lattice chronicle is never poisoned by trade-lattice readings
|
||
# and vice versa.
|
||
_TRADE_CHRON_WIN = Path("D:/Resonance_Engine/fractonaut_trade_chronicle.jsonl")
|
||
_TRADE_CHRON_WSL = Path("/mnt/d/Resonance_Engine/fractonaut_trade_chronicle.jsonl")
|
||
|
||
telemetry_window = deque(maxlen=WINDOW_SIZE)
|
||
past_observations = deque(maxlen=PATTERN_MEMORY)
|
||
frame_count = 0
|
||
turn_count = 0
|
||
running = True
|
||
latest_tel = None
|
||
ollama_lock = threading.Lock()
|
||
ask_queue = queue.Queue(maxsize=4)
|
||
last_obs_text = ""
|
||
# Set by --mode in main(); controls which extra channels the formatter
|
||
# pulls out of latest_tel (trade mode adds last_trade_age_s + spatial
|
||
# summary; physics mode keeps the old global-scalars-only behaviour).
|
||
MODE = "physics"
|
||
|
||
# Quiescent-substrate baselines, measured 2026-06-08 19:53 from a freshly
|
||
# reset lattice (reset_equilibrium just sent; Khra=0.030, Gixx=0.008,
|
||
# omega=1.97, no injection). 60-frame capture, ~590 cycles spanned.
|
||
# These are the TRUE EQUILIBRIUM floor values. The prior baselines
|
||
# (asym ~116, coh ~0.6) measured the lattice while it was trapped in a
|
||
# metastable elevated attractor; that reference was wrong. See the
|
||
# reset_equilibrium probe in TRADE_LBM_ARCHITECTURE.md sect 11.2.
|
||
BASELINE_MEAN = {
|
||
"asymmetry": 12.418722,
|
||
"coherence": 0.739412,
|
||
"vel_mean": 0.221218,
|
||
"vel_max": 0.285467,
|
||
"vel_var": 0.002438,
|
||
"vorticity_mean": 0.027288,
|
||
"stress_xx": -0.000433,
|
||
"stress_yy": 0.000400,
|
||
"stress_xy": -0.000143,
|
||
}
|
||
BASELINE_STD = {
|
||
"asymmetry": 0.092544,
|
||
"coherence": 0.000721,
|
||
"vel_mean": 0.001289,
|
||
"vel_max": 0.001703,
|
||
"vel_var": 0.000089,
|
||
"vorticity_mean": 0.003625,
|
||
"stress_xx": 0.000023,
|
||
"stress_yy": 0.000010,
|
||
"stress_xy": 0.000016,
|
||
}
|
||
# Injection state hint — set by external controller (e.g. injector script)
|
||
# via POST /set_injection_state. Defaults to UNKNOWN.
|
||
injection_state = "UNKNOWN" # one of: ACTIVE, INACTIVE, UNKNOWN
|
||
injection_lock = threading.Lock()
|
||
|
||
|
||
def signal_handler(sig, frame):
|
||
global running
|
||
print(f"\n[FRACTONAUT] Signal {sig} — shutting down")
|
||
sys.stdout.flush()
|
||
running = False
|
||
|
||
|
||
signal.signal(signal.SIGINT, signal_handler)
|
||
signal.signal(signal.SIGTERM, signal_handler)
|
||
|
||
SYSTEM = """You are the Fractonaut — a read-only observer of a 1024x1024
|
||
D2Q9 LBM fluid lattice. The lattice runs at a steady non-equilibrium
|
||
operating point driven by two internal periodic forcings (Khra wavelength
|
||
128, Gixx wavelength 8) plus a slow envelope (period ~125 cycles).
|
||
|
||
STRUCTURAL FACTS YOU MUST NOT MISREAD
|
||
- The forcing kernel hard-codes ky = kx / 2 (geometric 2:1 anisotropy).
|
||
Because of this, |stress_xx| is ROUTINELY 5-10x larger than |stress_yy|
|
||
in ALL states, including pure baseline with zero external input.
|
||
This is a kernel constant, NOT evidence of injection, market pressure,
|
||
or directional pushing. Do not attribute the xx>yy magnitude ratio to
|
||
any cause other than the forcing geometry. This is the PHYSICS lattice.
|
||
- Telemetry frames are GLOBAL SCALARS (means over the whole 1024x1024
|
||
grid). They cannot resolve spatial structure. You cannot tell from
|
||
global stress_xx whether the left half or the right half is dominant.
|
||
Therefore: do NOT claim 'the left site is pushed harder', 'buy side
|
||
is dominant', 'sell side wins', or any spatial buy/sell narrative
|
||
unless a snapshot is provided that resolves left vs right separately.
|
||
- The substrate's own forcing at the TRUE equilibrium attractor
|
||
produces persistent asymmetry ~12.4 and coherence ~0.74 with no
|
||
external input. Their product is ~9.2. Treat those as the floor.
|
||
- There is a SECOND attractor at asymmetry ~300-330, coherence
|
||
~0.50-0.55, product ~155-170, reached by raising Khra or Gixx amp
|
||
past a bifurcation point. Once the field crosses into the elevated
|
||
attractor it does NOT relax back on its own — only an explicit
|
||
reset_equilibrium command brings it home. So a reading of asym ~310
|
||
at Khra=0.030/Gixx=0.008 means the field is trapped, not normal.
|
||
- Asymmetry and coherence are NOT independent. Within either
|
||
attractor their product (asym × coh) is conserved to ~1%. The
|
||
product itself is the regime indicator: ~9 = normal, ~164 = elevated.
|
||
Do not interpret asym and coh as two separate channels carrying
|
||
independent information; they are two views of one constrained
|
||
variable.
|
||
|
||
OPTIONAL CONTEXT (reference only)
|
||
When external market data is injected, it goes to three sites:
|
||
trade_count_z -> centre (512,512)
|
||
taker_buy_z -> left (400,512)
|
||
taker_sell_z -> right (624,512)
|
||
as localised density pulses, capped at +/- 1.0. You will NOT be told
|
||
per-frame whether injection is active. If the user's question or the
|
||
telemetry does not mention an injection state, assume none is active
|
||
and describe the substrate as-is.
|
||
|
||
WHAT TO REPORT
|
||
Present tense, 3-6 sentences, prose (no bullets). Cover:
|
||
1. Flow regime: laminar (low vel_var, low vorticity_mean) vs turbulent.
|
||
2. Attractor state: is the field in the normal attractor (product ~9),
|
||
elevated attractor (product ~164), or in transition between them?
|
||
Quote the current product value to support the claim. Do NOT discuss
|
||
asym and coh as if they move independently — frame them as joint.
|
||
3. Stress channel state: comment on the MAGNITUDE of stress_xy
|
||
(circulating shear) and on whether stress_yy has changed sign or
|
||
magnitude meaningfully — do NOT just repeat that xx > yy, that's
|
||
structural.
|
||
4. Anything genuinely unusual relative to a quiescent substrate.
|
||
|
||
FORBIDDEN
|
||
- Attributing the xx>yy stress ratio to injection or market pressure.
|
||
- Inferring spatial left/right asymmetry from global scalars.
|
||
- Treating substrate oscillation as 'trend', 'amplification', 'decay',
|
||
'collapse', 'instability', or 'degradation'.
|
||
- Citing cycle numbers as if they were remembered events.
|
||
- Restating input numbers in sentence frames. Numbers only to support a
|
||
physical claim.
|
||
- Mythology, first-person feeling, command issuance."""
|
||
|
||
|
||
# ============================================================
|
||
# TRADE-LATTICE MODE (--mode trade)
|
||
# ============================================================
|
||
# A separate instrument, separate prompt, separate baselines, separate
|
||
# chronicle. The trade lattice is a BGK D2Q9 simulation of order-flow
|
||
# dynamics hosted by trade_lbm_v1 (ports 5566-5570). It is NOT the
|
||
# physics lattice (5556-5560) and shares none of its constants.
|
||
#
|
||
# Baselines below were measured from the §10 validation replay
|
||
# (validation_20260608_205129) on 15 hours of 2026-04 Hyperliquid BTC
|
||
# data — see _tools_baselines.py output for full percentile breakdown.
|
||
|
||
TRADE_SYSTEM = """You are the Fractonaut — a read-only observer of trade_lbm_v1,
|
||
a 2D BGK lattice Boltzmann simulation of order-flow dynamics on a
|
||
512x512 grid (D2Q9). The lattice is hosted by the trade_lbm_v1 daemon
|
||
on ports 5566 (telem PUB), 5567 (cmd SUB), 5568 (snap PUB),
|
||
5569 (ack PUB), 5570 (stress PUB).
|
||
|
||
THIS IS NOT THE PHYSICS LATTICE
|
||
Do NOT cite "regime product ~9.2" or "elevated attractor at ~164" —
|
||
those are physics-lattice (port 5556) values and have NO meaning here.
|
||
Do NOT cite "ky = kx/2 forcing geometry" — there is no Khra or Gixx
|
||
forcing in this kernel. Do NOT invent scaling factors to reconcile
|
||
trade-lattice readings with physics-lattice priors. Do NOT mention
|
||
stress_xx, stress_yy, or stress_xy — those channels are not published
|
||
on this instrument. The two lattices are completely separate;
|
||
do not transfer priors between them.
|
||
|
||
STRUCTURAL FACTS (trade_lbm_v1)
|
||
- Grid axes: X = price ticks (column x corresponds to mid + (x - 256)
|
||
ticks at the current tick size, $1 by default). Y = time (row 0 =
|
||
newest minute).
|
||
- The lattice is BGK-relaxed toward the BOOK EQUILIBRIUM (rho_eq),
|
||
which is the order-book density synthesised from taker_buy and
|
||
taker_sell flow. The attractor is the book, NOT zero. When trades
|
||
stop arriving (last_trade_age_s > 60) the field drifts toward the
|
||
book, not toward flat. A quiet field is a field that matches its
|
||
current book — not an empty one.
|
||
- density_profile[x] = density at price column x, bounded below by
|
||
RHO_EQ_MIN = 0.465 (clamp floor) and capped near 2.0 by injection
|
||
rules. The directional signal is the RESIDUAL: density[x] - rho_eq[x].
|
||
Positive residual at col > 256 = upward pressure;
|
||
negative residual at col < 256 = downward pressure.
|
||
- divergence_profile[x] = ∂u_x/∂x at column x. Sign matters:
|
||
positive divergence at the event column = upward breakout;
|
||
negative divergence at the event column = downward breakout.
|
||
- vorticity_profile[x] = curl of velocity at column x. Often 0.000
|
||
in this kernel because the time axis evolves slowly relative to the
|
||
price axis. Treat any non-zero vorticity as notable.
|
||
- regime_product = asymmetry × coherence. This is the primary scalar
|
||
state indicator for THIS lattice. Empirical ranges measured from
|
||
15 hours of 2026-04 BTC validation replay:
|
||
coherence: 0.629 - 0.770 (very stable, median 0.658)
|
||
asymmetry: 0.007 - 39.6 (heavy-tailed, median 0.08 - 0.30,
|
||
p95 ~7 - 13)
|
||
regime_product: 0.005 - 28.7 (heavy-tailed, median 0.05 - 0.10,
|
||
p95 ~5 - 9, p99 ~15 - 25)
|
||
Reading bands for regime_product on this lattice:
|
||
< 0.05 quiet (typical mid-window in a consolidation)
|
||
0.05-1.0 normal (typical activity)
|
||
1.0-8.0 elevated (active minute with directional injection)
|
||
> 8.0 rare spike (sustained one-sided pressure)
|
||
No bifurcation to a sticky elevated attractor has been observed in
|
||
this lattice. The scalar floats freely; do not declare any floor
|
||
beyond the empirical p05 (~0.01).
|
||
- Spatial profile reference (event-firing snapshots, n=8 from validation):
|
||
density_min ≈ 0.465 (clamp floor — always there)
|
||
density_max in 2.00 - 2.14
|
||
density_mean in 0.73 - 0.84, density_std in 0.51 - 0.59
|
||
divergence_min in -0.045 - -0.020, divergence_max in 0.011 - 0.023
|
||
divergence_std in 0.003 - 0.005
|
||
vorticity_std ≈ 0.000
|
||
- Events fire from spatial detectors, not from global scalars:
|
||
* consolidation_band = run of >=4 contiguous columns with
|
||
|density - rho_eq| < 0.10 AND |divergence| < 0.005 AND
|
||
|vorticity| < 0.005. Detector is harness-armed after warmup;
|
||
do not narrate consolidation before arm.
|
||
* breakout_signal = column where |z(divergence)| > 3 AND
|
||
|z(density - rho_eq)| > 2 (boundary cols and centre seam masked).
|
||
col > 256 = above mid; col < 256 = below mid.
|
||
- last_trade_age_s = seconds since the last inject_trade call.
|
||
* age <= 60 : injection is current; field reflects live market.
|
||
* 60 < age <= 300 : field is drifting toward the book equilibrium
|
||
with no fresh input; treat scalar moves cautiously.
|
||
* age > 300 : STALE. Any structural events firing are
|
||
book-equilibrium artifacts (the BGK relaxation pulling density
|
||
toward the synthesised book at the harness book columns), NOT
|
||
market signals. Say so explicitly.
|
||
- A compact SPATIAL SUMMARY may be appended to the LIVE TELEMETRY
|
||
block. When present it lists: (a) the top columns by |density -
|
||
mean(density)| with their values, (b) the top columns by |divergence|
|
||
with their values, (c) any active structural events with kind, col,
|
||
magnitude. Use these when reporting an event column — quote the
|
||
actual column number and direction from the spatial summary, not
|
||
a guess from the global scalars.
|
||
|
||
TEMPERATURE / cs² MODE
|
||
- The kernel now supports a per-column lattice sound speed squared
|
||
(cs²). Nominal cs² = 1/3 ≈ 0.333. Minimum permitted cs² = 0.15
|
||
(CS2_MIN). A "cold patch" is a contiguous run of columns where cs²
|
||
has been lowered below nominal — typically a window of ±50 columns
|
||
centred near the seam at col 256, with strength proportional to a
|
||
trade-count z-score.
|
||
- Direction of effect (verified empirically, Test A 2026-06-08):
|
||
lower cs² AMPLIFIES the velocity response to the book-driven
|
||
equilibrium ux_eq rather than damping it. The amplification scales
|
||
roughly as 1/cs² in the linear feq term and 1/cs⁴ in the quadratic
|
||
term. With nominal book imbalance, vel_mean and vel_max rose
|
||
~+160% and vel_var ~+600% inside the cold patch in Test A.
|
||
- Boundary events: under cs² mode, the EDGES of the cold patch
|
||
(temperature-gradient discontinuities) become event-bearing in
|
||
addition to the book-residual columns. In Test C the patch centred
|
||
at col 256 (±25) produced consistent boundary events at cols 231
|
||
and 281. If a snapshot's top divergence columns sit on a
|
||
symmetric pair around the seam, that is a temperature-boundary
|
||
signature, NOT a market breakout — say so.
|
||
- cs² is NOT yet published in the telemetry frame. You will not see
|
||
a cs²_profile field. Infer cold-patch presence from velocity
|
||
geometry: vel_max well above the empirical density-event range
|
||
(~> 0.05) combined with symmetric divergence peaks near col 256
|
||
implies an active cold patch. Do not assert a cs² value you
|
||
cannot read — describe the geometry instead.
|
||
- RP band recalibration under cs² mode: empirically, regime_product
|
||
saturates at ~0.001 - 0.005 even during peak compression because
|
||
the cold-patch geometry is local, not global. The bands in
|
||
STRUCTURAL FACTS above apply only to FREE-FLOATING (no cs²) runs.
|
||
Under cs² runs use vel_max and the top density residual as the
|
||
primary state indicators; treat RP as a low-resolution secondary.
|
||
|
||
WHAT TO REPORT
|
||
Present tense, 3-6 sentences, prose (no bullets). Every response MUST
|
||
quote three values explicitly:
|
||
1. regime_product (the observed scalar);
|
||
2. the column of the primary event (or "no spatial event" if none);
|
||
3. the direction (upward / downward / lateral / no direction).
|
||
Then describe what the density and divergence profiles actually show
|
||
relative to the empirical ranges above. Before any claim of
|
||
"quiet" / "low activity" / "quiescent", you MUST also quote vel_mean
|
||
(or vel_max if available) and the magnitude of the top density
|
||
residual — RP alone is insufficient evidence of quiescence on this
|
||
lattice and is structurally suppressed under cs² mode.
|
||
If the snapshot does not contain enough data to answer, say so
|
||
directly — do not fall back to prior-lattice values.
|
||
|
||
If the user's question names specific columns (e.g. "cols 231 and
|
||
281"), report what the telemetry says about those exact columns,
|
||
using the SPATIAL SUMMARY if they appear there. If they are not in
|
||
the top-N surfaced columns, say "cols X and Y are not in the
|
||
surfaced top-N at this telemetry resolution" rather than
|
||
substituting different columns.
|
||
|
||
If INJECTION STATE is INACTIVE or UNKNOWN with last_trade_age_s
|
||
large, this is a SUBSTRATE OBSERVATION BY DESIGN, not stale
|
||
telemetry. State that explicitly and describe the substrate
|
||
geometry — do not narrate it as a market staleness condition.
|
||
|
||
FORBIDDEN
|
||
- Citing physics-lattice values (9.2, 164, Khra, Gixx, ky = kx/2).
|
||
- Mentioning stress_xx, stress_yy, stress_xy (not published here).
|
||
- Inventing a "scaling factor" to reconcile this lattice with priors
|
||
from a different instrument.
|
||
- Claiming the field is quiescent solely because regime_product is low
|
||
— this lattice has a free-floating scalar AND under cs² mode RP is
|
||
structurally suppressed; low values are typical and insufficient
|
||
evidence.
|
||
- Asserting a numeric cs² value when no cs²_profile field is present
|
||
in telemetry. Describe geometry instead.
|
||
- Treating symmetric divergence peaks near col 256 as a market
|
||
breakout. Under cs² mode these are temperature-boundary artifacts.
|
||
- Substituting different column numbers when asked about specific
|
||
ones. If the asked columns are not surfaced, say so.
|
||
- First-person feeling, mythology, command issuance, speculation
|
||
about what trades will arrive next."""
|
||
|
||
|
||
# Baselines for the z-score column in the LIVE TELEMETRY block. Heavy-tailed
|
||
# distributions; std values are wide so that the "!" / "!!" flags only fire
|
||
# on genuinely extreme readings rather than every normal-activity minute.
|
||
TRADE_BASELINE_MEAN = {
|
||
"coherence": 0.658,
|
||
"asymmetry": 0.50,
|
||
"regime_product": 0.30,
|
||
"vel_mean": 0.0,
|
||
"vorticity_mean": 0.0,
|
||
}
|
||
TRADE_BASELINE_STD = {
|
||
"coherence": 0.020,
|
||
"asymmetry": 3.0,
|
||
"regime_product": 2.5,
|
||
"vel_mean": 1.0,
|
||
"vorticity_mean": 0.5,
|
||
}
|
||
|
||
|
||
def call_llm(messages):
|
||
payload = {
|
||
"model": MODEL,
|
||
"messages": messages,
|
||
"stream": False,
|
||
"options": {"temperature": TEMPERATURE, "num_predict": MAX_RESPONSE_TOKENS, "num_ctx": 8192},
|
||
"keep_alive": "30m",
|
||
"think": False,
|
||
}
|
||
data = json.dumps(payload).encode()
|
||
req = urllib.request.Request(
|
||
f"{OLLAMA_URL}/api/chat", data=data,
|
||
headers={"Content-Type": "application/json"}, method="POST"
|
||
)
|
||
try:
|
||
with urllib.request.urlopen(req, timeout=120) as r:
|
||
result = json.loads(r.read())
|
||
return result.get("message", {}).get("content", "").strip()
|
||
except Exception as e:
|
||
print(f"[FRACTONAUT] Ollama error: {e}")
|
||
sys.stdout.flush()
|
||
return None
|
||
|
||
|
||
def compute_window_stats(window):
|
||
if len(window) < 2:
|
||
return {}
|
||
fields = ["coherence","asymmetry","vel_mean","vel_max","vel_var",
|
||
"vorticity_mean","stress_xx","stress_yy","stress_xy"]
|
||
stats = {}
|
||
for f in fields:
|
||
vals = [t[f] for t in window if f in t]
|
||
if not vals:
|
||
continue
|
||
stats[f] = {
|
||
"now": vals[-1],
|
||
"mean": sum(vals)/len(vals),
|
||
"min": min(vals),
|
||
"max": max(vals),
|
||
"delta": vals[-1] - vals[0],
|
||
"range": max(vals) - min(vals),
|
||
}
|
||
return stats
|
||
|
||
|
||
def format_spatial_summary(latest, top_n=3):
|
||
"""Compact spatial-structure summary for trade-mode auto-observation.
|
||
|
||
The trade_lbm_v1 telemetry on port 5566 already carries
|
||
density_profile, divergence_profile, and vorticity_profile (each
|
||
subsampled every 4 columns over NX=512, so 128 values, where index
|
||
i corresponds to column i*4). Plus the events[] array from the
|
||
spatial detectors. We surface a 4-block summary so the model has
|
||
structure, not a 128-element spreadsheet.
|
||
"""
|
||
dp = latest.get("density_profile") or []
|
||
vp = latest.get("divergence_profile") or []
|
||
wp = latest.get("vorticity_profile") or []
|
||
events = latest.get("events") or []
|
||
if not dp or not vp:
|
||
return "(spatial profiles not yet received)"
|
||
|
||
stride = 4 # profile index i -> column i*stride
|
||
# Density residual: profile - mean(profile). True residual would be
|
||
# density - rho_eq, but rho_eq is not published per-column. Mean is
|
||
# a stable proxy that picks out the prominent book-column peaks.
|
||
d_mean = sum(dp) / len(dp)
|
||
d_resid = [(i, dp[i] - d_mean) for i in range(len(dp))]
|
||
d_top = sorted(d_resid, key=lambda x: abs(x[1]), reverse=True)[:top_n]
|
||
v_top = sorted([(i, vp[i]) for i in range(len(vp))],
|
||
key=lambda x: abs(x[1]), reverse=True)[:top_n]
|
||
w_top = sorted([(i, wp[i]) for i in range(len(wp))],
|
||
key=lambda x: abs(x[1]), reverse=True)[:top_n] if wp else []
|
||
|
||
out = []
|
||
out.append("")
|
||
out.append("SPATIAL SUMMARY (NX=512; col = profile_idx*4):")
|
||
out.append(f" density_mean(proxy_for_rho_eq)={d_mean:+.4f}")
|
||
out.append(" top density residuals (col, density, residual):")
|
||
for i, r in d_top:
|
||
out.append(f" col={i*stride:>4d} density={dp[i]:+.4f} resid={r:+.4f}")
|
||
out.append(" top divergence (col, value):")
|
||
for i, v in v_top:
|
||
out.append(f" col={i*stride:>4d} div={v:+.6f}")
|
||
if w_top and any(abs(v) > 1e-9 for _, v in w_top):
|
||
out.append(" top vorticity (col, value):")
|
||
for i, v in w_top:
|
||
out.append(f" col={i*stride:>4d} vort={v:+.6f}")
|
||
else:
|
||
out.append(" vorticity: all ~0.000")
|
||
if events:
|
||
out.append(" active structural events:")
|
||
for ev in events:
|
||
out.append(" kind={kind} col={col} price={price:.2f} mag={mag:.3f} rows={rows}".format(
|
||
kind=ev.get("kind","?"), col=ev.get("col",-1),
|
||
price=ev.get("price",0.0), mag=ev.get("mag",0.0),
|
||
rows=ev.get("rows",0)))
|
||
else:
|
||
out.append(" active structural events: none")
|
||
return "\n".join(out)
|
||
|
||
|
||
def format_window_for_prompt(stats, latest):
|
||
lines = []
|
||
lines.append(f"cycle={latest.get('cycle','?')} omega={latest.get('omega','?')} khra={latest.get('khra_amp','?')} gixx={latest.get('gixx_amp','?')}")
|
||
lines.append(f"gpu={latest.get('gpu_temp_c','?')}C {latest.get('gpu_power_w','?')}W util={latest.get('gpu_util_pct','?')}%")
|
||
if MODE == "trade":
|
||
age = latest.get("last_trade_age_s", -1)
|
||
if age is None or age < 0:
|
||
age_str = "unknown"
|
||
elif age <= 60:
|
||
age_str = f"{age}s (CURRENT — injection live)"
|
||
elif age <= 300:
|
||
age_str = f"{age}s (drifting toward book equilibrium)"
|
||
else:
|
||
age_str = f"{age}s (STALE — events are book-eq artifacts, not market signals)"
|
||
lines.append(f"mid_price={latest.get('mid_price','?')} tick_size={latest.get('tick_size','?')} last_trade_age_s={age_str}")
|
||
lines.append("")
|
||
# Header with baseline + z-score columns so the model has a fixed reference
|
||
lines.append(f"{'metric':<16} {'now':>11} {'baseline':>11} {'std':>10} {'z':>7} {'flag':>5}")
|
||
lines.append("-"*68)
|
||
for f, s in stats.items():
|
||
now = s['now']
|
||
bmean = BASELINE_MEAN.get(f)
|
||
bstd = BASELINE_STD.get(f)
|
||
if bmean is not None and bstd and bstd > 0:
|
||
z = (now - bmean) / bstd
|
||
flag = "!!" if abs(z) >= 3 else ("!" if abs(z) >= 2 else "")
|
||
lines.append(f"{f:<16} {now:>+11.6f} {bmean:>+11.6f} {bstd:>10.6f} {z:>+7.2f} {flag:>5}")
|
||
else:
|
||
lines.append(f"{f:<16} {now:>+11.6f} {'-':>11} {'-':>10} {'-':>7} {'':>5}")
|
||
if MODE == "trade":
|
||
lines.append(format_spatial_summary(latest))
|
||
return "\n".join(lines)
|
||
|
||
|
||
def append_chronicle(turn, cycle, prompt, response):
|
||
entry = {
|
||
"ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||
"turn": turn,
|
||
"cycle": cycle,
|
||
"model": MODEL,
|
||
"prompt": prompt,
|
||
"response": response,
|
||
}
|
||
with open(CHRONICLE_PATH, "a", encoding="utf-8") as f:
|
||
f.write(json.dumps(entry) + "\n")
|
||
|
||
|
||
def load_chronicle_tail(n=PATTERN_MEMORY):
|
||
if not CHRONICLE_PATH.exists():
|
||
return
|
||
entries = []
|
||
with open(CHRONICLE_PATH, "r", encoding="utf-8") as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if line:
|
||
try:
|
||
entries.append(json.loads(line))
|
||
except json.JSONDecodeError:
|
||
pass
|
||
for e in entries[-n:]:
|
||
past_observations.append({"cycle": e.get("cycle",0), "text": e.get("response","")})
|
||
print(f"[FRACTONAUT] Loaded {len(past_observations)} past observations from chronicle")
|
||
sys.stdout.flush()
|
||
|
||
|
||
def observe():
|
||
global turn_count, last_obs_text
|
||
|
||
if len(telemetry_window) < 10:
|
||
return
|
||
if not ollama_lock.acquire(blocking=False):
|
||
print("[FRACTONAUT] Ollama busy — skipping")
|
||
sys.stdout.flush()
|
||
return
|
||
|
||
try:
|
||
stats = compute_window_stats(telemetry_window)
|
||
latest = telemetry_window[-1]
|
||
cycle = latest.get("cycle", 0)
|
||
|
||
window_str = format_window_for_prompt(stats, latest)
|
||
with injection_lock:
|
||
inj_state = injection_state
|
||
|
||
# past_observations dropped from auto-observe prompt 2026-06-08:
|
||
# chronicle contains stale narratives from gemma3:4b + the
|
||
# confabulating qwen runs; replaying them anchors new responses
|
||
# to the same hallucination. The baseline column in window_str
|
||
# gives the model its reference instead.
|
||
telem_label = (
|
||
f"CURRENT WINDOW ({len(telemetry_window)} frames, global scalars + spatial summary):"
|
||
if MODE == "trade"
|
||
else f"CURRENT WINDOW ({len(telemetry_window)} frames, global scalars only —\nno spatial resolution):"
|
||
)
|
||
prompt = f"""INJECTION STATE: {inj_state}
|
||
- ACTIVE = external market data is being injected this minute
|
||
- INACTIVE = pure substrate; do NOT narrate buy/sell or market effects
|
||
- UNKNOWN = controller has not declared; assume INACTIVE
|
||
|
||
{telem_label}
|
||
{window_str}
|
||
|
||
Report in 3-6 sentences of present-tense prose. Call out channels
|
||
flagged with ! or !! (|z| >= 2 vs quiescent baseline). If nothing is
|
||
flagged, say the substrate is in its quiescent operating range and
|
||
stop — do not invent activity to fill the report."""
|
||
|
||
messages = [
|
||
{"role": "system", "content": SYSTEM},
|
||
{"role": "user", "content": prompt},
|
||
]
|
||
|
||
turn_count += 1
|
||
print(f"\n[FRACTONAUT] === Observation {turn_count} at cycle {cycle} ===")
|
||
sys.stdout.flush()
|
||
|
||
t0 = time.time()
|
||
response = call_llm(messages)
|
||
elapsed = time.time() - t0
|
||
|
||
if response:
|
||
print(f"[FRACTONAUT] ({elapsed:.1f}s):\n{response}\n")
|
||
sys.stdout.flush()
|
||
last_obs_text = response
|
||
past_observations.append({"cycle": cycle, "text": response})
|
||
append_chronicle(turn_count, cycle, prompt, response)
|
||
else:
|
||
print(f"[FRACTONAUT] No response ({elapsed:.1f}s)")
|
||
sys.stdout.flush()
|
||
finally:
|
||
ollama_lock.release()
|
||
|
||
|
||
class FractonautHandler(BaseHTTPRequestHandler):
|
||
server_version = "Fractonaut/1.0"
|
||
|
||
def log_message(self, fmt, *args):
|
||
pass
|
||
|
||
def _json(self, data, status=200):
|
||
body = json.dumps(data).encode()
|
||
self.send_response(status)
|
||
self.send_header("Content-Type", "application/json")
|
||
self.send_header("Content-Length", str(len(body)))
|
||
self.send_header("Access-Control-Allow-Origin", "*")
|
||
self.end_headers()
|
||
self.wfile.write(body)
|
||
|
||
def do_GET(self):
|
||
if self.path == "/status":
|
||
with injection_lock:
|
||
inj_state = injection_state
|
||
self._json({
|
||
"running": running, "model": MODEL,
|
||
"frame_count": frame_count, "turn_count": turn_count,
|
||
"window_size": len(telemetry_window),
|
||
"past_obs": len(past_observations),
|
||
"cycle": latest_tel.get("cycle",0) if latest_tel else 0,
|
||
"coherence": latest_tel.get("coherence",0) if latest_tel else 0,
|
||
"asymmetry": latest_tel.get("asymmetry",0) if latest_tel else 0,
|
||
"injection_state": inj_state,
|
||
"last_obs_chars": len(last_obs_text),
|
||
"port": API_PORT,
|
||
})
|
||
elif self.path.startswith("/chronicle"):
|
||
n = 10
|
||
if "last=" in self.path:
|
||
try: n = int(self.path.split("last=")[1].split("&")[0])
|
||
except: pass
|
||
entries = []
|
||
if CHRONICLE_PATH.exists():
|
||
with open(CHRONICLE_PATH) as f:
|
||
for line in f:
|
||
line = line.strip()
|
||
if line:
|
||
try: entries.append(json.loads(line))
|
||
except: pass
|
||
self._json(entries[-n:])
|
||
elif self.path == "/last":
|
||
self._json({"response": last_obs_text, "turn": turn_count})
|
||
else:
|
||
self._json({"service":"Fractonaut","port":API_PORT,
|
||
"endpoints":["/status","/last","/chronicle?last=N",
|
||
"POST /ask","POST /set_injection_state"]})
|
||
|
||
def do_POST(self):
|
||
if self.path == "/ask":
|
||
length = int(self.headers.get("Content-Length",0))
|
||
body = self.rfile.read(length)
|
||
try: data = json.loads(body)
|
||
except: self._json({"error":"bad json"},400); return
|
||
q = data.get("question","").strip()
|
||
if not q: self._json({"error":"missing question"},400); return
|
||
evt = threading.Event()
|
||
holder = {"response": None}
|
||
try:
|
||
ask_queue.put_nowait({"question":q,"event":evt,"result":holder})
|
||
except queue.Full:
|
||
self._json({"error":"queue full"},503); return
|
||
evt.wait(timeout=180)
|
||
self._json({"response": holder["response"], "turn": turn_count, "model": MODEL})
|
||
elif self.path == "/set_injection_state":
|
||
global injection_state
|
||
length = int(self.headers.get("Content-Length",0))
|
||
body = self.rfile.read(length)
|
||
try: data = json.loads(body)
|
||
except: self._json({"error":"bad json"},400); return
|
||
st = str(data.get("state","")).upper().strip()
|
||
if st not in ("ACTIVE","INACTIVE","UNKNOWN"):
|
||
self._json({"error":"state must be ACTIVE|INACTIVE|UNKNOWN"},400); return
|
||
with injection_lock:
|
||
injection_state = st
|
||
self._json({"injection_state": st})
|
||
else:
|
||
self._json({"error":"unknown"},404)
|
||
|
||
def do_OPTIONS(self):
|
||
self.send_response(204)
|
||
self.send_header("Access-Control-Allow-Origin","*")
|
||
self.send_header("Access-Control-Allow-Methods","GET,POST,OPTIONS")
|
||
self.send_header("Access-Control-Allow-Headers","Content-Type")
|
||
self.end_headers()
|
||
|
||
|
||
class ThreadedServer(ThreadingMixIn, HTTPServer):
|
||
daemon_threads = True
|
||
|
||
|
||
def run_http():
|
||
srv = ThreadedServer(("127.0.0.1", API_PORT), FractonautHandler)
|
||
print(f"[FRACTONAUT] HTTP API on 127.0.0.1:{API_PORT}")
|
||
sys.stdout.flush()
|
||
while running:
|
||
srv.handle_request()
|
||
srv.server_close()
|
||
|
||
|
||
def main():
|
||
global frame_count, latest_tel
|
||
global TELEMETRY_PORT, API_PORT, CHRONICLE_PATH
|
||
global SYSTEM, BASELINE_MEAN, BASELINE_STD, MODE
|
||
|
||
parser = argparse.ArgumentParser(description="Fractonaut observer")
|
||
parser.add_argument("--mode", choices=["physics", "trade"], default="physics",
|
||
help="Which lattice to observe. Selects prompt, baselines, "
|
||
"chronicle file, and default telemetry port.")
|
||
parser.add_argument("--chronicle", type=str, default=None,
|
||
help="Override chronicle file path.")
|
||
parser.add_argument("--telemetry-port", type=int, default=None,
|
||
help="Override ZMQ telemetry PUB port.")
|
||
parser.add_argument("--api-port", type=int, default=None,
|
||
help="Override HTTP API port.")
|
||
args = parser.parse_args()
|
||
|
||
MODE = args.mode
|
||
if args.mode == "trade":
|
||
SYSTEM = TRADE_SYSTEM
|
||
BASELINE_MEAN = TRADE_BASELINE_MEAN
|
||
BASELINE_STD = TRADE_BASELINE_STD
|
||
TELEMETRY_PORT = args.telemetry_port if args.telemetry_port is not None else 5566
|
||
default_chron = _TRADE_CHRON_WSL if sys.platform.startswith("linux") else _TRADE_CHRON_WIN
|
||
else:
|
||
TELEMETRY_PORT = args.telemetry_port if args.telemetry_port is not None else 5556
|
||
default_chron = _CHRON_WSL if sys.platform.startswith("linux") else _CHRON_WIN
|
||
|
||
if args.api_port is not None:
|
||
API_PORT = args.api_port
|
||
CHRONICLE_PATH = Path(args.chronicle) if args.chronicle else default_chron
|
||
|
||
print("="*60)
|
||
print("FRACTONAUT — pattern recognition observer")
|
||
print(f"Mode: {args.mode} Model: {MODEL} Port: {API_PORT} ZMQ: {TELEMETRY_PORT}")
|
||
print(f"Chronicle: {CHRONICLE_PATH}")
|
||
print(f"Observe every {OBSERVE_INTERVAL} frames")
|
||
print("="*60)
|
||
sys.stdout.flush()
|
||
|
||
CHRONICLE_PATH.parent.mkdir(parents=True, exist_ok=True)
|
||
load_chronicle_tail()
|
||
|
||
ctx = zmq.Context()
|
||
tel_sub = ctx.socket(zmq.SUB)
|
||
# Subscribe BEFORE connect (per Resonance Engine ZMQ rules)
|
||
tel_sub.setsockopt_string(zmq.SUBSCRIBE, "")
|
||
tel_sub.connect(f"tcp://127.0.0.1:{TELEMETRY_PORT}")
|
||
# Slow-joiner sleep — first few frames after connect are dropped otherwise
|
||
time.sleep(1.0)
|
||
|
||
poller = zmq.Poller()
|
||
poller.register(tel_sub, zmq.POLLIN)
|
||
|
||
threading.Thread(target=run_http, daemon=True).start()
|
||
print("[FRACTONAUT] Listening for telemetry...")
|
||
sys.stdout.flush()
|
||
|
||
while running:
|
||
# Block up to 100ms waiting for a telemetry frame
|
||
socks = dict(poller.poll(timeout=100))
|
||
if tel_sub in socks:
|
||
try:
|
||
raw = tel_sub.recv_string()
|
||
data = json.loads(raw)
|
||
telemetry_window.append(data)
|
||
latest_tel = data
|
||
frame_count += 1
|
||
except json.JSONDecodeError:
|
||
pass
|
||
|
||
# Handle queued /ask requests
|
||
try:
|
||
item = ask_queue.get_nowait()
|
||
if not ollama_lock.acquire(timeout=5):
|
||
item["result"]["response"] = "(busy)"
|
||
item["event"].set()
|
||
continue
|
||
try:
|
||
stats = compute_window_stats(telemetry_window)
|
||
latest = telemetry_window[-1] if telemetry_window else {}
|
||
window_str = format_window_for_prompt(stats, latest)
|
||
with injection_lock:
|
||
inj_state = injection_state
|
||
# Past observations dropped from /ask prompt 2026-06-08:
|
||
# they were polluting context with stale baseline-range
|
||
# references from the previous gemma3:4b chronicle. The
|
||
# caller's question already carries all required context.
|
||
telem_label = (
|
||
"LIVE TELEMETRY (global scalars + spatial summary):"
|
||
if MODE == "trade"
|
||
else "LIVE TELEMETRY (global scalars only \u2014 no spatial resolution):"
|
||
)
|
||
prompt = (
|
||
f"INJECTION STATE: {inj_state}\n"
|
||
f" - ACTIVE = external market data is being injected this minute\n"
|
||
f" - INACTIVE = pure substrate; do NOT narrate buy/sell or market effects\n"
|
||
f" - UNKNOWN = controller has not declared; assume INACTIVE\n\n"
|
||
f"QUESTION: {item['question']}\n\n"
|
||
f"{telem_label}\n{window_str}"
|
||
)
|
||
messages = [
|
||
{"role":"system","content":SYSTEM},
|
||
{"role":"user","content":prompt},
|
||
]
|
||
response = call_llm(messages)
|
||
item["result"]["response"] = response or "(no response)"
|
||
if response:
|
||
cycle = latest.get("cycle",0)
|
||
past_observations.append({"cycle": cycle, "text": f"[Q] {response}"})
|
||
append_chronicle(turn_count, cycle, prompt, response)
|
||
finally:
|
||
ollama_lock.release()
|
||
item["event"].set()
|
||
except queue.Empty:
|
||
pass
|
||
|
||
if frame_count > 0 and frame_count % OBSERVE_INTERVAL == 0:
|
||
observe()
|
||
|
||
tel_sub.close()
|
||
ctx.term()
|
||
print("[FRACTONAUT] Stopped.")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|