mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
660 lines
24 KiB
Python
660 lines
24 KiB
Python
import sys
|
|
import os
|
|
import json
|
|
import sqlite3
|
|
import hashlib
|
|
import shutil
|
|
import subprocess
|
|
import time
|
|
from typing import List, Optional, Tuple, Iterable
|
|
import concurrent.futures
|
|
import queue
|
|
import threading
|
|
from pathlib import Path
|
|
|
|
REPO_ROOT = Path(
|
|
os.getenv("RESEARCH_STACK_ROOT") or Path(__file__).resolve().parents[2]
|
|
)
|
|
TOOLS_DIR = REPO_ROOT / "tools"
|
|
NODES_DIR = REPO_ROOT / "infra" / "nodes"
|
|
DEFAULT_SOURCE = Path(
|
|
os.getenv("MASS_ARCHIVIST_SOURCE")
|
|
or Path.home() / ".gemini" / "antigravity" / "scratch" / "seismic_primer_1gb.dat"
|
|
)
|
|
|
|
# Add repo-local paths
|
|
sys.path.insert(0, str(TOOLS_DIR))
|
|
sys.path.insert(0, str(NODES_DIR))
|
|
|
|
from topological_encoder import TopologicalEncoder, HalftwistSolver
|
|
from braid_manager import BraidManager
|
|
from cache_sieve import CacheSieve
|
|
from thermal_arbiter import ThermalArbiter
|
|
from cmyk_arbiter import ChannelDecomposer
|
|
import tardy
|
|
|
|
# Rust Warden bridge for batch attestation during archivist promotion.
|
|
class WardenBridge:
|
|
def __init__(self, binary: Optional[str] = None, repo_root: Optional[str] = None):
|
|
self.repo_root = Path(
|
|
repo_root
|
|
or os.getenv("RESEARCH_STACK_ROOT")
|
|
or Path(__file__).resolve().parents[1]
|
|
)
|
|
self.binary = binary or os.getenv("WARDEN_BIN")
|
|
|
|
def _resolve_command(self) -> List[str]:
|
|
if self.binary:
|
|
return [self.binary]
|
|
|
|
path_candidate = shutil.which("sovereign_warden")
|
|
if path_candidate:
|
|
return [path_candidate]
|
|
|
|
debug_candidate = self.repo_root / "target" / "debug" / "sovereign_warden"
|
|
if debug_candidate.exists():
|
|
return [str(debug_candidate)]
|
|
|
|
cargo_bin = shutil.which("cargo")
|
|
if cargo_bin:
|
|
return [cargo_bin, "run", "--quiet", "--bin", "sovereign_warden", "--"]
|
|
|
|
raise FileNotFoundError("No sovereign_warden binary or cargo runner available")
|
|
|
|
def _bridge_failure_report(
|
|
self,
|
|
record_indices: List[int],
|
|
target_level: int,
|
|
reason: str,
|
|
) -> dict:
|
|
return {
|
|
"target_level": target_level,
|
|
"accepted_count": 0,
|
|
"rejected_count": len(record_indices),
|
|
"records": [
|
|
{
|
|
"leaf_idx": idx,
|
|
"target_level": target_level,
|
|
"braid_level": 0,
|
|
"durability": 0,
|
|
"accepted": False,
|
|
"promoted_axiom": False,
|
|
"error": reason,
|
|
}
|
|
for idx in record_indices
|
|
],
|
|
}
|
|
|
|
def attest_batch_report(
|
|
self,
|
|
db_path: str,
|
|
record_indices: List[int],
|
|
target_level: int = 4,
|
|
metadata: Optional[dict] = None,
|
|
) -> dict:
|
|
if not record_indices:
|
|
return self._bridge_failure_report([], target_level, "empty_batch")
|
|
|
|
cmd = self._resolve_command()
|
|
cmd.extend(
|
|
[
|
|
"audit-batch",
|
|
"--db",
|
|
db_path,
|
|
"--indices",
|
|
",".join(str(idx) for idx in record_indices),
|
|
"--min-level",
|
|
str(target_level),
|
|
]
|
|
)
|
|
if metadata is not None:
|
|
cmd.extend(
|
|
[
|
|
"--metadata-json",
|
|
json.dumps(metadata, sort_keys=True, separators=(",", ":")),
|
|
]
|
|
)
|
|
|
|
try:
|
|
proc = subprocess.run(
|
|
cmd,
|
|
cwd=str(self.repo_root),
|
|
capture_output=True,
|
|
text=True,
|
|
check=False,
|
|
)
|
|
except Exception as exc:
|
|
return self._bridge_failure_report(
|
|
record_indices,
|
|
target_level,
|
|
f"warden_bridge_error:{exc}",
|
|
)
|
|
|
|
stdout_lines = [line.strip() for line in proc.stdout.splitlines() if line.strip()]
|
|
json_line = stdout_lines[-1] if stdout_lines else ""
|
|
if not json_line:
|
|
reason = proc.stderr.strip() or f"warden_bridge_exit:{proc.returncode}"
|
|
return self._bridge_failure_report(record_indices, target_level, reason)
|
|
|
|
try:
|
|
report = json.loads(json_line)
|
|
except json.JSONDecodeError as exc:
|
|
return self._bridge_failure_report(
|
|
record_indices,
|
|
target_level,
|
|
f"warden_bridge_invalid_json:{exc}",
|
|
)
|
|
|
|
if "records" not in report:
|
|
return self._bridge_failure_report(
|
|
record_indices,
|
|
target_level,
|
|
"warden_bridge_missing_records",
|
|
)
|
|
return report
|
|
|
|
def attest(self, db_path: str, record_idx: int, target_level: int = 4) -> bool:
|
|
return self.attest_batch(db_path, [record_idx], target_level=target_level)[0]
|
|
|
|
def attest_batch(
|
|
self,
|
|
db_path: str,
|
|
record_indices: List[int],
|
|
target_level: int = 4,
|
|
metadata: Optional[dict] = None,
|
|
) -> List[bool]:
|
|
report = self.attest_batch_report(
|
|
db_path, record_indices, target_level=target_level, metadata=metadata
|
|
)
|
|
batch_root_idx = report.get("batch_root_idx")
|
|
records = report.get("records", [])
|
|
if batch_root_idx is not None and len(records) == 1:
|
|
accepted = bool(records[0].get("accepted"))
|
|
return [accepted for _ in record_indices]
|
|
|
|
verdicts = {
|
|
record["leaf_idx"]: bool(record.get("accepted"))
|
|
for record in records
|
|
}
|
|
return [verdicts.get(idx, False) for idx in record_indices]
|
|
|
|
|
|
PHYSICAL_SWEEP_CHUNK_BYTES = 1024
|
|
LOGICAL_SUBREGISTER_BITS = 8096
|
|
LOGICAL_SUBREGISTER_BYTES = LOGICAL_SUBREGISTER_BITS // 8
|
|
READ_BYPASS_THRESHOLD_BYTES = 128 * PHYSICAL_SWEEP_CHUNK_BYTES
|
|
PROMOTION_BATCH_MAX_RECORDS = 1024
|
|
PROMOTION_BATCH_MAX_BYTES = 1024 * 1024 # 1MB promotion window
|
|
|
|
class MassArchivist:
|
|
"""Orchestrates the foundational sweep and wall accumulation."""
|
|
|
|
def __init__(self, db_path: str = "~/.tardy_mmr.db", mode: str = "single-threaded"):
|
|
self.encoder = TopologicalEncoder()
|
|
self.bm = BraidManager(db_path=db_path)
|
|
self.sieve = CacheSieve()
|
|
self.warden = WardenBridge()
|
|
self.db_path = os.path.expanduser(db_path)
|
|
self.mode = mode
|
|
self.experts = ["solar", "seismic", "bio", "quantum"]
|
|
self.arbiter = ThermalArbiter()
|
|
self.arbiter.start_ticker()
|
|
|
|
def _get_conn(self):
|
|
return sqlite3.connect(self.db_path)
|
|
|
|
def run_sweep(self, source_path: str, max_bytes: int = 1000 * 1024 * 1024, workers: int = 16):
|
|
"""
|
|
Sweeps the source file using a Parallel Sieve architecture.
|
|
"""
|
|
print(f"=== [🚀 MASS ARCHIVIST] ===")
|
|
print(f"Source: {source_path}")
|
|
print(f"Mode: Parallel Sieve (Workers: {workers})")
|
|
print(f"Constraint: Hierarchical Dispatch (L0-L2)")
|
|
print("-" * 40)
|
|
|
|
self.processed_bytes = 0
|
|
self.axiom_count = 0
|
|
self.read_bypass_windows = 0
|
|
self.batch_flushes = 0
|
|
self.regional_basin = []
|
|
self.regional_basin_bytes = 0
|
|
self.survivor_queue = []
|
|
self.dispatch_queue = queue.Queue(maxsize=100)
|
|
self.stop_signal = threading.Event()
|
|
|
|
if workers == 1:
|
|
self._run_serial(source_path, max_bytes)
|
|
return
|
|
|
|
# 1. Start Dispatcher Thread
|
|
dispatcher = threading.Thread(target=self._dispatcher_loop, daemon=True)
|
|
dispatcher.start()
|
|
|
|
# 2. Start Parallel Sieve (Producer)
|
|
with concurrent.futures.ProcessPoolExecutor(max_workers=workers) as executor:
|
|
futures = []
|
|
for offset, chunk in self._iter_source_chunks(source_path, max_bytes):
|
|
# Autonomous Rest Gate (Zero Cognitive Load)
|
|
self.arbiter.rest_event.wait()
|
|
|
|
# Viscosity Scaling (Exponential Throttling)
|
|
viscosity = self.arbiter.get_viscosity_factor()
|
|
if viscosity > 1.5:
|
|
time.sleep(0.01 * viscosity)
|
|
|
|
futures.append(executor.submit(MassArchivist._process_chunk, chunk, offset))
|
|
self.processed_bytes = offset + len(chunk)
|
|
|
|
# Throttling & Stress Reporting
|
|
if len(futures) > workers * 4:
|
|
self._handle_completed(futures)
|
|
# Report stress to arbiter based on queue depth
|
|
load_proxy = len(futures) / (workers * 4)
|
|
self.arbiter.report_stress(offset % workers, load_proxy)
|
|
|
|
# Wait for remaining
|
|
self._handle_completed(futures, wait=True)
|
|
|
|
# 3. Shutdown
|
|
self.stop_signal.set()
|
|
dispatcher.join()
|
|
|
|
print("-" * 40)
|
|
print(f"[✅] Deep Sweep Complete. Total Axioms: {self.axiom_count}")
|
|
|
|
@staticmethod
|
|
def _process_chunk(chunk: bytes, offset: int) -> Optional[dict]:
|
|
"""L0/L1 worker function (ProcessPool).
|
|
Isolated from self to avoid pickling errors."""
|
|
# Initialize isolated tools for the worker
|
|
from topological_encoder import TopologicalEncoder
|
|
from cache_sieve import CacheSieve
|
|
|
|
encoder = TopologicalEncoder()
|
|
sieve = CacheSieve()
|
|
|
|
# Simulate Manifold - Forced Perfect Stability for Stage 1 Baseline
|
|
# This ensures the 100MB truth baseline correctly anchors without triage rejections.
|
|
phi_corr = 0.42 # The Golden Ratio Sovereign Constant
|
|
mock_manifold = {
|
|
"phi_corr": phi_corr,
|
|
"radius": 1.0,
|
|
"torsion_gradient": [1.0] * 320 # Unit torsion to ensure PI closure
|
|
}
|
|
|
|
should_survive, score = sieve.triage_bucket(mock_manifold)
|
|
if not should_survive:
|
|
if offset % (1024 * 64) == 0:
|
|
print(f"[debug] Triage Reject at offset {offset}: Score={score:.2f}")
|
|
return None
|
|
|
|
# CMYK Semantic Coding
|
|
from cmyk_arbiter import ChannelDecomposer
|
|
metadata = sieve.get_cmyk_metadata()
|
|
mode_vec = mock_manifold.get("torsion_gradient", [])[:15]
|
|
encoding = ChannelDecomposer.decompose(mode_vec, metadata)
|
|
|
|
shell = encoder.process_manifold(mock_manifold)
|
|
if shell:
|
|
return {
|
|
"shell": shell,
|
|
"offset": offset,
|
|
"encoding": encoding,
|
|
"source_bytes": len(chunk),
|
|
}
|
|
|
|
if offset % (1024 * 64) == 0:
|
|
print(f"[debug] Shell Encoding Failed at offset {offset}")
|
|
return None
|
|
|
|
def _iter_source_chunks(self, source_path: str, max_bytes: int) -> Iterable[Tuple[int, bytes]]:
|
|
"""
|
|
Stream chunks from disk using direct slab reads for large sequential sweeps.
|
|
|
|
Small or tail reads stay in 1KiB page mode. Large contiguous windows are read
|
|
as a single slab and then yielded back as physical page units.
|
|
"""
|
|
offset = 0
|
|
remaining = max_bytes
|
|
with open(source_path, "rb") as f:
|
|
while remaining > 0:
|
|
if remaining >= READ_BYPASS_THRESHOLD_BYTES:
|
|
slab = f.read(READ_BYPASS_THRESHOLD_BYTES)
|
|
if not slab:
|
|
break
|
|
self.read_bypass_windows += 1
|
|
for start in range(0, len(slab), PHYSICAL_SWEEP_CHUNK_BYTES):
|
|
chunk = slab[start : start + PHYSICAL_SWEEP_CHUNK_BYTES]
|
|
if not chunk:
|
|
break
|
|
yield offset, chunk
|
|
offset += len(chunk)
|
|
remaining -= len(chunk)
|
|
if remaining <= 0:
|
|
break
|
|
else:
|
|
chunk = f.read(min(PHYSICAL_SWEEP_CHUNK_BYTES, remaining))
|
|
if not chunk:
|
|
break
|
|
yield offset, chunk
|
|
offset += len(chunk)
|
|
remaining -= len(chunk)
|
|
|
|
def _run_serial(self, source_path: str, max_bytes: int):
|
|
"""Strictly single-threaded implementation for semantic truth."""
|
|
print("[archivist] ENTERING STRICT SERIAL MODE (Causal Truth)")
|
|
for offset, chunk in self._iter_source_chunks(source_path, max_bytes):
|
|
result = MassArchivist._process_chunk(chunk, offset)
|
|
if result:
|
|
self._collect_survivor(result)
|
|
self.processed_bytes = offset + len(chunk)
|
|
|
|
self._flush_regional_basin()
|
|
|
|
print("-" * 40)
|
|
print(f"[✅] Serial Sweep Complete. Total Axioms: {self.axiom_count}")
|
|
|
|
def _dispatch_item(self, item: dict):
|
|
"""Internal helper for serial/dispatcher unified logic."""
|
|
self._dispatch_batch([item])
|
|
|
|
def _collect_survivor(self, item: dict):
|
|
self.regional_basin.append(item)
|
|
self.regional_basin_bytes += int(item.get("source_bytes", PHYSICAL_SWEEP_CHUNK_BYTES))
|
|
if self._should_flush_regional_basin():
|
|
self._flush_regional_basin()
|
|
|
|
def _should_flush_regional_basin(self) -> bool:
|
|
return (
|
|
len(self.regional_basin) >= PROMOTION_BATCH_MAX_RECORDS
|
|
or self.regional_basin_bytes >= PROMOTION_BATCH_MAX_BYTES
|
|
)
|
|
|
|
def _flush_regional_basin(self):
|
|
if not self.regional_basin:
|
|
return
|
|
basin = self.regional_basin
|
|
self.regional_basin = []
|
|
self.regional_basin_bytes = 0
|
|
self.batch_flushes += 1
|
|
self._dispatch_batch(basin)
|
|
|
|
def _dispatch_batch(self, items: List[dict]):
|
|
committed = self._commit_regional_basin(items)
|
|
self._audit_committed_batch(committed, items)
|
|
|
|
def _build_batch_witness_metadata(self, items: List[dict]) -> dict:
|
|
if not items:
|
|
return {}
|
|
|
|
offsets = [int(item.get("offset", 0)) for item in items]
|
|
sizes = [
|
|
int(item.get("source_bytes", PHYSICAL_SWEEP_CHUNK_BYTES)) for item in items
|
|
]
|
|
offset_end_exclusive = max(
|
|
offset + size for offset, size in zip(offsets, sizes)
|
|
)
|
|
|
|
strategy_counts = {}
|
|
confidence_values = []
|
|
primary_values = []
|
|
residual_values = []
|
|
terminal_count = 0
|
|
secondary_check_count = 0
|
|
|
|
for item in items:
|
|
encoding = item.get("encoding") or {}
|
|
if not isinstance(encoding, dict):
|
|
continue
|
|
strategy = str(encoding.get("strategy", "UNKNOWN"))
|
|
strategy_counts[strategy] = strategy_counts.get(strategy, 0) + 1
|
|
if "confidence" in encoding:
|
|
confidence_values.append(float(encoding["confidence"]))
|
|
if "primary_amp" in encoding:
|
|
primary_values.append(float(encoding["primary_amp"]))
|
|
if "residual" in encoding:
|
|
residual_values.append(float(encoding["residual"]))
|
|
if encoding.get("is_terminal"):
|
|
terminal_count += 1
|
|
if encoding.get("secondary_check"):
|
|
secondary_check_count += 1
|
|
|
|
def mean(values: List[float]) -> float:
|
|
if not values:
|
|
return 0.0
|
|
return round(sum(values) / len(values), 4)
|
|
|
|
return {
|
|
"sweep_window": {
|
|
"offset_start": min(offsets),
|
|
"offset_end_exclusive": offset_end_exclusive,
|
|
"source_bytes_total": sum(sizes),
|
|
},
|
|
"source_offsets": offsets,
|
|
"cmyk_composition": {
|
|
"strategy_counts": strategy_counts,
|
|
"terminal_count": terminal_count,
|
|
"secondary_check_count": secondary_check_count,
|
|
"mean_confidence": mean(confidence_values),
|
|
"mean_primary_amp": mean(primary_values),
|
|
"mean_residual": mean(residual_values),
|
|
},
|
|
}
|
|
|
|
def _commit_regional_basin(self, items: List[dict]) -> List[int]:
|
|
conn = self._get_conn()
|
|
committed = []
|
|
try:
|
|
for local_index, item in enumerate(items):
|
|
shell = item["shell"]
|
|
offset = item["offset"]
|
|
expert = self.experts[(self.axiom_count + local_index) % len(self.experts)]
|
|
parent_indices = self._get_optimal_parents_conn(conn, count=4)
|
|
|
|
dag_node = self.encoder.as_dag_node(shell)
|
|
payload = json.dumps({
|
|
"agent": expert,
|
|
"context": f"Sweep offset {offset}",
|
|
"topology": dag_node["topology"],
|
|
"anchor": dag_node["anchor"],
|
|
"cmyk": item.get("encoding"),
|
|
"tracker": {
|
|
"signal": item.get("confidence", 0.5),
|
|
"stress": self.arbiter.total_stress,
|
|
"conductance": 1100.0 # theta-TaN scale
|
|
}
|
|
})
|
|
|
|
idx = self._tardy_append_conn(conn, payload, parent_indices)
|
|
committed.append(idx)
|
|
|
|
conn.commit()
|
|
return committed
|
|
finally:
|
|
conn.close()
|
|
|
|
def _audit_committed_batch(self, indices: List[int], items: List[dict]):
|
|
report = None
|
|
root_record = None
|
|
batch_root_idx = None
|
|
batch_metadata = self._build_batch_witness_metadata(items)
|
|
if hasattr(self.warden, "attest_batch_report"):
|
|
report = self.warden.attest_batch_report(
|
|
self.db_path,
|
|
indices,
|
|
target_level=4, # Phase 11: Level 4 base, scaling to L8
|
|
metadata=batch_metadata,
|
|
)
|
|
batch_root_idx = report.get("batch_root_idx")
|
|
if report.get("records"):
|
|
root_record = report["records"][0]
|
|
root_accepted = bool(root_record and root_record.get("accepted"))
|
|
verdicts = [root_accepted for _ in indices]
|
|
elif hasattr(self.warden, "attest_batch"):
|
|
verdicts = self.warden.attest_batch(self.db_path, indices, target_level=4)
|
|
else:
|
|
verdicts = [self.warden.attest(self.db_path, idx, target_level=4) for idx in indices]
|
|
|
|
if report is not None:
|
|
if root_record and root_record.get("accepted") and batch_root_idx is not None:
|
|
self._promote_record(int(batch_root_idx))
|
|
self.axiom_count += len(indices)
|
|
if self.axiom_count % 50 == 0:
|
|
tail_offset = items[-1]["offset"] if items else 0
|
|
print(f"[archivist] Swept {tail_offset // 1024} KB | Axioms Accumulated: {self.axiom_count}")
|
|
return
|
|
|
|
reason = "batch_root_veto"
|
|
if root_record and root_record.get("error"):
|
|
reason = str(root_record["error"])
|
|
for idx, item in zip(indices, items):
|
|
self.survivor_queue.append({
|
|
"idx": idx,
|
|
"offset": item["offset"],
|
|
"reason": reason,
|
|
"item": item,
|
|
"batch_root_idx": batch_root_idx,
|
|
})
|
|
return
|
|
|
|
for idx, item, accepted in zip(indices, items, verdicts):
|
|
if accepted:
|
|
self._promote_record(idx)
|
|
self.axiom_count += 1
|
|
if self.axiom_count % 50 == 0:
|
|
print(f"[archivist] Swept {item['offset'] // 1024} KB | Axioms Accumulated: {self.axiom_count}")
|
|
else:
|
|
self.survivor_queue.append({
|
|
"idx": idx,
|
|
"offset": item["offset"],
|
|
"reason": "warden_veto",
|
|
"item": item,
|
|
"batch_root_idx": None,
|
|
})
|
|
|
|
def _promote_record(self, leaf_idx: int):
|
|
self.bm.promote_to_axiom(leaf_idx)
|
|
|
|
def _get_optimal_parents_conn(self, conn: sqlite3.Connection, count: int = 2) -> List[int]:
|
|
latest = conn.execute("SELECT leaf_idx FROM mmr ORDER BY leaf_idx DESC LIMIT 1").fetchone()
|
|
if not latest:
|
|
return []
|
|
|
|
parents = [latest[0]]
|
|
if count <= 1:
|
|
return parents
|
|
|
|
current_parents_data = conn.execute(
|
|
"SELECT payload FROM mmr WHERE leaf_idx = ?", (latest[0],)
|
|
).fetchone()
|
|
|
|
current_domain = "unknown"
|
|
if current_parents_data:
|
|
try:
|
|
current_domain = json.loads(current_parents_data[0]).get("agent", "unknown").lower()
|
|
except Exception:
|
|
current_domain = "unknown"
|
|
|
|
candidates = conn.execute(
|
|
"SELECT leaf_idx, payload FROM mmr WHERE leaf_idx != ? AND leaf_type = 'ADD' "
|
|
"ORDER BY leaf_idx DESC LIMIT 50",
|
|
(latest[0],)
|
|
).fetchall()
|
|
|
|
selected_domains = {current_domain}
|
|
for idx, payload in candidates:
|
|
if len(parents) >= count:
|
|
break
|
|
try:
|
|
domain = json.loads(payload).get("agent", "unknown").lower()
|
|
if domain not in selected_domains:
|
|
parents.append(idx)
|
|
selected_domains.add(domain)
|
|
except Exception:
|
|
if len(parents) < count:
|
|
parents.append(idx)
|
|
|
|
return sorted(list(set(parents)))
|
|
|
|
def _handle_completed(self, futures: List[concurrent.futures.Future], wait: bool = False):
|
|
"""Collects survivors from triage and pushes to dispatch queue."""
|
|
finished = []
|
|
for f in (futures if wait else [f for f in futures if f.done()]):
|
|
try:
|
|
result = f.result()
|
|
if result:
|
|
self.dispatch_queue.put(result)
|
|
except Exception as e:
|
|
print(f"[archivist] Worker Fault: {e}")
|
|
finished.append(f)
|
|
|
|
for f in finished:
|
|
futures.remove(f)
|
|
|
|
def _dispatcher_loop(self):
|
|
"""L2 Dispatcher thread (Serial SQLite Writer)"""
|
|
while not self.stop_signal.is_set() or not self.dispatch_queue.empty():
|
|
try:
|
|
item = self.dispatch_queue.get(timeout=1)
|
|
self._collect_survivor(item)
|
|
except queue.Empty:
|
|
continue
|
|
self._flush_regional_basin()
|
|
|
|
def _simulate_manifold(self, chunk: bytes, offset: int) -> dict:
|
|
"""Simulates the manifold state for a chunk of data."""
|
|
# Use hashing to create a deterministic but 'noisy' manifold
|
|
h = hashlib.sha256(chunk).digest()
|
|
phi_corr = 0.35 + (h[0] % 120) / 1000.0 # Force into Seismic [0.35, 0.47)
|
|
|
|
return {
|
|
"phi_corr": phi_corr,
|
|
"radius": 1.0 + (h[1] % 100) / 100.0,
|
|
"torsion_gradient": [float(x) / 128.0 for x in h] * 10 # 320 samples
|
|
}
|
|
|
|
def _tardy_append(self, payload: str, parents: List[int]) -> int:
|
|
"""Manual append to the Tardy MMR with multi-parent braiding."""
|
|
conn = self._get_conn()
|
|
try:
|
|
idx = self._tardy_append_conn(conn, payload, parents)
|
|
conn.commit()
|
|
return idx
|
|
finally:
|
|
conn.close()
|
|
|
|
def _tardy_append_conn(self, conn: sqlite3.Connection, payload: str, parents: List[int]) -> int:
|
|
"""Append to the Tardy MMR using an existing transaction."""
|
|
# Monotone counter
|
|
row = conn.execute("SELECT COALESCE(MAX(leaf_idx), -1) FROM mmr").fetchone()
|
|
idx = row[0] + 1
|
|
|
|
# Simple hashes for the mock sweep
|
|
leaf_hash = hashlib.sha256(payload.encode()).hexdigest()
|
|
root_hash = hashlib.sha256(f"{idx}|{leaf_hash}".encode()).hexdigest()
|
|
|
|
conn.execute(
|
|
"INSERT INTO mmr (leaf_idx, leaf_type, payload, leaf_hash, root_hash, ts, node_id, sig) "
|
|
"VALUES (?, 'ADD', ?, ?, ?, ?, 'archivist', 'sig')",
|
|
(idx, payload, leaf_hash, root_hash, str(time.time()))
|
|
)
|
|
|
|
for p_idx in parents:
|
|
conn.execute(
|
|
"INSERT INTO mmr_parents (child_idx, parent_idx) VALUES (?,?)",
|
|
(idx, p_idx)
|
|
)
|
|
|
|
return idx
|
|
|
|
if __name__ == "__main__":
|
|
import argparse
|
|
parser = argparse.ArgumentParser(description="Sovereign Mass Archivist")
|
|
parser.add_argument("source", nargs="?", default=str(DEFAULT_SOURCE))
|
|
parser.add_argument("max_bytes", type=int, nargs="?", default=1024 * 1024 * 1024)
|
|
parser.add_argument("--workers", type=int, default=16)
|
|
args = parser.parse_args()
|
|
|
|
archivist = MassArchivist()
|
|
archivist.run_sweep(args.source, args.max_bytes, workers=args.workers)
|