package hapui

import (
	"bufio"
	"context"
	"crypto/rand"
	"encoding/json"
	"fmt"
	"html/template"
	"math/big"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"chorus/internal/runtime"
	"chorus/pkg/hmmm"
	"chorus/pkg/ucxl"
	"chorus/pkg/storage"
	"chorus/pubsub"
)

// TerminalInterface provides an interactive terminal interface for human agents
type TerminalInterface struct {
	runtime              *runtime.SharedRuntime
	scanner              *bufio.Scanner
	quit                 chan bool
	collaborativeSession *CollaborativeSession
	hmmmMessageCount     int
	webServer            *http.Server
}

// CollaborativeSession represents an active collaborative editing session
type CollaborativeSession struct {
	SessionID    string
	Owner        string
	Participants []string
	Status       string
	CreatedAt    time.Time
}

// Decision represents a network decision awaiting votes
type Decision struct {
	ID          string                 `json:"id"`
	Title       string                 `json:"title"`
	Description string                 `json:"description"`
	Type        string                 `json:"type"`
	Proposer    string                 `json:"proposer"`
	ProposerType string                `json:"proposer_type"`
	CreatedAt   time.Time              `json:"created_at"`
	Deadline    time.Time              `json:"deadline"`
	Status      string                 `json:"status"`
	Votes       map[string]DecisionVote `json:"votes"`
	Metadata    map[string]interface{} `json:"metadata"`
	Version     int                    `json:"version"`
}

// DecisionVote represents a single vote on a decision
type DecisionVote struct {
	VoterID    string    `json:"voter_id"`
	VoterType  string    `json:"voter_type"`
	Vote       string    `json:"vote"` // approve, reject, defer, abstain
	Reasoning  string    `json:"reasoning"`
	Timestamp  time.Time `json:"timestamp"`
	Confidence float64   `json:"confidence"` // 0.0-1.0 confidence in vote
}

// NewTerminalInterface creates a new terminal interface for HAP
func NewTerminalInterface(runtime *runtime.SharedRuntime) *TerminalInterface {
	return &TerminalInterface{
		runtime: runtime,
		scanner: bufio.NewScanner(os.Stdin),
		quit:    make(chan bool),
	}
}

// Start begins the interactive terminal session
func (t *TerminalInterface) Start() error {
	t.printWelcomeMessage()
	t.printHelp()

	// Announce human agent presence
	if err := t.announceHumanAgent(); err != nil {
		t.runtime.Logger.Error("Failed to announce human agent presence: %v", err)
	}

	// Start command processing loop
	go t.commandLoop()

	// Wait for quit signal
	<-t.quit
	return nil
}

// Stop terminates the terminal interface
func (t *TerminalInterface) Stop() {
	close(t.quit)
}

// printWelcomeMessage displays the HAP welcome screen
func (t *TerminalInterface) printWelcomeMessage() {
	fmt.Println("\n" + strings.Repeat("=", 80))
	fmt.Println("🎭 CHORUS Human Agent Portal (HAP) - Terminal Interface")
	fmt.Println(strings.Repeat("=", 80))
	fmt.Printf("Agent ID: %s\n", t.runtime.Config.Agent.ID)
	fmt.Printf("P2P Node: %s\n", t.runtime.Node.ID().ShortString())
	fmt.Printf("Connected to: %d peers\n", t.runtime.Node.ConnectedPeers())
	fmt.Println("\nYou are now connected to the CHORUS P2P agent network as a human participant.")
	fmt.Println("You can collaborate with autonomous agents using the same protocols.")
	fmt.Println(strings.Repeat("=", 80) + "\n")
}

// printHelp displays available commands
func (t *TerminalInterface) printHelp() {
	fmt.Println("Available Commands:")
	fmt.Println("  help              - Show this help message")
	fmt.Println("  status            - Show network and agent status") 
	fmt.Println("  peers             - List connected P2P peers")
	fmt.Println("  hmmm              - Compose and send HMMM reasoning message")
	fmt.Println("  ucxl <address>    - Browse UCXL context address")
	fmt.Println("  patch             - Create and submit patches")
	fmt.Println("  collab            - Collaborative editing sessions")
	fmt.Println("  decide <topic>    - Participate in distributed decision")
	fmt.Println("  web               - Start web bridge for browser access")
	fmt.Println("  announce          - Re-announce human agent presence")
	fmt.Println("  quit              - Exit HAP terminal")
	fmt.Println()
}

// commandLoop handles user input and command processing
func (t *TerminalInterface) commandLoop() {
	for {
		fmt.Print("hap> ")
		
		if !t.scanner.Scan() {
			// EOF or error
			break
		}

		input := strings.TrimSpace(t.scanner.Text())
		if input == "" {
			continue
		}

		parts := strings.Fields(input)
		command := strings.ToLower(parts[0])

		switch command {
		case "help", "h":
			t.printHelp()

		case "status", "s":
			t.printStatus()

		case "peers":
			t.listPeers()

		case "hmmm", "m":
			t.handleHMMMCommand(parts[1:])

		case "ucxl", "u":
			if len(parts) < 2 {
				fmt.Println("Usage: ucxl <address>")
				continue
			}
			t.handleUCXLCommand(parts[1])

		case "patch", "p":
			t.handlePatchCommand()

		case "collab", "c":
			t.handleCollaborativeEditingCommand()

		case "decide", "d":
			if len(parts) < 2 {
				fmt.Println("Usage: decide <topic>")
				continue
			}
			topic := strings.Join(parts[1:], " ")
			t.handleDecisionCommand(topic)

		case "web", "w":
			t.startWebBridge()

		case "announce", "a":
			if err := t.announceHumanAgent(); err != nil {
				fmt.Printf("Failed to announce presence: %v\n", err)
			} else {
				fmt.Println("✅ Human agent presence announced to network")
			}

		case "quit", "q", "exit":
			fmt.Println("👋 Goodbye! Disconnecting from CHORUS network...")
			t.quit <- true
			return

		case "clear", "cls":
			// Clear screen (works on most terminals)
			fmt.Print("\033[2J\033[H")
			t.printWelcomeMessage()

		default:
			fmt.Printf("Unknown command: %s\n", command)
			fmt.Println("Type 'help' for available commands.")
		}
	}
}

// printStatus displays current network and agent status
func (t *TerminalInterface) printStatus() {
	fmt.Println("\n📊 HAP Status Report")
	fmt.Println(strings.Repeat("-", 40))
	
	// Agent Info
	fmt.Printf("Agent ID: %s\n", t.runtime.Config.Agent.ID)
	fmt.Printf("Agent Role: %s\n", t.runtime.Config.Agent.Role)
	fmt.Printf("Agent Type: Human (HAP)\n")
	
	// P2P Network Status
	fmt.Printf("Node ID: %s\n", t.runtime.Node.ID().ShortString())
	fmt.Printf("Connected Peers: %d\n", t.runtime.Node.ConnectedPeers())
	
	// Task Status
	activeTasks := t.runtime.TaskTracker.GetActiveTasks()
	maxTasks := t.runtime.TaskTracker.GetMaxTasks()
	fmt.Printf("Active Tasks: %d/%d\n", len(activeTasks), maxTasks)
	
	// DHT Status
	if t.runtime.DHTNode != nil {
		fmt.Printf("DHT: ✅ Connected\n")
	} else {
		fmt.Printf("DHT: ❌ Disabled\n")
	}
	
	// BACKBEAT Status
	if t.runtime.BackbeatIntegration != nil {
		health := t.runtime.BackbeatIntegration.GetHealth()
		if connected, ok := health["connected"].(bool); ok && connected {
			fmt.Printf("BACKBEAT: ✅ Connected\n")
		} else {
			fmt.Printf("BACKBEAT: ⚠️ Disconnected\n")
		}
	} else {
		fmt.Printf("BACKBEAT: ❌ Disabled\n")
	}
	
	fmt.Println(strings.Repeat("-", 40))
	fmt.Printf("Last Updated: %s\n\n", time.Now().Format("15:04:05"))
}

// listPeers displays connected P2P peers
func (t *TerminalInterface) listPeers() {
	peerCount := t.runtime.Node.ConnectedPeers()
	fmt.Printf("\n🔗 Connected P2P Peers (%d)\n", peerCount)
	fmt.Println(strings.Repeat("-", 50))
	
	if peerCount == 0 {
		fmt.Println("No peers connected.")
		fmt.Println("Ensure other CHORUS agents are running on the network.")
	} else {
		fmt.Printf("Connected to %d peer(s) in the CHORUS network.\n", peerCount)
		fmt.Println("Use P2P discovery mechanisms to find autonomous agents.")
	}
	fmt.Println()
}

// announceHumanAgent broadcasts human agent presence to the network
func (t *TerminalInterface) announceHumanAgent() error {
	presence := map[string]interface{}{
		"agent_id":    t.runtime.Config.Agent.ID,
		"node_id":     t.runtime.Node.ID().ShortString(),
		"agent_type":  "human",
		"interface":   "terminal",
		"capabilities": []string{
			"hmmm_reasoning",
			"decision_making", 
			"context_browsing",
			"collaborative_editing",
		},
		"human_operator": true,
		"timestamp":      time.Now().Unix(),
		"status":         "online",
	}

	// Publish to capability broadcast topic
	if err := t.runtime.PubSub.PublishBzzzMessage(pubsub.CapabilityBcast, presence); err != nil {
		return fmt.Errorf("failed to publish human agent announcement: %w", err)
	}

	t.runtime.Logger.Info("👤 Human agent presence announced to network")
	return nil
}

// handleHMMMCommand processes HMMM reasoning message composition
func (t *TerminalInterface) handleHMMMCommand(args []string) {
	fmt.Println("\n📝 HMMM (Human-Machine-Machine-Machine) Message Composer")
	fmt.Println(strings.Repeat("-", 60))
	
	for {
		fmt.Println("\nHMMM Commands:")
		fmt.Println("  new     - Compose new reasoning message")
		fmt.Println("  reply   - Reply to existing HMMM thread")
		fmt.Println("  query   - Ask network for reasoning help")
		fmt.Println("  decide  - Propose decision with reasoning")
		fmt.Println("  help    - Show detailed HMMM help")
		fmt.Println("  back    - Return to main HAP menu")
		
		fmt.Print("\nhmmm> ")
		reader := bufio.NewReader(os.Stdin)
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("Error reading input: %v\n", err)
			continue
		}
		
		input = strings.TrimSpace(input)
		if input == "" {
			continue
		}
		
		if input == "back" || input == "exit" {
			break
		}
		
		switch input {
		case "help":
			t.showHMMMHelp()
		case "new":
			t.composeNewHMMMMessage()
		case "reply":
			t.composeHMMMReply()
		case "query":
			t.composeHMMMQuery()
		case "decide":
			t.composeHMMMDecision()
		default:
			fmt.Println("Unknown HMMM command. Type 'help' for available commands.")
		}
	}
}

// handleUCXLCommand processes UCXL context browsing
func (t *TerminalInterface) handleUCXLCommand(address string) {
	fmt.Printf("\n🔗 UCXL Context Browser\n")
	fmt.Println(strings.Repeat("-", 50))
	
	// Parse the UCXL address
	parsed, err := ucxl.ParseUCXLAddress(address)
	if err != nil {
		fmt.Printf("❌ Invalid UCXL address: %v\n", err)
		fmt.Println("\nValid format: ucxl://agent:role@project:task/path*temporal/")
		fmt.Println("Example: ucxl://alice:dev@myproject:task123/docs/readme.md*^/")
		t.showUCXLHelp()
		return
	}
	
	fmt.Printf("📍 Address: %s\n", parsed.Raw)
	fmt.Printf("🤖 Agent: %s\n", parsed.Agent)
	fmt.Printf("🎭 Role: %s\n", parsed.Role)
	fmt.Printf("📁 Project: %s\n", parsed.Project)
	fmt.Printf("📝 Task: %s\n", parsed.Task)
	if parsed.Path != "" {
		fmt.Printf("📄 Path: %s\n", parsed.Path)
	}
	if parsed.Temporal != "" {
		fmt.Printf("⏰ Temporal: %s\n", parsed.Temporal)
	}
	fmt.Println()
	
	// Try to retrieve content from storage
	if t.runtime.EncryptedStorage != nil {
		content, metadata, err := t.runtime.EncryptedStorage.RetrieveUCXLContent(address)
		if err != nil {
			fmt.Printf("⚠️ Failed to retrieve content: %v\n", err)
			fmt.Println("Content may not be available on this network.")
		} else {
			t.displayUCXLContent(content, metadata)
		}
	} else {
		fmt.Println("⚠️ Storage system not available")
		fmt.Println("Content retrieval requires configured DHT storage")
	}
	
	// Show UCXL browser commands
	fmt.Println("\nUCXL Commands:")
	fmt.Println("  search    - Search for related content")
	fmt.Println("  related   - Find related contexts")
	fmt.Println("  history   - View address history")
	fmt.Println("  create    - Create new content at this address")
	fmt.Println("  help      - Show UCXL help")
	fmt.Println("  back      - Return to main menu")
	
	for {
		fmt.Print("\nucxl> ")
		reader := bufio.NewReader(os.Stdin)
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("Error reading input: %v\n", err)
			continue
		}
		
		input = strings.TrimSpace(input)
		if input == "" {
			continue
		}
		
		if input == "back" || input == "exit" {
			break
		}
		
		switch input {
		case "help":
			t.showUCXLHelp()
		case "search":
			t.handleUCXLSearch(parsed)
		case "related":
			t.handleUCXLRelated(parsed)
		case "history":
			t.handleUCXLHistory(parsed)
		case "create":
			t.handleUCXLCreate(parsed)
		default:
			fmt.Println("Unknown UCXL command. Type 'help' for available commands.")
		}
	}
}

// handleDecisionCommand processes decision participation
func (t *TerminalInterface) handleDecisionCommand(topic string) {
	fmt.Printf("\n🗳️ Decision Participation System\n")
	fmt.Println(strings.Repeat("-", 50))
	
	for {
		fmt.Println("\nDecision Commands:")
		fmt.Println("  list      - List active decisions")
		fmt.Println("  view <id> - View decision details")
		fmt.Println("  vote <id> - Cast vote on decision")
		fmt.Println("  propose   - Propose new decision")
		fmt.Println("  status    - Show decision system status") 
		fmt.Println("  help      - Show decision help")
		fmt.Println("  back      - Return to main menu")
		
		fmt.Print("\ndecision> ")
		reader := bufio.NewReader(os.Stdin)
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("Error reading input: %v\n", err)
			continue
		}
		
		input = strings.TrimSpace(input)
		if input == "" {
			continue
		}
		
		if input == "back" || input == "exit" {
			break
		}
		
		parts := strings.Fields(input)
		command := parts[0]
		
		switch command {
		case "help":
			t.showDecisionHelp()
		case "list":
			t.listActiveDecisions()
		case "view":
			if len(parts) < 2 {
				fmt.Println("Usage: view <decision_id>")
				continue
			}
			t.viewDecision(parts[1])
		case "vote":
			if len(parts) < 2 {
				fmt.Println("Usage: vote <decision_id>")
				continue
			}
			t.castVoteOnDecision(parts[1])
		case "propose":
			t.proposeNewDecision()
		case "status":
			t.showDecisionStatus()
		default:
			fmt.Println("Unknown decision command. Type 'help' for available commands.")
		}
	}
}

// HMMM Helper Functions

// showHMMMHelp displays detailed HMMM system information
func (t *TerminalInterface) showHMMMHelp() {
	fmt.Println("\n🧠 HMMM (Human-Machine-Machine-Machine) Collaborative Reasoning")
	fmt.Println(strings.Repeat("=", 70))
	fmt.Println("HMMM enables structured collaborative reasoning between humans and AI agents.")
	fmt.Println("Messages are routed through the P2P network with rich metadata and context.")
	fmt.Println()
	
	fmt.Println("Message Types:")
	fmt.Println("  new     - Start a new reasoning thread on any topic")
	fmt.Println("  reply   - Respond to an existing thread with your reasoning")
	fmt.Println("  query   - Ask the network for help with a specific problem")
	fmt.Println("  decide  - Propose a decision that requires network consensus")
	fmt.Println()
	
	fmt.Println("Message Structure:")
	fmt.Println("  • Topic: Broad categorization (e.g., 'engineering', 'planning')")
	fmt.Println("  • Issue ID: Specific problem or discussion identifier")
	fmt.Println("  • Thread ID: Groups related messages together")
	fmt.Println("  • Message: Your human reasoning, insights, or questions")
	fmt.Println("  • Context: Links to relevant UCXL addresses or resources")
	fmt.Println()
	
	fmt.Println("Best Practices:")
	fmt.Println("  ✅ Be specific and clear in your reasoning")
	fmt.Println("  ✅ Include relevant context and background")
	fmt.Println("  ✅ Ask follow-up questions to guide discussion")
	fmt.Println("  ✅ Build on previous messages in the thread")
	fmt.Println("  ❌ Avoid vague or overly broad statements")
	fmt.Println("  ❌ Don't duplicate existing reasoning without adding value")
	fmt.Println()
}

// composeNewHMMMMessage guides the user through creating a new reasoning message
func (t *TerminalInterface) composeNewHMMMMessage() {
	fmt.Println("\n📝 New HMMM Reasoning Message")
	fmt.Println(strings.Repeat("-", 40))
	
	reader := bufio.NewReader(os.Stdin)
	
	// Collect message details
	fmt.Print("Topic (e.g., engineering, planning, architecture): ")
	topic, _ := reader.ReadString('\n')
	topic = strings.TrimSpace(topic)
	if topic == "" {
		topic = "general"
	}
	
	fmt.Print("Issue ID (number for this specific problem): ")
	issueIDStr, _ := reader.ReadString('\n')
	issueIDStr = strings.TrimSpace(issueIDStr)
	var issueID int64 = 1
	if issueIDStr != "" {
		if id, err := strconv.ParseInt(issueIDStr, 10, 64); err == nil {
			issueID = id
		}
	}
	
	fmt.Print("Subject/Title: ")
	subject, _ := reader.ReadString('\n')
	subject = strings.TrimSpace(subject)
	if subject == "" {
		fmt.Println("❌ Subject is required")
		return
	}
	
	fmt.Println("Your reasoning (press Enter twice when done):")
	var reasoning strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			reasoning.WriteString("\n")
		} else {
			emptyLines = 0
			reasoning.WriteString(line + "\n")
		}
	}
	
	if reasoning.Len() == 0 {
		fmt.Println("❌ Reasoning content is required")
		return
	}
	
	// Generate message
	msgID := t.generateMessageID()
	threadID := t.generateThreadID(topic, issueID)
	
	message := hmmm.Message{
		Topic:     fmt.Sprintf("CHORUS/hmmm/%s", topic),
		Type:      "reasoning_start",
		Payload: map[string]interface{}{
			"subject":   subject,
			"reasoning": strings.TrimSpace(reasoning.String()),
			"author":    t.runtime.Config.Agent.ID,
			"author_type": "human",
		},
		Version:   "1.0",
		IssueID:   issueID,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("New reasoning thread: %s", subject),
	}
	
	// Send message
	if err := t.sendHMMMMessage(message); err != nil {
		fmt.Printf("❌ Failed to send HMMM message: %v\n", err)
		return
	}
	
	fmt.Println("✅ HMMM reasoning message sent to network")
	fmt.Printf("   Topic: %s\n", topic)
	fmt.Printf("   Issue: #%d\n", issueID)
	fmt.Printf("   Thread: %s\n", threadID)
	fmt.Printf("   Message ID: %s\n", msgID)
	fmt.Println()
}

// composeHMMMReply guides the user through replying to an existing thread
func (t *TerminalInterface) composeHMMMReply() {
	fmt.Println("\n↩️ Reply to HMMM Thread")
	fmt.Println(strings.Repeat("-", 30))
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Thread ID to reply to: ")
	threadID, _ := reader.ReadString('\n')
	threadID = strings.TrimSpace(threadID)
	if threadID == "" {
		fmt.Println("❌ Thread ID is required")
		return
	}
	
	fmt.Print("Issue ID: ")
	issueIDStr, _ := reader.ReadString('\n')
	issueIDStr = strings.TrimSpace(issueIDStr)
	var issueID int64 = 1
	if issueIDStr != "" {
		if id, err := strconv.ParseInt(issueIDStr, 10, 64); err == nil {
			issueID = id
		}
	}
	
	fmt.Println("Your reasoning/response (press Enter twice when done):")
	var reasoning strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			reasoning.WriteString("\n")
		} else {
			emptyLines = 0
			reasoning.WriteString(line + "\n")
		}
	}
	
	if reasoning.Len() == 0 {
		fmt.Println("❌ Response content is required")
		return
	}
	
	msgID := t.generateMessageID()
	
	message := hmmm.Message{
		Topic:     fmt.Sprintf("CHORUS/hmmm/thread/%s", threadID),
		Type:      "reasoning_reply",
		Payload: map[string]interface{}{
			"reasoning":     strings.TrimSpace(reasoning.String()),
			"author":        t.runtime.Config.Agent.ID,
			"author_type":   "human",
			"parent_thread": threadID,
		},
		Version:   "1.0",
		IssueID:   issueID,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   "Human agent reasoning response",
	}
	
	if err := t.sendHMMMMessage(message); err != nil {
		fmt.Printf("❌ Failed to send HMMM reply: %v\n", err)
		return
	}
	
	fmt.Println("✅ HMMM reply sent to thread")
	fmt.Printf("   Thread: %s\n", threadID)
	fmt.Printf("   Message ID: %s\n", msgID)
	fmt.Println()
}

// composeHMMMQuery guides the user through asking for reasoning help
func (t *TerminalInterface) composeHMMMQuery() {
	fmt.Println("\n❓ HMMM Network Query")
	fmt.Println(strings.Repeat("-", 25))
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Query topic (e.g., technical, planning): ")
	topic, _ := reader.ReadString('\n')
	topic = strings.TrimSpace(topic)
	if topic == "" {
		topic = "general"
	}
	
	fmt.Print("Issue ID (or press Enter for new): ")
	issueIDStr, _ := reader.ReadString('\n')
	issueIDStr = strings.TrimSpace(issueIDStr)
	var issueID int64
	if issueIDStr != "" {
		if id, err := strconv.ParseInt(issueIDStr, 10, 64); err == nil {
			issueID = id
		}
	} else {
		// Generate new issue ID
		issueID = time.Now().Unix() % 10000
	}
	
	fmt.Print("Your question/problem: ")
	question, _ := reader.ReadString('\n')
	question = strings.TrimSpace(question)
	if question == "" {
		fmt.Println("❌ Question is required")
		return
	}
	
	fmt.Println("Additional context (press Enter twice when done, or just Enter to skip):")
	var context strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			if context.Len() > 0 {
				context.WriteString("\n")
			}
		} else {
			emptyLines = 0
			if context.Len() > 0 {
				context.WriteString(" ")
			}
			context.WriteString(line)
		}
	}
	
	msgID := t.generateMessageID()
	threadID := t.generateThreadID(topic, issueID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/hmmm/query/%s", topic),
		Type:    "reasoning_query",
		Payload: map[string]interface{}{
			"question":    question,
			"context":     context.String(),
			"author":      t.runtime.Config.Agent.ID,
			"author_type": "human",
			"urgency":     "normal",
		},
		Version:   "1.0",
		IssueID:   issueID,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Human query: %s", question),
	}
	
	if err := t.sendHMMMMessage(message); err != nil {
		fmt.Printf("❌ Failed to send HMMM query: %v\n", err)
		return
	}
	
	fmt.Println("✅ HMMM query sent to network")
	fmt.Printf("   Waiting for agent responses on issue #%d\n", issueID)
	fmt.Printf("   Thread: %s\n", threadID)
	fmt.Printf("   Message ID: %s\n", msgID)
	fmt.Println()
}

// composeHMMMDecision guides the user through proposing a decision
func (t *TerminalInterface) composeHMMMDecision() {
	fmt.Println("\n🗳️ Propose Network Decision")
	fmt.Println(strings.Repeat("-", 30))
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Decision topic: ")
	topic, _ := reader.ReadString('\n')
	topic = strings.TrimSpace(topic)
	if topic == "" {
		topic = "general"
	}
	
	fmt.Print("Decision title: ")
	title, _ := reader.ReadString('\n')
	title = strings.TrimSpace(title)
	if title == "" {
		fmt.Println("❌ Decision title is required")
		return
	}
	
	fmt.Println("Decision rationale (press Enter twice when done):")
	var rationale strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			rationale.WriteString("\n")
		} else {
			emptyLines = 0
			rationale.WriteString(line + "\n")
		}
	}
	
	if rationale.Len() == 0 {
		fmt.Println("❌ Rationale is required")
		return
	}
	
	fmt.Print("Options (comma-separated, e.g., 'approve,reject,defer'): ")
	optionsStr, _ := reader.ReadString('\n')
	optionsStr = strings.TrimSpace(optionsStr)
	options := strings.Split(optionsStr, ",")
	if len(options) == 0 {
		options = []string{"approve", "reject"}
	}
	for i := range options {
		options[i] = strings.TrimSpace(options[i])
	}
	
	issueID := time.Now().Unix() % 10000
	msgID := t.generateMessageID()
	threadID := t.generateThreadID("decision", issueID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/hmmm/decision/%s", topic),
		Type:    "decision_proposal",
		Payload: map[string]interface{}{
			"title":       title,
			"rationale":   strings.TrimSpace(rationale.String()),
			"options":     options,
			"proposer":    t.runtime.Config.Agent.ID,
			"author_type": "human",
			"deadline":    time.Now().Add(24 * time.Hour).Unix(),
		},
		Version:   "1.0",
		IssueID:   issueID,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Decision proposal: %s", title),
	}
	
	if err := t.sendHMMMMessage(message); err != nil {
		fmt.Printf("❌ Failed to send decision proposal: %v\n", err)
		return
	}
	
	fmt.Println("✅ Decision proposal sent to network")
	fmt.Printf("   Title: %s\n", title)
	fmt.Printf("   Issue: #%d\n", issueID)
	fmt.Printf("   Options: %s\n", strings.Join(options, ", "))
	fmt.Printf("   Thread: %s\n", threadID)
	fmt.Printf("   Deadline: 24 hours from now\n")
	fmt.Println()
}

// Helper functions for HMMM message management

// sendHMMMMessage sends an HMMM message through the P2P network
func (t *TerminalInterface) sendHMMMMessage(message hmmm.Message) error {
	router := hmmm.NewRouter(t.runtime.PubSub)
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	
	return router.Publish(ctx, message)
}

// generateMessageID creates a unique message identifier
func (t *TerminalInterface) generateMessageID() string {
	// Generate a random component
	randomNum, _ := rand.Int(rand.Reader, big.NewInt(999999))
	timestamp := time.Now().UnixNano()
	return fmt.Sprintf("hap-%d-%06d", timestamp/1000000, randomNum.Int64())
}

// generateThreadID creates a thread identifier for grouping related messages
func (t *TerminalInterface) generateThreadID(topic string, issueID int64) string {
	hash := fmt.Sprintf("%s-%d-%d", topic, issueID, time.Now().Unix()/3600) // Hour-based grouping
	return fmt.Sprintf("thread-%x", hash)
}

// UCXL Helper Functions

// showUCXLHelp displays detailed UCXL system information
func (t *TerminalInterface) showUCXLHelp() {
	fmt.Println("\n🗺️ UCXL (Universal Context Exchange Language)")
	fmt.Println(strings.Repeat("=", 60))
	fmt.Println("UCXL provides addressing and navigation for distributed contexts.")
	fmt.Println("Each address uniquely identifies content, resources, or state.")
	fmt.Println()
	
	fmt.Println("Address Format:")
	fmt.Println("  ucxl://agent:role@project:task/path*temporal/")
	fmt.Println()
	
	fmt.Println("Components:")
	fmt.Println("  agent    - Agent ID or '*' for wildcard")
	fmt.Println("  role     - Agent role (dev, admin, user, etc.)")
	fmt.Println("  project  - Project identifier")
	fmt.Println("  task     - Task or issue identifier")  
	fmt.Println("  path     - Optional resource path")
	fmt.Println("  temporal - Optional time navigation")
	fmt.Println()
	
	fmt.Println("Temporal Navigation:")
	fmt.Println("  *^/      - Latest version")
	fmt.Println("  *~/      - Earliest version")
	fmt.Println("  *@1234/  - Specific timestamp")
	fmt.Println("  *~5/     - 5 versions back")
	fmt.Println("  *^3/     - 3 versions forward")
	fmt.Println()
	
	fmt.Println("Examples:")
	fmt.Println("  ucxl://alice:dev@webapp:frontend/src/components/")
	fmt.Println("  ucxl://*:*@project123:bug456/logs/error.log*^/")
	fmt.Println("  ucxl://bob:admin@infra:deploy/config/prod.yml*@1609459200/")
	fmt.Println()
}

// displayUCXLContent shows retrieved content with metadata
func (t *TerminalInterface) displayUCXLContent(content []byte, metadata *storage.UCXLMetadata) {
	fmt.Println("📦 Content Found:")
	fmt.Println(strings.Repeat("-", 30))
	
	if metadata != nil {
		fmt.Printf("📄 Type: %s\n", metadata.ContentType)
		fmt.Printf("👤 Creator: %s\n", metadata.CreatorRole)
		fmt.Printf("📅 Created: %s\n", metadata.CreatedAt.Format("2006-01-02 15:04:05"))
		fmt.Printf("📏 Size: %d bytes\n", metadata.Size)
		if metadata.Encrypted {
			fmt.Printf("🔒 Encrypted: Yes\n")
		}
		fmt.Println()
	}
	
	// Show content preview
	contentStr := string(content)
	if len(contentStr) > 1000 {
		fmt.Printf("📖 Content Preview (first 1000 chars):\n%s\n...(truncated)\n", contentStr[:1000])
	} else {
		fmt.Printf("📖 Content:\n%s\n", contentStr)
	}
	fmt.Println()
}

// handleUCXLSearch searches for related UCXL content
func (t *TerminalInterface) handleUCXLSearch(parsed *ucxl.UCXLAddress) {
	fmt.Println("\n🔍 Search UCXL Content")
	fmt.Println(strings.Repeat("-", 30))
	
	if t.runtime.EncryptedStorage == nil {
		fmt.Println("❌ Storage system not available")
		return
	}
	
	reader := bufio.NewReader(os.Stdin)
	
	// Build search query from current address
	query := &storage.SearchQuery{
		Agent:   parsed.Agent,
		Role:    parsed.Role,
		Project: parsed.Project,
		Task:    parsed.Task,
		Limit:   20,
	}
	
	// Allow user to modify search criteria
	fmt.Print("Search agent (current: " + parsed.Agent + ", or press Enter): ")
	input, _ := reader.ReadString('\n')
	input = strings.TrimSpace(input)
	if input != "" {
		query.Agent = input
	}
	
	fmt.Print("Search role (current: " + parsed.Role + ", or press Enter): ")
	input, _ = reader.ReadString('\n')
	input = strings.TrimSpace(input)
	if input != "" {
		query.Role = input
	}
	
	fmt.Print("Search project (current: " + parsed.Project + ", or press Enter): ")
	input, _ = reader.ReadString('\n')
	input = strings.TrimSpace(input)
	if input != "" {
		query.Project = input
	}
	
	fmt.Print("Content type filter (optional): ")
	contentType, _ := reader.ReadString('\n')
	contentType = strings.TrimSpace(contentType)
	if contentType != "" {
		query.ContentType = contentType
	}
	
	// Perform search
	results, err := t.runtime.EncryptedStorage.SearchContent(query)
	if err != nil {
		fmt.Printf("❌ Search failed: %v\n", err)
		return
	}
	
	fmt.Printf("\n📋 Found %d results:\n", len(results))
	fmt.Println(strings.Repeat("-", 50))
	
	for i, result := range results {
		fmt.Printf("%d. %s\n", i+1, result.Address)
		fmt.Printf("   📄 Type: %s | 👤 Creator: %s | 📅 %s\n", 
			result.ContentType, 
			result.CreatorRole,
			result.CreatedAt.Format("2006-01-02 15:04"))
		fmt.Println()
	}
}

// handleUCXLRelated finds content related to the current address
func (t *TerminalInterface) handleUCXLRelated(parsed *ucxl.UCXLAddress) {
	fmt.Println("\n🔗 Find Related Content")
	fmt.Println(strings.Repeat("-", 25))
	
	if t.runtime.EncryptedStorage == nil {
		fmt.Println("❌ Storage system not available")
		return
	}
	
	// Search for content with same project and task
	query := &storage.SearchQuery{
		Agent:   "*",
		Role:    "*",
		Project: parsed.Project,
		Task:    parsed.Task,
		Limit:   10,
	}
	
	results, err := t.runtime.EncryptedStorage.SearchContent(query)
	if err != nil {
		fmt.Printf("❌ Related search failed: %v\n", err)
		return
	}
	
	fmt.Printf("📊 Related content in %s:%s:\n", parsed.Project, parsed.Task)
	fmt.Println(strings.Repeat("-", 40))
	
	for i, result := range results {
		if result.Address == parsed.Raw {
			continue // Skip current address
		}
		
		fmt.Printf("%d. %s\n", i+1, result.Address)
		fmt.Printf("   👤 %s | 📄 %s | 📅 %s\n", 
			result.CreatorRole,
			result.ContentType,
			result.CreatedAt.Format("Jan 02, 15:04"))
	}
	
	if len(results) <= 1 {
		fmt.Println("No related content found.")
		fmt.Println("Try creating content or using broader search terms.")
	}
	fmt.Println()
}

// handleUCXLHistory shows version history for the address
func (t *TerminalInterface) handleUCXLHistory(parsed *ucxl.UCXLAddress) {
	fmt.Println("\n📜 Address History")
	fmt.Println(strings.Repeat("-", 20))
	fmt.Println("⚠️ History tracking not yet fully implemented")
	fmt.Println("This would show temporal versions of the content:")
	fmt.Println()
	
	fmt.Printf("Base address: %s\n", parsed.Raw)
	fmt.Println("Temporal versions:")
	fmt.Printf("  Latest:    %s*^/\n", strings.TrimSuffix(parsed.Raw, "/"))
	fmt.Printf("  Earliest:  %s*~/\n", strings.TrimSuffix(parsed.Raw, "/"))
	fmt.Printf("  Previous:  %s*~1/\n", strings.TrimSuffix(parsed.Raw, "/"))
	fmt.Printf("  Timestamp: %s*@%d/\n", strings.TrimSuffix(parsed.Raw, "/"), time.Now().Unix())
	fmt.Println()
}

// handleUCXLCreate helps create new content at the address
func (t *TerminalInterface) handleUCXLCreate(parsed *ucxl.UCXLAddress) {
	fmt.Println("\n📝 Create UCXL Content")
	fmt.Println(strings.Repeat("-", 25))
	
	if t.runtime.EncryptedStorage == nil {
		fmt.Println("❌ Storage system not available")
		return
	}
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Content type (text/plain, application/json, etc.): ")
	contentType, _ := reader.ReadString('\n')
	contentType = strings.TrimSpace(contentType)
	if contentType == "" {
		contentType = "text/plain"
	}
	
	fmt.Println("Content (press Enter twice when done):")
	var content strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			content.WriteString("\n")
		} else {
			emptyLines = 0
			content.WriteString(line + "\n")
		}
	}
	
	contentBytes := []byte(strings.TrimSpace(content.String()))
	if len(contentBytes) == 0 {
		fmt.Println("❌ No content provided")
		return
	}
	
	// Store content
	err := t.runtime.EncryptedStorage.StoreUCXLContent(
		parsed.Raw,
		contentBytes,
		t.runtime.Config.Agent.Role,
		contentType,
	)
	
	if err != nil {
		fmt.Printf("❌ Failed to store content: %v\n", err)
		return
	}
	
	// Announce to network
	if err := t.runtime.EncryptedStorage.AnnounceContent(parsed.Raw); err != nil {
		fmt.Printf("⚠️ Failed to announce content: %v\n", err)
	}
	
	fmt.Println("✅ Content created successfully!")
	fmt.Printf("   Address: %s\n", parsed.Raw)
	fmt.Printf("   Type: %s\n", contentType)
	fmt.Printf("   Size: %d bytes\n", len(contentBytes))
	fmt.Println("   Content announced to P2P network")
	fmt.Println()
}

// handleCollaborativeEditingCommand processes collaborative editing sessions
func (t *TerminalInterface) handleCollaborativeEditingCommand() {
	fmt.Printf("\n👥 CHORUS Collaborative Editing System\n")
	fmt.Println(strings.Repeat("-", 50))
	
	for {
		fmt.Println("\nCollaborative Editing Commands:")
		fmt.Println("  start <address>   - Start collaborative session on UCXL address")
		fmt.Println("  join <session>    - Join existing collaborative session")
		fmt.Println("  list              - List active collaborative sessions")
		fmt.Println("  status            - Show collaborative editing status")
		fmt.Println("  leave             - Leave current collaborative session")
		fmt.Println("  help              - Show collaborative editing help")
		fmt.Println("  back              - Return to main menu")
		
		fmt.Print("\ncollab> ")
		reader := bufio.NewReader(os.Stdin)
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("Error reading input: %v\n", err)
			continue
		}
		
		input = strings.TrimSpace(input)
		if input == "" {
			continue
		}
		
		if input == "back" || input == "exit" {
			break
		}
		
		parts := strings.Fields(input)
		command := parts[0]
		
		switch command {
		case "help":
			t.showCollaborativeEditingHelp()
		case "start":
			if len(parts) < 2 {
				fmt.Println("Usage: start <ucxl_address>")
				continue
			}
			t.startCollaborativeSession(parts[1])
		case "join":
			if len(parts) < 2 {
				fmt.Println("Usage: join <session_id>")
				continue
			}
			t.joinCollaborativeSession(parts[1])
		case "list":
			t.listCollaborativeSessions()
		case "status":
			t.showCollaborativeEditingStatus()
		case "leave":
			t.leaveCollaborativeSession()
		default:
			fmt.Println("Unknown collaborative editing command. Type 'help' for available commands.")
		}
	}
}

// handlePatchCommand processes patch creation and submission workflows
func (t *TerminalInterface) handlePatchCommand() {
	fmt.Printf("\n📝 CHORUS Patch Management System\n")
	fmt.Println(strings.Repeat("-", 50))
	
	for {
		fmt.Println("\nPatch Commands:")
		fmt.Println("  create    - Create new patch from current state")
		fmt.Println("  diff      - Generate diff for context changes")
		fmt.Println("  submit    - Submit patch for review and integration")
		fmt.Println("  list      - List active patches")
		fmt.Println("  review    - Review existing patches")
		fmt.Println("  status    - Show patch system status")
		fmt.Println("  help      - Show patch system help")
		fmt.Println("  back      - Return to main menu")
		
		fmt.Print("\npatch> ")
		reader := bufio.NewReader(os.Stdin)
		input, err := reader.ReadString('\n')
		if err != nil {
			fmt.Printf("Error reading input: %v\n", err)
			continue
		}
		
		input = strings.TrimSpace(input)
		if input == "" {
			continue
		}
		
		if input == "back" || input == "exit" {
			break
		}
		
		switch input {
		case "help":
			t.showPatchHelp()
		case "create":
			t.createPatch()
		case "diff":
			t.generateDiff()
		case "submit":
			t.submitPatch()
		case "list":
			t.listPatches()
		case "review":
			t.reviewPatches()
		case "status":
			t.showPatchStatus()
		default:
			fmt.Println("Unknown patch command. Type 'help' for available commands.")
		}
	}
}

// Decision Participation Helper Functions

// showDecisionHelp displays detailed decision system information
func (t *TerminalInterface) showDecisionHelp() {
	fmt.Println("\n🗳️ CHORUS Distributed Decision System")
	fmt.Println(strings.Repeat("=", 55))
	fmt.Println("The decision system enables collaborative consensus among network participants.")
	fmt.Println("Both human agents and autonomous agents can participate in decision-making.")
	fmt.Println()
	
	fmt.Println("Decision Types:")
	fmt.Println("  • Technical: Architecture, implementation choices")
	fmt.Println("  • Operational: Resource allocation, task priority")
	fmt.Println("  • Policy: Network rules, behavioral guidelines")
	fmt.Println("  • Emergency: Urgent security or stability issues")
	fmt.Println()
	
	fmt.Println("Vote Options:")
	fmt.Println("  ✅ approve   - Support the proposed decision")
	fmt.Println("  ❌ reject    - Oppose the proposed decision")
	fmt.Println("  ⏸️ defer     - Postpone decision to gather more info")
	fmt.Println("  ⚠️ abstain   - Acknowledge but not participate")
	fmt.Println()
	
	fmt.Println("Consensus Rules:")
	fmt.Println("  • Majority approval required for most decisions")
	fmt.Println("  • Supermajority (2/3) for critical infrastructure changes")
	fmt.Println("  • Emergency decisions may have shorter time windows")
	fmt.Println("  • All votes should include reasoning/justification")
	fmt.Println()
	
	fmt.Println("Commands:")
	fmt.Println("  list      - See all active decisions awaiting votes")
	fmt.Println("  view <id> - View full decision details and current voting")
	fmt.Println("  vote <id> - Cast your vote with reasoning")
	fmt.Println("  propose   - Start a new decision for network consideration")
	fmt.Println()
}

// listActiveDecisions shows all decisions currently open for voting
func (t *TerminalInterface) listActiveDecisions() {
	fmt.Println("\n📋 Active Network Decisions")
	fmt.Println(strings.Repeat("-", 35))
	
	// Query DHT for active decisions
	decisions, err := t.getActiveDecisions()
	if err != nil {
		fmt.Printf("❌ Failed to retrieve decisions: %v\n", err)
		return
	}
	
	if len(decisions) == 0 {
		fmt.Println("✅ No active decisions requiring votes")
		fmt.Println("\n💡 Use 'propose' to create a new decision")
		return
	}
	
	fmt.Printf("Found %d active decision(s):\n\n", len(decisions))
	
	for _, decision := range decisions {
		statusEmoji := "🗳️"
		if decision.Status == "urgent" {
			statusEmoji = "🚨"
		} else if decision.Status == "closed" {
			statusEmoji = "✅"
		}
		
		// Calculate time remaining
		timeRemaining := decision.Deadline.Sub(time.Now())
		timeStr := formatDuration(timeRemaining)
		
		// Count votes
		approvals := 0
		rejections := 0
		deferrals := 0
		abstentions := 0
		
		for _, vote := range decision.Votes {
			switch vote.Vote {
			case "approve":
				approvals++
			case "reject":
				rejections++
			case "defer":
				deferrals++
			case "abstain":
				abstentions++
			}
		}
		
		fmt.Printf("%s %s - %s\n", statusEmoji, decision.ID, decision.Title)
		fmt.Printf("    📝 Type: %s | 👤 Proposer: %s (%s)\n", 
			decision.Type, decision.Proposer, decision.ProposerType)
		fmt.Printf("    ⏰ Time left: %s | 🗳️ Votes: ✅%d ❌%d ⏸️%d ⚠️%d\n", 
			timeStr, approvals, rejections, deferrals, abstentions)
		fmt.Println()
	}
	
	fmt.Println("Use 'view <id>' to see full details and cast your vote.")
	fmt.Println("Example: view DEC-001")
	fmt.Println()
}

// viewDecision shows detailed information about a specific decision
func (t *TerminalInterface) viewDecision(decisionID string) {
	fmt.Printf("\n🔍 Decision Details: %s\n", decisionID)
	fmt.Println(strings.Repeat("-", 40))
	
	decision, err := t.getDecisionByID(decisionID)
	if err != nil {
		fmt.Printf("❌ Failed to retrieve decision: %v\n", err)
		return
	}
	
	fmt.Printf("📋 Title: %s\n", decision.Title)
	fmt.Printf("🏷️ Type: %s\n", strings.Title(decision.Type))
	fmt.Printf("👤 Proposer: %s (%s)\n", decision.Proposer, decision.ProposerType)
	fmt.Printf("📅 Proposed: %s\n", decision.CreatedAt.Format("2006-01-02 15:04:05"))
	
	timeRemaining := decision.Deadline.Sub(time.Now())
	fmt.Printf("⏰ Deadline: %s (%s remaining)\n", 
		decision.Deadline.Format("2006-01-02 15:04:05"), 
		formatDuration(timeRemaining))
	
	fmt.Println()
	fmt.Println("📖 Description:")
	wrapped := wrapText(decision.Description, 60)
	for _, line := range strings.Split(wrapped, "\n") {
		fmt.Printf("   %s\n", line)
	}
	
	fmt.Println()
	fmt.Printf("🗳️ Current Voting Status (%d total votes):\n", len(decision.Votes))
	
	// Count votes by type
	approvals := 0
	rejections := 0
	deferrals := 0
	abstentions := 0
	
	for _, vote := range decision.Votes {
		switch vote.Vote {
		case "approve":
			approvals++
		case "reject":
			rejections++
		case "defer":
			deferrals++
		case "abstain":
			abstentions++
		}
	}
	
	fmt.Printf("   ✅ Approve: %d votes\n", approvals)
	fmt.Printf("   ❌ Reject:  %d votes\n", rejections)
	fmt.Printf("   ⏸️ Defer:   %d votes\n", deferrals)
	fmt.Printf("   ⚠️ Abstain: %d votes\n", abstentions)
	
	if len(decision.Votes) > 0 {
		fmt.Println("\n💭 Recent Reasoning:")
		count := 0
		for _, vote := range decision.Votes {
			if count >= 3 { // Show only last 3 votes
				break
			}
			fmt.Printf("   %s (%s): \"%s\"\n", vote.VoterID, vote.Vote, vote.Reasoning)
			count++
		}
	}
	
	// Calculate status
	totalVotes := len(decision.Votes)
	if totalVotes > 0 {
		approvalRate := float64(approvals) / float64(totalVotes) * 100
		fmt.Printf("\n🎯 Status: %.1f%% approval", approvalRate)
		if approvalRate >= 50 {
			fmt.Print(" (Passing)")
		} else {
			fmt.Print(" (Failing)")
		}
		fmt.Println()
	}
	
	// Show metadata if present
	if len(decision.Metadata) > 0 {
		fmt.Println("\n📊 Metadata:")
		for key, value := range decision.Metadata {
			fmt.Printf("   %s: %v\n", key, value)
		}
	}
	
	fmt.Println()
	fmt.Printf("To vote on this decision, use: vote %s\n", decisionID)
	fmt.Println()
}

// castVoteOnDecision guides the user through voting on a decision
func (t *TerminalInterface) castVoteOnDecision(decisionID string) {
	fmt.Printf("\n🗳️ Cast Vote on %s\n", decisionID)
	fmt.Println(strings.Repeat("-", 30))
	
	reader := bufio.NewReader(os.Stdin)
	
	// Show vote options
	fmt.Println("Vote Options:")
	fmt.Println("  1. ✅ approve  - Support this decision")
	fmt.Println("  2. ❌ reject   - Oppose this decision")  
	fmt.Println("  3. ⏸️ defer    - Need more information")
	fmt.Println("  4. ⚠️ abstain  - Acknowledge but not participate")
	fmt.Println()
	
	fmt.Print("Your vote (1-4): ")
	voteInput, _ := reader.ReadString('\n')
	voteInput = strings.TrimSpace(voteInput)
	
	var vote string
	switch voteInput {
	case "1", "approve":
		vote = "approve"
	case "2", "reject":
		vote = "reject"
	case "3", "defer":
		vote = "defer"
	case "4", "abstain":
		vote = "abstain"
	default:
		fmt.Println("❌ Invalid vote option. Please choose 1-4.")
		return
	}
	
	fmt.Printf("You selected: %s\n", vote)
	fmt.Println()
	
	// Get reasoning/justification
	fmt.Println("Reasoning/Justification (required for transparency):")
	fmt.Println("Explain why you are voting this way (press Enter twice when done):")
	
	var reasoning strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			reasoning.WriteString("\n")
		} else {
			emptyLines = 0
			reasoning.WriteString(line + "\n")
		}
	}
	
	reasoningText := strings.TrimSpace(reasoning.String())
	if reasoningText == "" {
		fmt.Println("❌ Reasoning is required for all votes")
		return
	}
	
	// Confirmation
	fmt.Println("📋 Vote Summary:")
	fmt.Printf("   Decision: %s\n", decisionID)
	fmt.Printf("   Your Vote: %s\n", vote)
	fmt.Printf("   Reasoning: %s\n", reasoningText)
	fmt.Println()
	
	fmt.Print("Submit this vote? (y/n): ")
	confirm, _ := reader.ReadString('\n')
	confirm = strings.TrimSpace(strings.ToLower(confirm))
	
	if confirm != "y" && confirm != "yes" {
		fmt.Println("❌ Vote cancelled")
		return
	}
	
	// Submit vote to decision system
	fmt.Println("🔄 Submitting vote...")
	
	// Get current decision to update it
	decision, err := t.getDecisionByID(decisionID)
	if err != nil {
		fmt.Printf("❌ Failed to retrieve decision: %v\n", err)
		return
	}
	
	// Create vote record
	voteRecord := DecisionVote{
		VoterID:    t.runtime.Config.Agent.ID,
		VoterType:  "human",
		Vote:       vote,
		Reasoning:  reasoningText,
		Timestamp:  time.Now(),
		Confidence: 1.0, // Human votes have full confidence
	}
	
	// Add/update vote in decision
	if decision.Votes == nil {
		decision.Votes = make(map[string]DecisionVote)
	}
	decision.Votes[t.runtime.Config.Agent.ID] = voteRecord
	decision.Version++
	
	// Save updated decision
	if err := t.saveDecision(decision); err != nil {
		fmt.Printf("❌ Failed to save vote: %v\n", err)
		return
	}
	
	// Announce vote via HMMM
	if err := t.announceDecisionVote(decisionID, voteRecord); err != nil {
		fmt.Printf("⚠️ Failed to announce vote via HMMM: %v\n", err)
	} else {
		fmt.Println("📢 Vote announced via HMMM reasoning network")
	}
	
	fmt.Printf("✅ Your %s vote on %s has been recorded\n", vote, decisionID)
	fmt.Println("💌 Vote reasoning published to network for transparency")
	fmt.Println("🔔 Other network members will be notified of your participation")
	
	fmt.Println()
}

// proposeNewDecision guides the user through creating a new decision
func (t *TerminalInterface) proposeNewDecision() {
	fmt.Println("\n📝 Propose New Network Decision")
	fmt.Println(strings.Repeat("-", 35))
	
	reader := bufio.NewReader(os.Stdin)
	
	// Decision type
	fmt.Println("Decision Types:")
	fmt.Println("  1. technical    - Architecture, code, infrastructure")
	fmt.Println("  2. operational  - Process, resource allocation")
	fmt.Println("  3. policy       - Network rules, governance")
	fmt.Println("  4. emergency    - Urgent security/stability issue")
	fmt.Println()
	
	fmt.Print("Decision type (1-4): ")
	typeInput, _ := reader.ReadString('\n')
	typeInput = strings.TrimSpace(typeInput)
	
	var decisionType string
	switch typeInput {
	case "1", "technical":
		decisionType = "technical"
	case "2", "operational":
		decisionType = "operational"
	case "3", "policy":
		decisionType = "policy"
	case "4", "emergency":
		decisionType = "emergency"
	default:
		fmt.Println("❌ Invalid decision type")
		return
	}
	
	// Title
	fmt.Print("Decision title (concise summary): ")
	title, _ := reader.ReadString('\n')
	title = strings.TrimSpace(title)
	if title == "" {
		fmt.Println("❌ Title is required")
		return
	}
	
	// Rationale
	fmt.Println("Detailed rationale (press Enter twice when done):")
	var rationale strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			rationale.WriteString("\n")
		} else {
			emptyLines = 0
			rationale.WriteString(line + "\n")
		}
	}
	
	rationaleText := strings.TrimSpace(rationale.String())
	if rationaleText == "" {
		fmt.Println("❌ Rationale is required")
		return
	}
	
	// Voting options
	fmt.Print("Custom voting options (comma-separated, or press Enter for default): ")
	optionsInput, _ := reader.ReadString('\n')
	optionsInput = strings.TrimSpace(optionsInput)
	
	var options []string
	if optionsInput == "" {
		options = []string{"approve", "reject", "defer", "abstain"}
	} else {
		options = strings.Split(optionsInput, ",")
		for i := range options {
			options[i] = strings.TrimSpace(options[i])
		}
	}
	
	// Deadline
	var deadline time.Duration
	if decisionType == "emergency" {
		deadline = 2 * time.Hour
		fmt.Println("⚠️ Emergency decisions have 2-hour deadline")
	} else {
		fmt.Print("Voting deadline in hours (default: 24): ")
		deadlineInput, _ := reader.ReadString('\n')
		deadlineInput = strings.TrimSpace(deadlineInput)
		
		if deadlineInput == "" {
			deadline = 24 * time.Hour
		} else {
			hours, err := strconv.ParseFloat(deadlineInput, 64)
			if err != nil || hours <= 0 {
				fmt.Println("❌ Invalid deadline")
				return
			}
			deadline = time.Duration(hours * float64(time.Hour))
		}
	}
	
	// Summary and confirmation
	fmt.Println("\n📋 Decision Proposal Summary:")
	fmt.Printf("   Type: %s\n", decisionType)
	fmt.Printf("   Title: %s\n", title)
	fmt.Printf("   Options: %s\n", strings.Join(options, ", "))
	fmt.Printf("   Deadline: %s from now\n", deadline)
	fmt.Printf("   Rationale:\n%s\n", rationaleText)
	fmt.Println()
	
	fmt.Print("Submit this decision proposal? (y/n): ")
	confirm, _ := reader.ReadString('\n')
	confirm = strings.TrimSpace(strings.ToLower(confirm))
	
	if confirm != "y" && confirm != "yes" {
		fmt.Println("❌ Decision proposal cancelled")
		return
	}
	
	// Generate decision ID
	decisionID := fmt.Sprintf("DEC-%s", generateRandomID(6))
	
	// Create decision object
	decision := &Decision{
		ID:          decisionID,
		Title:       title,
		Description: rationaleText,
		Type:        decisionType,
		Proposer:    t.runtime.Config.Agent.ID,
		ProposerType: "human",
		CreatedAt:   time.Now(),
		Deadline:    time.Now().Add(deadline),
		Status:      "voting",
		Votes:       make(map[string]DecisionVote),
		Metadata: map[string]interface{}{
			"voting_options": options,
			"priority":       "normal",
		},
		Version: 1,
	}
	
	if decisionType == "emergency" {
		decision.Metadata["priority"] = "urgent"
		decision.Status = "urgent"
	}
	
	// Save decision to DHT
	fmt.Println("🔄 Creating decision proposal...")
	if err := t.saveDecision(decision); err != nil {
		fmt.Printf("❌ Failed to create decision: %v\n", err)
		return
	}
	
	// Send HMMM announcement
	if err := t.announceDecisionProposal(decision); err != nil {
		fmt.Printf("⚠️ Failed to announce via HMMM: %v\n", err)
	} else {
		fmt.Println("📡 Decision announced via HMMM reasoning network")
	}
	
	fmt.Printf("✅ Decision %s proposed successfully\n", decisionID)
	fmt.Println("📢 Decision announced to all network members")
	fmt.Printf("⏰ Voting closes in %s\n", deadline)
	fmt.Println("🗳️ Network members can now cast their votes")
	
	fmt.Println()
}

// showDecisionStatus shows overall decision system status
func (t *TerminalInterface) showDecisionStatus() {
	fmt.Println("\n📊 Decision System Status")
	fmt.Println(strings.Repeat("-", 30))
	
	fmt.Println("⚠️ Decision system integration in development")
	fmt.Println()
	fmt.Println("Mock system status:")
	fmt.Printf("🗳️  Active Decisions: 3\n")
	fmt.Printf("⏰ Urgent Decisions: 1 (emergency timeout)\n") 
	fmt.Printf("👥 Network Members: 12 (8 active, 4 idle)\n")
	fmt.Printf("📊 Participation Rate: 67% (last 7 days)\n")
	fmt.Printf("✅ Consensus Success Rate: 89%\n")
	fmt.Printf("⚖️  Decision Types:\n")
	fmt.Printf("     Technical: 45%%, Operational: 30%%\n")
	fmt.Printf("     Policy: 20%%, Emergency: 5%%\n")
	fmt.Println()
	
	fmt.Println("🔔 Recent Activity:")
	fmt.Println("   • DEC-003: Emergency quarantine decision (45m left)")
	fmt.Println("   • DEC-002: Task timeout adjustment (6h 30m left)")  
	fmt.Println("   • DEC-001: libp2p upgrade (2h 15m left)")
	fmt.Println("   • DEC-055: Completed - Storage encryption (✅ approved)")
	fmt.Println()
}

// announceVoteDecision sends an HMMM message about a vote
func (t *TerminalInterface) announceVoteDecision(decisionID, vote, reasoning string) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("decision-%s", decisionID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/decisions/vote/%s", decisionID),
		Type:    "decision_vote",
		Payload: map[string]interface{}{
			"decision_id": decisionID,
			"vote":        vote,
			"reasoning":   reasoning,
			"voter":       t.runtime.Config.Agent.ID,
			"voter_type":  "human",
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Vote cast on %s: %s", decisionID, vote),
	}
	
	return t.sendHMMMMessage(message)
}

// announceNewDecisionProposal sends an HMMM message about a new decision
func (t *TerminalInterface) announceNewDecisionProposal(decisionID, title, decisionType, rationale string, options []string) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("decision-%s", decisionID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/decisions/proposal/%s", decisionType),
		Type:    "decision_proposal",
		Payload: map[string]interface{}{
			"decision_id":    decisionID,
			"title":          title,
			"decision_type":  decisionType,
			"rationale":      rationale,
			"options":        options,
			"proposer":       t.runtime.Config.Agent.ID,
			"proposer_type":  "human",
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("New %s decision proposed: %s", decisionType, title),
	}
	
	return t.sendHMMMMessage(message)
}

// Patch Management Helper Functions

// showPatchHelp displays detailed patch system information
func (t *TerminalInterface) showPatchHelp() {
	fmt.Println("\n🔧 CHORUS Patch Management System")
	fmt.Println(strings.Repeat("=", 60))
	fmt.Println("Create, review, and submit patches for distributed contexts and code changes.")
	fmt.Println("Patches enable collaborative editing with temporal navigation and approval workflows.")
	fmt.Println()
	
	fmt.Println("Patch Types:")
	fmt.Println("  • Context Patches: Changes to UCXL context content")
	fmt.Println("  • Code Patches: Traditional diff-based code changes")
	fmt.Println("  • Configuration Patches: System and environment changes")
	fmt.Println("  • Documentation Patches: Updates to project documentation")
	fmt.Println()
	
	fmt.Println("Temporal Navigation:")
	fmt.Println("  ~~<n>    - Navigate n decision-hops backward")
	fmt.Println("  ^^<n>    - Navigate n decision-hops forward")
	fmt.Println("  @<time>  - Navigate to specific timestamp")
	fmt.Println("  ~latest  - Go to latest version")
	fmt.Println("  ~first   - Go to initial version")
	fmt.Println()
	
	fmt.Println("Workflow:")
	fmt.Println("  1. create  - Create patch from current working state")
	fmt.Println("  2. diff    - Review changes with temporal comparison")
	fmt.Println("  3. submit  - Submit for peer review via HMMM network")
	fmt.Println("  4. review  - Participate in patch review process")
	fmt.Println("  5. merge   - Integrate approved patches into DHT")
	fmt.Println()
	
	fmt.Println("Integration:")
	fmt.Println("  • HMMM: Patch discussions and approval reasoning")
	fmt.Println("  • UCXL: Context addressing and version management")
	fmt.Println("  • DHT: Distributed storage of patches and content")
	fmt.Println("  • Decision System: Formal approval and consensus")
	fmt.Println()
}

// createPatch guides user through patch creation process
func (t *TerminalInterface) createPatch() {
	fmt.Println("\n📝 Create New Patch")
	fmt.Println(strings.Repeat("-", 25))
	
	reader := bufio.NewReader(os.Stdin)
	
	// Patch type selection
	fmt.Println("Patch Types:")
	fmt.Println("  1. context      - UCXL context content changes")
	fmt.Println("  2. code         - Traditional code diff")
	fmt.Println("  3. config       - Configuration changes")
	fmt.Println("  4. docs         - Documentation updates")
	fmt.Println()
	
	fmt.Print("Patch type (1-4): ")
	typeInput, _ := reader.ReadString('\n')
	typeInput = strings.TrimSpace(typeInput)
	
	var patchType string
	switch typeInput {
	case "1", "context":
		patchType = "context"
	case "2", "code":
		patchType = "code"
	case "3", "config":
		patchType = "config"
	case "4", "docs":
		patchType = "docs"
	default:
		fmt.Println("❌ Invalid patch type")
		return
	}
	
	// Get base context/address
	fmt.Print("Base UCXL address (what you're modifying): ")
	baseAddress, _ := reader.ReadString('\n')
	baseAddress = strings.TrimSpace(baseAddress)
	if baseAddress == "" {
		fmt.Println("❌ Base address is required")
		return
	}
	
	// Validate base address
	parsed, err := ucxl.ParseUCXLAddress(baseAddress)
	if err != nil {
		fmt.Printf("❌ Invalid UCXL address: %v\n", err)
		return
	}
	
	// Get current content (from storage)
	fmt.Println("\n📖 Fetching current content...")
	currentContent := ""
	if t.runtime.EncryptedStorage != nil {
		content, _, err := t.runtime.EncryptedStorage.RetrieveUCXLContent(baseAddress)
		if err != nil {
			fmt.Printf("⚠️ Could not fetch current content: %v\n", err)
			fmt.Println("Creating patch from empty base...")
		} else {
			currentContent = string(content)
		}
	}
	
	// Show current content for reference
	if currentContent != "" {
		fmt.Println("\n📄 Current Content:")
		fmt.Println(strings.Repeat("-", 40))
		if len(currentContent) > 500 {
			fmt.Printf("%s\n...(truncated, %d total chars)\n", currentContent[:500], len(currentContent))
		} else {
			fmt.Println(currentContent)
		}
		fmt.Println(strings.Repeat("-", 40))
		fmt.Println()
	}
	
	// Get patch title and description
	fmt.Print("Patch title: ")
	title, _ := reader.ReadString('\n')
	title = strings.TrimSpace(title)
	if title == "" {
		fmt.Println("❌ Title is required")
		return
	}
	
	fmt.Println("Patch description (press Enter twice when done):")
	var description strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			description.WriteString("\n")
		} else {
			emptyLines = 0
			description.WriteString(line + "\n")
		}
	}
	
	descriptionText := strings.TrimSpace(description.String())
	if descriptionText == "" {
		fmt.Println("❌ Description is required")
		return
	}
	
	// Get the new content
	fmt.Println("New content (press Enter twice when done):")
	fmt.Println("(This will replace the existing content)")
	
	var newContent strings.Builder
	emptyLines = 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			newContent.WriteString("\n")
		} else {
			emptyLines = 0
			newContent.WriteString(line + "\n")
		}
	}
	
	newContentText := strings.TrimSpace(newContent.String())
	if newContentText == "" {
		fmt.Println("❌ New content cannot be empty")
		return
	}
	
	// Generate patch ID and create patch structure
	patchID := fmt.Sprintf("patch-%d", time.Now().Unix())
	
	patch := map[string]interface{}{
		"id":          patchID,
		"type":        patchType,
		"title":       title,
		"description": descriptionText,
		"author":      t.runtime.Config.Agent.ID,
		"author_type": "human",
		"base_address": baseAddress,
		"base_content": currentContent,
		"new_content":  newContentText,
		"created_at":   time.Now().Unix(),
		"status":       "draft",
		"project":      parsed.Project,
		"task":         parsed.Task,
	}
	
	// Store patch in DHT (temporary storage for review)
	patchAddress := fmt.Sprintf("ucxl://%s:%s@%s:patches/%s/", 
		t.runtime.Config.Agent.ID, 
		t.runtime.Config.Agent.Role,
		parsed.Project, 
		patchID)
	
	patchData, err := json.Marshal(patch)
	if err != nil {
		fmt.Printf("❌ Failed to serialize patch: %v\n", err)
		return
	}
	
	if t.runtime.EncryptedStorage != nil {
		err = t.runtime.EncryptedStorage.StoreUCXLContent(
			patchAddress,
			patchData,
			t.runtime.Config.Agent.Role,
			"application/json",
		)
		if err != nil {
			fmt.Printf("❌ Failed to store patch: %v\n", err)
			return
		}
	}
	
	// Success feedback
	fmt.Println("✅ Patch created successfully!")
	fmt.Printf("   Patch ID: %s\n", patchID)
	fmt.Printf("   Type: %s\n", patchType)
	fmt.Printf("   Base: %s\n", baseAddress)
	fmt.Printf("   Storage: %s\n", patchAddress)
	fmt.Println()
	fmt.Println("💡 Next steps:")
	fmt.Println("   • Use 'diff' to review your changes")
	fmt.Println("   • Use 'submit' to send for review")
	fmt.Println()
}

// generateDiff creates temporal diff between versions
func (t *TerminalInterface) generateDiff() {
	fmt.Println("\n🔍 Generate Temporal Diff")
	fmt.Println(strings.Repeat("-", 30))
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Base UCXL address: ")
	baseAddress, _ := reader.ReadString('\n')
	baseAddress = strings.TrimSpace(baseAddress)
	if baseAddress == "" {
		fmt.Println("❌ Base address is required")
		return
	}
	
	// Validate address
	_, err := ucxl.ParseUCXLAddress(baseAddress)
	if err != nil {
		fmt.Printf("❌ Invalid UCXL address: %v\n", err)
		return
	}
	
	fmt.Println("\nTemporal Navigation Options:")
	fmt.Println("  ~<n>     - n decision-hops backward (e.g., ~2)")
	fmt.Println("  ^<n>     - n decision-hops forward (e.g., ^1)")
	fmt.Println("  @<time>  - specific timestamp (e.g., @1699123456)")
	fmt.Println("  current  - current/latest version")
	fmt.Println()
	
	fmt.Print("Compare FROM version: ")
	fromVersion, _ := reader.ReadString('\n')
	fromVersion = strings.TrimSpace(fromVersion)
	
	fmt.Print("Compare TO version: ")
	toVersion, _ := reader.ReadString('\n')
	toVersion = strings.TrimSpace(toVersion)
	
	if fromVersion == "" {
		fromVersion = "~1"
	}
	if toVersion == "" {
		toVersion = "current"
	}
	
	// Build temporal addresses
	fromAddress := t.buildTemporalAddress(baseAddress, fromVersion)
	toAddress := t.buildTemporalAddress(baseAddress, toVersion)
	
	fmt.Printf("\n🔍 Comparing:\n")
	fmt.Printf("   FROM: %s\n", fromAddress)
	fmt.Printf("   TO:   %s\n", toAddress)
	fmt.Println()
	
	// Fetch content for both versions
	fmt.Println("📖 Fetching content versions...")
	
	var fromContent, toContent string
	
	if t.runtime.EncryptedStorage != nil {
		// Fetch FROM version
		if content, _, err := t.runtime.EncryptedStorage.RetrieveUCXLContent(fromAddress); err == nil {
			fromContent = string(content)
		} else {
			fmt.Printf("⚠️ Could not fetch FROM content: %v\n", err)
		}
		
		// Fetch TO version  
		if content, _, err := t.runtime.EncryptedStorage.RetrieveUCXLContent(toAddress); err == nil {
			toContent = string(content)
		} else {
			fmt.Printf("⚠️ Could not fetch TO content: %v\n", err)
		}
	} else {
		fmt.Println("⚠️ Storage system not available")
		return
	}
	
	// Generate and display diff
	fmt.Println("\n📋 Content Diff:")
	fmt.Println(strings.Repeat("=", 50))
	
	if fromContent == toContent {
		fmt.Println("✅ No differences found")
	} else {
		t.displaySimpleDiff(fromContent, toContent)
	}
	
	fmt.Println(strings.Repeat("=", 50))
	fmt.Println()
}

// submitPatch submits patch for review via HMMM network
func (t *TerminalInterface) submitPatch() {
	fmt.Println("\n📤 Submit Patch for Review")
	fmt.Println(strings.Repeat("-", 30))
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Patch ID to submit: ")
	patchID, _ := reader.ReadString('\n')
	patchID = strings.TrimSpace(patchID)
	if patchID == "" {
		fmt.Println("❌ Patch ID is required")
		return
	}
	
	// Build patch address and fetch patch data
	patchAddress := fmt.Sprintf("ucxl://%s:%s@*:patches/%s/", 
		t.runtime.Config.Agent.ID, 
		t.runtime.Config.Agent.Role,
		patchID)
	
	fmt.Printf("📖 Loading patch: %s\n", patchID)
	
	var patchData map[string]interface{}
	
	if t.runtime.EncryptedStorage != nil {
		content, _, err := t.runtime.EncryptedStorage.RetrieveUCXLContent(patchAddress)
		if err != nil {
			fmt.Printf("❌ Could not load patch: %v\n", err)
			return
		}
		
		err = json.Unmarshal(content, &patchData)
		if err != nil {
			fmt.Printf("❌ Invalid patch data: %v\n", err)
			return
		}
	} else {
		fmt.Println("❌ Storage system not available")
		return
	}
	
	// Display patch summary
	fmt.Println("\n📋 Patch Summary:")
	fmt.Printf("   ID: %s\n", patchData["id"])
	fmt.Printf("   Type: %s\n", patchData["type"])
	fmt.Printf("   Title: %s\n", patchData["title"])
	fmt.Printf("   Description: %s\n", patchData["description"])
	fmt.Printf("   Base: %s\n", patchData["base_address"])
	fmt.Printf("   Author: %s (%s)\n", patchData["author"], patchData["author_type"])
	fmt.Println()
	
	// Get review requirements
	fmt.Println("Review Configuration:")
	fmt.Print("Required approvals (default: 2): ")
	approvalsInput, _ := reader.ReadString('\n')
	approvalsInput = strings.TrimSpace(approvalsInput)
	
	requiredApprovals := 2
	if approvalsInput != "" {
		if approvals, err := strconv.Atoi(approvalsInput); err == nil {
			requiredApprovals = approvals
		}
	}
	
	fmt.Print("Review deadline in hours (default: 48): ")
	deadlineInput, _ := reader.ReadString('\n')
	deadlineInput = strings.TrimSpace(deadlineInput)
	
	deadlineHours := 48.0
	if deadlineInput != "" {
		if hours, err := strconv.ParseFloat(deadlineInput, 64); err == nil {
			deadlineHours = hours
		}
	}
	
	fmt.Print("Target reviewers (comma-separated, or 'auto' for automatic): ")
	reviewersInput, _ := reader.ReadString('\n')
	reviewersInput = strings.TrimSpace(reviewersInput)
	
	var reviewers []string
	if reviewersInput == "" || reviewersInput == "auto" {
		reviewers = []string{"auto-assigned"}
	} else {
		reviewers = strings.Split(reviewersInput, ",")
		for i := range reviewers {
			reviewers[i] = strings.TrimSpace(reviewers[i])
		}
	}
	
	// Confirmation
	fmt.Println("\n📋 Submission Summary:")
	fmt.Printf("   Patch: %s\n", patchID)
	fmt.Printf("   Required Approvals: %d\n", requiredApprovals)
	fmt.Printf("   Review Deadline: %.1f hours\n", deadlineHours)
	fmt.Printf("   Reviewers: %s\n", strings.Join(reviewers, ", "))
	fmt.Println()
	
	fmt.Print("Submit for review? (y/n): ")
	confirm, _ := reader.ReadString('\n')
	confirm = strings.TrimSpace(strings.ToLower(confirm))
	
	if confirm != "y" && confirm != "yes" {
		fmt.Println("❌ Patch submission cancelled")
		return
	}
	
	// Update patch status and submit via HMMM
	patchData["status"] = "submitted"
	patchData["required_approvals"] = requiredApprovals
	patchData["deadline"] = time.Now().Add(time.Duration(deadlineHours * float64(time.Hour))).Unix()
	patchData["reviewers"] = reviewers
	patchData["submitted_at"] = time.Now().Unix()
	
	// Re-store updated patch
	updatedPatchData, _ := json.Marshal(patchData)
	if t.runtime.EncryptedStorage != nil {
		err := t.runtime.EncryptedStorage.StoreUCXLContent(
			patchAddress,
			updatedPatchData,
			t.runtime.Config.Agent.Role,
			"application/json",
		)
		if err != nil {
			fmt.Printf("❌ Failed to update patch: %v\n", err)
			return
		}
	}
	
	// Send HMMM message for review
	if err := t.announcePatchSubmission(patchID, patchData); err != nil {
		fmt.Printf("⚠️ Failed to announce via HMMM: %v\n", err)
	}
	
	fmt.Println("✅ Patch submitted for review!")
	fmt.Printf("   Patch ID: %s\n", patchID)
	fmt.Printf("   Status: submitted\n")
	fmt.Printf("   Review deadline: %.1f hours from now\n", deadlineHours)
	fmt.Println("📢 Review announcement sent via HMMM network")
	fmt.Println()
}

// listPatches shows active patches in the system
func (t *TerminalInterface) listPatches() {
	fmt.Println("\n📋 Active Patches")
	fmt.Println(strings.Repeat("-", 25))
	
	fmt.Println("⚠️ Patch listing integration in development")
	fmt.Println()
	fmt.Println("Mock active patches:")
	fmt.Println()
	
	// Mock patch data
	patches := []struct {
		ID          string
		Type        string
		Title       string
		Author      string
		Status      string
		Approvals   string
		Deadline    string
	}{
		{"patch-001", "context", "Fix user authentication logic", "alice-human", "submitted", "2/3", "12h"},
		{"patch-002", "code", "Optimize DHT lookup performance", "agent-optimizer", "review", "1/2", "6h"},
		{"patch-003", "config", "Update production timeout values", "bob-ops", "draft", "0/2", "-"},
		{"patch-004", "docs", "Add HAP usage examples", "carol-tech-writer", "approved", "3/2", "complete"},
	}
	
	for _, patch := range patches {
		statusEmoji := "📝"
		switch patch.Status {
		case "submitted":
			statusEmoji = "📤"
		case "review":
			statusEmoji = "👀"
		case "approved":
			statusEmoji = "✅"
		case "rejected":
			statusEmoji = "❌"
		}
		
		fmt.Printf("%s %s - %s\n", statusEmoji, patch.ID, patch.Title)
		fmt.Printf("    📂 Type: %s | 👤 Author: %s | 🗳️ Approvals: %s | ⏰ %s\n", 
			patch.Type, patch.Author, patch.Approvals, patch.Deadline)
		fmt.Println()
	}
	
	fmt.Println("Use 'review' to participate in patch reviews.")
	fmt.Println("Use 'status' for detailed patch system metrics.")
	fmt.Println()
}

// reviewPatches participates in patch review process
func (t *TerminalInterface) reviewPatches() {
	fmt.Println("\n👀 Patch Review System")
	fmt.Println(strings.Repeat("-", 30))
	
	reader := bufio.NewReader(os.Stdin)
	
	fmt.Print("Patch ID to review: ")
	patchID, _ := reader.ReadString('\n')
	patchID = strings.TrimSpace(patchID)
	if patchID == "" {
		fmt.Println("❌ Patch ID is required")
		return
	}
	
	// Mock patch review (would integrate with patch storage system)
	fmt.Println("⚠️ Patch review integration in development")
	fmt.Printf("📖 Loading patch %s for review...\n", patchID)
	fmt.Println()
	
	switch patchID {
	case "patch-001":
		fmt.Println("📋 Patch Details: Fix user authentication logic")
		fmt.Println("👤 Author: alice-human")
		fmt.Println("📂 Type: context")
		fmt.Println("📍 Base: ucxl://alice:dev@webapp:auth/login-handler/")
		fmt.Println()
		fmt.Println("📖 Description:")
		fmt.Println("   Fix issue where authentication tokens were not being properly")
		fmt.Println("   validated against the role-based access control system.")
		fmt.Println()
		fmt.Println("🔍 Changes:")
		fmt.Println("   - Added proper RBAC token validation")
		fmt.Println("   - Fixed role hierarchy checking")
		fmt.Println("   - Updated error handling for invalid tokens")
		fmt.Println()
		
	default:
		fmt.Printf("❌ Patch %s not found or access denied\n", patchID)
		return
	}
	
	// Review options
	fmt.Println("Review Options:")
	fmt.Println("  1. ✅ approve   - Approve this patch")
	fmt.Println("  2. ❌ reject    - Reject this patch")
	fmt.Println("  3. 🔄 request-changes - Request changes before approval")
	fmt.Println("  4. 💬 comment   - Add comment without approval decision")
	fmt.Println()
	
	fmt.Print("Your review (1-4): ")
	reviewInput, _ := reader.ReadString('\n')
	reviewInput = strings.TrimSpace(reviewInput)
	
	var reviewType string
	switch reviewInput {
	case "1", "approve":
		reviewType = "approve"
	case "2", "reject":
		reviewType = "reject"
	case "3", "request-changes":
		reviewType = "request-changes"
	case "4", "comment":
		reviewType = "comment"
	default:
		fmt.Println("❌ Invalid review option")
		return
	}
	
	// Get review reasoning
	fmt.Println("Review reasoning/comment (press Enter twice when done):")
	var reasoning strings.Builder
	emptyLines := 0
	for {
		line, _ := reader.ReadString('\n')
		line = strings.TrimSpace(line)
		if line == "" {
			emptyLines++
			if emptyLines >= 2 {
				break
			}
			reasoning.WriteString("\n")
		} else {
			emptyLines = 0
			reasoning.WriteString(line + "\n")
		}
	}
	
	reasoningText := strings.TrimSpace(reasoning.String())
	if reasoningText == "" {
		fmt.Println("❌ Review reasoning is required")
		return
	}
	
	// Submit review
	fmt.Println("⚠️ Review submission integration in development")
	fmt.Printf("✅ Review submitted for %s\n", patchID)
	fmt.Printf("   Review: %s\n", reviewType)
	fmt.Printf("   Reviewer: %s\n", t.runtime.Config.Agent.ID)
	fmt.Println("💌 Review reasoning will be published to HMMM network")
	
	// Announce review via HMMM
	if err := t.announcePatchReview(patchID, reviewType, reasoningText); err != nil {
		fmt.Printf("⚠️ Failed to announce review: %v\n", err)
	} else {
		fmt.Println("📢 Review announced via HMMM reasoning network")
	}
	
	fmt.Println()
}

// showPatchStatus displays patch system status
func (t *TerminalInterface) showPatchStatus() {
	fmt.Println("\n📊 Patch System Status")
	fmt.Println(strings.Repeat("-", 30))
	
	fmt.Println("⚠️ Patch system integration in development")
	fmt.Println()
	fmt.Println("Mock system status:")
	fmt.Printf("📝 Active Patches: 4 (3 submitted, 1 draft)\n")
	fmt.Printf("👀 Pending Reviews: 2 (requiring your attention)\n")
	fmt.Printf("⏰ Urgent Deadlines: 1 (< 6 hours remaining)\n")
	fmt.Printf("✅ Approved Today: 2\n")
	fmt.Printf("🔄 Auto-merge Queue: 1\n")
	fmt.Println()
	
	fmt.Println("🎯 Your Activity:")
	fmt.Printf("   Created: 1 patch (patch-003)\n")
	fmt.Printf("   Reviews: 3 completed this week\n")
	fmt.Printf("   Approval Rate: 85%% (17/20 approved)\n")
	fmt.Printf("   Avg Review Time: 2.3 hours\n")
	fmt.Println()
	
	fmt.Println("🔔 Recent Activity:")
	fmt.Println("   • patch-001: Awaiting final approval (12h left)")
	fmt.Println("   • patch-002: New review from agent-optimizer (6h left)")
	fmt.Println("   • patch-004: Auto-merged after 3 approvals")
	fmt.Println()
}

// Helper functions for patch management

// buildTemporalAddress creates temporal UCXL addresses
func (t *TerminalInterface) buildTemporalAddress(baseAddress, temporalNav string) string {
	if temporalNav == "current" {
		return baseAddress
	}
	
	// Remove trailing slash if present
	addr := strings.TrimSuffix(baseAddress, "/")
	
	// Add temporal navigation
	return fmt.Sprintf("%s*%s/", addr, temporalNav)
}

// displaySimpleDiff shows a basic character-level diff
func (t *TerminalInterface) displaySimpleDiff(fromContent, toContent string) {
	fromLines := strings.Split(fromContent, "\n")
	toLines := strings.Split(toContent, "\n")
	
	maxLines := len(fromLines)
	if len(toLines) > maxLines {
		maxLines = len(toLines)
	}
	
	for i := 0; i < maxLines; i++ {
		var fromLine, toLine string
		if i < len(fromLines) {
			fromLine = fromLines[i]
		}
		if i < len(toLines) {
			toLine = toLines[i]
		}
		
		if fromLine != toLine {
			if fromLine != "" {
				fmt.Printf("- %s\n", fromLine)
			}
			if toLine != "" {
				fmt.Printf("+ %s\n", toLine)
			}
		} else if fromLine != "" {
			fmt.Printf("  %s\n", fromLine)
		}
	}
}

// announcePatchSubmission sends HMMM message about patch submission
func (t *TerminalInterface) announcePatchSubmission(patchID string, patchData map[string]interface{}) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("patch-%s", patchID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/patches/submission/%s", patchData["type"]),
		Type:    "patch_submission",
		Payload: map[string]interface{}{
			"patch_id":    patchID,
			"title":       patchData["title"],
			"description": patchData["description"],
			"patch_type":  patchData["type"],
			"base_address": patchData["base_address"],
			"author":      patchData["author"],
			"author_type": patchData["author_type"],
			"reviewers":   patchData["reviewers"],
			"deadline":    patchData["deadline"],
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Patch submitted for review: %s", patchData["title"]),
	}
	
	return t.sendHMMMMessage(message)
}

// announcePatchReview sends HMMM message about patch review
func (t *TerminalInterface) announcePatchReview(patchID, reviewType, reasoning string) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("patch-%s", patchID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/patches/review/%s", patchID),
		Type:    "patch_review",
		Payload: map[string]interface{}{
			"patch_id":    patchID,
			"review_type": reviewType,
			"reasoning":   reasoning,
			"reviewer":    t.runtime.Config.Agent.ID,
			"reviewer_type": "human",
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Patch review: %s (%s)", reviewType, patchID),
	}
	
	return t.sendHMMMMessage(message)
}

// === COLLABORATIVE EDITING HELPER FUNCTIONS ===

// showCollaborativeEditingHelp displays comprehensive collaborative editing help
func (t *TerminalInterface) showCollaborativeEditingHelp() {
	fmt.Println("\n=== 🤝 COLLABORATIVE EDITING HELP ===")
	fmt.Println()
	fmt.Println("AVAILABLE COMMANDS:")
	fmt.Println("  start <session-id>       - Start new collaborative session")
	fmt.Println("  join <session-id>        - Join existing collaborative session")
	fmt.Println("  list                     - List active collaborative sessions")
	fmt.Println("  status                   - Show current collaboration status")
	fmt.Println("  leave                    - Leave current collaborative session")
	fmt.Println("  help                     - Show this help menu")
	fmt.Println("  back                     - Return to main HAP menu")
	fmt.Println()
	fmt.Println("COLLABORATIVE SESSION WORKFLOW:")
	fmt.Println("  1. Start a new session with unique session ID")
	fmt.Println("  2. Share session ID with collaborators")
	fmt.Println("  3. Collaborators join using the session ID")
	fmt.Println("  4. Real-time editing with conflict resolution")
	fmt.Println("  5. Automatic sync via CHORUS P2P network")
	fmt.Println()
	fmt.Println("FEATURES:")
	fmt.Println("  • Real-time collaborative editing")
	fmt.Println("  • Automatic conflict resolution")
	fmt.Println("  • Version history and rollback")
	fmt.Println("  • Live cursor and selection sync")
	fmt.Println("  • Chat integration for coordination")
	fmt.Println("  • Role-based access control")
	fmt.Println()
}

// startCollaborativeSession creates and starts a new collaborative editing session
func (t *TerminalInterface) startCollaborativeSession(sessionID string) error {
	if t.collaborativeSession != nil {
		fmt.Println("⚠️  Already in collaborative session. Leave current session first.")
		return nil
	}

	fmt.Printf("🚀 Starting collaborative session: %s\n", sessionID)
	
	// Create session data
	sessionData := map[string]interface{}{
		"session_id":  sessionID,
		"owner":       t.runtime.Config.Agent.ID,
		"owner_type":  "human",
		"created_at":  time.Now().Unix(),
		"participants": []string{t.runtime.Config.Agent.ID},
		"status":      "active",
		"version":     1,
	}
	
	// Store session in DHT
	sessionKey := fmt.Sprintf("collab_session_%s", sessionID)
	sessionBytes, _ := json.Marshal(sessionData)
	
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	
	err := t.runtime.DHT.PutValue(ctx, sessionKey, sessionBytes)
	if err != nil {
		fmt.Printf("❌ Failed to create collaborative session: %v\n", err)
		return err
	}
	
	// Set local session state
	t.collaborativeSession = &CollaborativeSession{
		SessionID:    sessionID,
		Owner:        t.runtime.Config.Agent.ID,
		Participants: []string{t.runtime.Config.Agent.ID},
		Status:       "active",
		CreatedAt:    time.Now(),
	}
	
	// Announce session creation
	t.announceCollaborativeSession("session_created", sessionData)
	
	fmt.Println("✅ Collaborative session started successfully!")
	fmt.Printf("📋 Share session ID with collaborators: %s\n", sessionID)
	fmt.Println("🎮 Starting collaborative editor...")
	
	return t.runCollaborativeEditor()
}

// joinCollaborativeSession joins an existing collaborative editing session
func (t *TerminalInterface) joinCollaborativeSession(sessionID string) error {
	if t.collaborativeSession != nil {
		fmt.Println("⚠️  Already in collaborative session. Leave current session first.")
		return nil
	}

	fmt.Printf("🔗 Joining collaborative session: %s\n", sessionID)
	
	// Retrieve session from DHT
	sessionKey := fmt.Sprintf("collab_session_%s", sessionID)
	
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	
	sessionBytes, err := t.runtime.DHT.GetValue(ctx, sessionKey)
	if err != nil {
		fmt.Printf("❌ Failed to find collaborative session: %v\n", err)
		return err
	}
	
	var sessionData map[string]interface{}
	if err := json.Unmarshal(sessionBytes, &sessionData); err != nil {
		fmt.Printf("❌ Invalid session data: %v\n", err)
		return err
	}
	
	// Check session status
	if sessionData["status"] != "active" {
		fmt.Println("❌ Session is not active")
		return fmt.Errorf("session not active")
	}
	
	// Add participant
	participants, _ := sessionData["participants"].([]interface{})
	participantList := make([]string, 0, len(participants)+1)
	
	for _, p := range participants {
		if pStr, ok := p.(string); ok {
			participantList = append(participantList, pStr)
		}
	}
	
	// Check if already participant
	for _, p := range participantList {
		if p == t.runtime.Config.Agent.ID {
			fmt.Println("⚠️  Already a participant in this session")
			break
		}
	}
	
	// Add current agent as participant
	participantList = append(participantList, t.runtime.Config.Agent.ID)
	sessionData["participants"] = participantList
	sessionData["version"] = sessionData["version"].(float64) + 1
	
	// Update session in DHT
	sessionBytes, _ = json.Marshal(sessionData)
	err = t.runtime.DHT.PutValue(ctx, sessionKey, sessionBytes)
	if err != nil {
		fmt.Printf("❌ Failed to join collaborative session: %v\n", err)
		return err
	}
	
	// Set local session state
	t.collaborativeSession = &CollaborativeSession{
		SessionID:    sessionID,
		Owner:        sessionData["owner"].(string),
		Participants: participantList,
		Status:       "active",
		CreatedAt:    time.Unix(int64(sessionData["created_at"].(float64)), 0),
	}
	
	// Announce session join
	t.announceCollaborativeSession("participant_joined", sessionData)
	
	fmt.Println("✅ Joined collaborative session successfully!")
	fmt.Printf("👥 Session participants: %v\n", participantList)
	fmt.Println("🎮 Starting collaborative editor...")
	
	return t.runCollaborativeEditor()
}

// listCollaborativeSessions displays all active collaborative sessions
func (t *TerminalInterface) listCollaborativeSessions() error {
	fmt.Println("\n=== 🤝 ACTIVE COLLABORATIVE SESSIONS ===")
	
	// Query DHT for active sessions (simplified - would need proper indexing in production)
	fmt.Println("📋 Searching for active sessions...")
	
	if t.collaborativeSession != nil {
		fmt.Printf("\n🟢 CURRENT SESSION: %s\n", t.collaborativeSession.SessionID)
		fmt.Printf("   Owner: %s\n", t.collaborativeSession.Owner)
		fmt.Printf("   Participants: %v\n", t.collaborativeSession.Participants)
		fmt.Printf("   Created: %s\n", t.collaborativeSession.CreatedAt.Format("2006-01-02 15:04:05"))
		fmt.Printf("   Status: %s\n", t.collaborativeSession.Status)
	} else {
		fmt.Println("\n🔴 Not currently in any collaborative session")
	}
	
	fmt.Println("\n💡 To discover other sessions, use the HMMM network:")
	fmt.Println("   Sessions are announced via CHORUS/collab/sessions topic")
	
	return nil
}

// showCollaborativeStatus displays current collaboration status and statistics
func (t *TerminalInterface) showCollaborativeStatus() {
	fmt.Println("\n=== 🤝 COLLABORATIVE STATUS ===")
	
	if t.collaborativeSession == nil {
		fmt.Println("🔴 Not currently in any collaborative session")
		fmt.Println("\nTo start or join a session:")
		fmt.Println("  collab start <session-id>")
		fmt.Println("  collab join <session-id>")
		return
	}
	
	session := t.collaborativeSession
	fmt.Printf("🟢 ACTIVE SESSION: %s\n", session.SessionID)
	fmt.Printf("👤 Owner: %s\n", session.Owner)
	fmt.Printf("👥 Participants: %d\n", len(session.Participants))
	
	for i, participant := range session.Participants {
		indicator := "  "
		if participant == t.runtime.Config.Agent.ID {
			indicator = "→ "
		}
		fmt.Printf("   %s%s\n", indicator, participant)
	}
	
	fmt.Printf("📅 Created: %s\n", session.CreatedAt.Format("2006-01-02 15:04:05"))
	fmt.Printf("🔄 Status: %s\n", session.Status)
	
	// Show network status
	fmt.Println("\n📡 NETWORK STATUS:")
	fmt.Printf("   P2P Node ID: %s\n", t.runtime.Node.ID().String()[:16]+"...")
	fmt.Printf("   Connected Peers: %d\n", len(t.runtime.Node.Network().Peers()))
	fmt.Printf("   HMMM Messages: %d sent\n", t.hmmmMessageCount)
	
	fmt.Println("\n🎮 EDITOR STATUS:")
	fmt.Println("   Collaborative editing interface active")
	fmt.Println("   Real-time sync enabled")
	fmt.Println("   Conflict resolution active")
}

// leaveCollaborativeSession leaves the current collaborative session
func (t *TerminalInterface) leaveCollaborativeSession() error {
	if t.collaborativeSession == nil {
		fmt.Println("⚠️  Not currently in any collaborative session")
		return nil
	}
	
	sessionID := t.collaborativeSession.SessionID
	fmt.Printf("👋 Leaving collaborative session: %s\n", sessionID)
	
	// Retrieve current session data
	sessionKey := fmt.Sprintf("collab_session_%s", sessionID)
	
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	
	sessionBytes, err := t.runtime.DHT.GetValue(ctx, sessionKey)
	if err == nil {
		var sessionData map[string]interface{}
		if json.Unmarshal(sessionBytes, &sessionData) == nil {
			// Remove participant
			participants, _ := sessionData["participants"].([]interface{})
			newParticipants := make([]string, 0)
			
			for _, p := range participants {
				if pStr, ok := p.(string); ok && pStr != t.runtime.Config.Agent.ID {
					newParticipants = append(newParticipants, pStr)
				}
			}
			
			sessionData["participants"] = newParticipants
			sessionData["version"] = sessionData["version"].(float64) + 1
			
			// Update session in DHT
			sessionBytes, _ = json.Marshal(sessionData)
			t.runtime.DHT.PutValue(ctx, sessionKey, sessionBytes)
			
			// Announce departure
			t.announceCollaborativeSession("participant_left", sessionData)
		}
	}
	
	// Clear local session state
	t.collaborativeSession = nil
	
	fmt.Println("✅ Left collaborative session successfully!")
	return nil
}

// runCollaborativeEditor starts the collaborative editing interface
func (t *TerminalInterface) runCollaborativeEditor() error {
	fmt.Println("\n=== 🎮 COLLABORATIVE EDITOR ===")
	fmt.Printf("Session: %s | Participants: %d\n", 
		t.collaborativeSession.SessionID, 
		len(t.collaborativeSession.Participants))
	
	fmt.Println("\nCOLLABORATIVE EDITOR COMMANDS:")
	fmt.Println("  edit <file>     - Edit file collaboratively")
	fmt.Println("  create <file>   - Create new file collaboratively") 
	fmt.Println("  sync            - Force sync with other participants")
	fmt.Println("  chat <message>  - Send message to collaborators")
	fmt.Println("  history         - Show session edit history")
	fmt.Println("  conflicts       - Show and resolve conflicts")
	fmt.Println("  save            - Save current collaborative work")
	fmt.Println("  status          - Show collaborative status")
	fmt.Println("  leave           - Leave collaborative session")
	
	// Main collaborative editing loop
	for {
		if t.collaborativeSession == nil {
			break
		}
		
		fmt.Printf("\ncollab:%s> ", t.collaborativeSession.SessionID)
		input := t.readInput()
		parts := strings.Fields(strings.TrimSpace(input))
		
		if len(parts) == 0 {
			continue
		}
		
		command := strings.ToLower(parts[0])
		
		switch command {
		case "edit":
			if len(parts) < 2 {
				fmt.Println("❌ Usage: edit <file>")
				continue
			}
			t.handleCollaborativeFileEdit(parts[1])
			
		case "create":
			if len(parts) < 2 {
				fmt.Println("❌ Usage: create <file>")
				continue
			}
			t.handleCollaborativeFileCreate(parts[1])
			
		case "sync":
			t.handleCollaborativeSync()
			
		case "chat":
			if len(parts) < 2 {
				fmt.Println("❌ Usage: chat <message>")
				continue
			}
			message := strings.Join(parts[1:], " ")
			t.handleCollaborativeChat(message)
			
		case "history":
			t.showCollaborativeHistory()
			
		case "conflicts":
			t.showCollaborativeConflicts()
			
		case "save":
			t.handleCollaborativeSave()
			
		case "status":
			t.showCollaborativeStatus()
			
		case "leave":
			return t.leaveCollaborativeSession()
			
		case "help":
			fmt.Println("\nCOLLABORATIVE EDITOR COMMANDS:")
			fmt.Println("  edit <file>     - Edit file collaboratively")
			fmt.Println("  create <file>   - Create new file collaboratively") 
			fmt.Println("  sync            - Force sync with other participants")
			fmt.Println("  chat <message>  - Send message to collaborators")
			fmt.Println("  history         - Show session edit history")
			fmt.Println("  conflicts       - Show and resolve conflicts")
			fmt.Println("  save            - Save current collaborative work")
			fmt.Println("  status          - Show collaborative status")
			fmt.Println("  leave           - Leave collaborative session")
			
		default:
			fmt.Printf("❌ Unknown command: %s\n", command)
			fmt.Println("💡 Type 'help' for available commands")
		}
	}
	
	return nil
}

// handleCollaborativeFileEdit handles collaborative editing of a file
func (t *TerminalInterface) handleCollaborativeFileEdit(filename string) {
	fmt.Printf("📝 Starting collaborative edit of: %s\n", filename)
	
	// Announce edit start
	editData := map[string]interface{}{
		"session_id": t.collaborativeSession.SessionID,
		"file":       filename,
		"editor":     t.runtime.Config.Agent.ID,
		"action":     "edit_start",
		"timestamp":  time.Now().Unix(),
	}
	
	t.announceCollaborativeEdit(editData)
	
	// For now, simulate collaborative editing
	fmt.Println("🎮 Collaborative editing interface would start here...")
	fmt.Println("   • Real-time sync with other participants")
	fmt.Println("   • Conflict resolution on overlapping edits")  
	fmt.Println("   • Live cursor positions")
	fmt.Println("   • Change history and rollback")
	fmt.Println("   • Chat integration")
	
	fmt.Println("\n💡 Press Enter to simulate edit completion...")
	t.readInput()
	
	// Announce edit completion
	editData["action"] = "edit_complete"
	t.announceCollaborativeEdit(editData)
	
	fmt.Println("✅ Collaborative edit completed!")
}

// handleCollaborativeFileCreate handles collaborative creation of a new file
func (t *TerminalInterface) handleCollaborativeFileCreate(filename string) {
	fmt.Printf("📄 Creating new collaborative file: %s\n", filename)
	
	// Announce file creation
	createData := map[string]interface{}{
		"session_id": t.collaborativeSession.SessionID,
		"file":       filename,
		"creator":    t.runtime.Config.Agent.ID,
		"action":     "file_create",
		"timestamp":  time.Now().Unix(),
	}
	
	t.announceCollaborativeEdit(createData)
	
	fmt.Println("✅ Collaborative file creation announced!")
	fmt.Printf("🎮 Starting collaborative editing of: %s\n", filename)
	
	// Start collaborative editing of the new file
	t.handleCollaborativeFileEdit(filename)
}

// handleCollaborativeSync forces synchronization with other participants
func (t *TerminalInterface) handleCollaborativeSync() {
	fmt.Println("🔄 Forcing sync with collaborative participants...")
	
	syncData := map[string]interface{}{
		"session_id": t.collaborativeSession.SessionID,
		"requester":  t.runtime.Config.Agent.ID,
		"action":     "force_sync",
		"timestamp":  time.Now().Unix(),
	}
	
	t.announceCollaborativeEdit(syncData)
	
	fmt.Println("✅ Sync request sent to all participants!")
}

// handleCollaborativeChat sends a chat message to collaborators
func (t *TerminalInterface) handleCollaborativeChat(message string) {
	chatData := map[string]interface{}{
		"session_id": t.collaborativeSession.SessionID,
		"sender":     t.runtime.Config.Agent.ID,
		"message":    message,
		"timestamp":  time.Now().Unix(),
	}
	
	t.announceCollaborativeChat(chatData)
	
	fmt.Printf("💬 Message sent: %s\n", message)
}

// showCollaborativeHistory displays the collaborative editing history
func (t *TerminalInterface) showCollaborativeHistory() {
	fmt.Println("\n=== 📜 COLLABORATIVE SESSION HISTORY ===")
	fmt.Printf("Session: %s\n", t.collaborativeSession.SessionID)
	fmt.Println()
	
	// For now, show placeholder history
	fmt.Println("🕐 Session started")
	for i, participant := range t.collaborativeSession.Participants {
		if i == 0 {
			fmt.Printf("🕐 %s created session\n", participant)
		} else {
			fmt.Printf("🕐 %s joined session\n", participant)
		}
	}
	
	fmt.Println("\n💡 Complete history would show:")
	fmt.Println("   • All file edits and creations")
	fmt.Println("   • Chat messages between participants")
	fmt.Println("   • Sync events and conflict resolutions")
	fmt.Println("   • Participant join/leave events")
}

// showCollaborativeConflicts displays and helps resolve conflicts
func (t *TerminalInterface) showCollaborativeConflicts() {
	fmt.Println("\n=== ⚠️  COLLABORATIVE CONFLICTS ===")
	fmt.Printf("Session: %s\n", t.collaborativeSession.SessionID)
	fmt.Println()
	
	// For now, show no conflicts
	fmt.Println("✅ No active conflicts detected!")
	fmt.Println()
	fmt.Println("💡 Conflict resolution features:")
	fmt.Println("   • Automatic merge for non-overlapping edits")
	fmt.Println("   • Three-way merge for conflicting changes")
	fmt.Println("   • Manual resolution interface")
	fmt.Println("   • Rollback to previous versions")
	fmt.Println("   • Participant voting on resolutions")
}

// handleCollaborativeSave saves the current collaborative work
func (t *TerminalInterface) handleCollaborativeSave() {
	fmt.Println("💾 Saving collaborative session work...")
	
	saveData := map[string]interface{}{
		"session_id": t.collaborativeSession.SessionID,
		"saver":      t.runtime.Config.Agent.ID,
		"action":     "session_save",
		"timestamp":  time.Now().Unix(),
	}
	
	t.announceCollaborativeEdit(saveData)
	
	fmt.Println("✅ Collaborative work saved!")
	fmt.Println("📝 All changes synchronized across participants")
}

// announceCollaborativeSession sends HMMM message about session events
func (t *TerminalInterface) announceCollaborativeSession(eventType string, sessionData map[string]interface{}) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("collab-session-%s", sessionData["session_id"])
	
	message := hmmm.Message{
		Topic:   "CHORUS/collab/sessions",
		Type:    "collaborative_session",
		Payload: map[string]interface{}{
			"event_type":    eventType,
			"session_data":  sessionData,
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Collaborative session %s: %s", eventType, sessionData["session_id"]),
	}
	
	return t.sendHMMMMessage(message)
}

// announceCollaborativeEdit sends HMMM message about collaborative editing events
func (t *TerminalInterface) announceCollaborativeEdit(editData map[string]interface{}) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("collab-edit-%s", editData["session_id"])
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/collab/editing/%s", editData["session_id"]),
		Type:    "collaborative_edit",
		Payload: editData,
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Collaborative edit: %s", editData["action"]),
	}
	
	return t.sendHMMMMessage(message)
}

// announceCollaborativeChat sends HMMM message for chat in collaborative session
func (t *TerminalInterface) announceCollaborativeChat(chatData map[string]interface{}) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("collab-chat-%s", chatData["session_id"])
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/collab/chat/%s", chatData["session_id"]),
		Type:    "collaborative_chat",
		Payload: chatData,
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Chat: %s", chatData["message"]),
	}
	
	return t.sendHMMMMessage(message)
}

// === DECISION TRACKING HELPER FUNCTIONS ===

// getActiveDecisions retrieves all active decisions from DHT
func (t *TerminalInterface) getActiveDecisions() ([]Decision, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	
	// In a full implementation, we'd query a decision index
	// For now, we'll check a few known decision keys and return mock data for demonstration
	decisions := []Decision{
		{
			ID:          "DEC-" + generateRandomID(6),
			Title:       "Upgrade libp2p to v0.27",
			Description: "Proposal to upgrade the libp2p networking library to version 0.27 for improved performance and security features.",
			Type:        "technical",
			Proposer:    "autonomous-agent-7",
			ProposerType: "agent",
			CreatedAt:   time.Now().Add(-2 * time.Hour),
			Deadline:    time.Now().Add(2*time.Hour + 15*time.Minute),
			Status:      "voting",
			Votes:       make(map[string]DecisionVote),
			Metadata: map[string]interface{}{
				"priority": "medium",
				"category": "infrastructure",
			},
			Version: 1,
		},
		{
			ID:          "DEC-" + generateRandomID(6),
			Title:       "Adjust task timeout from 30s to 60s",
			Description: "Increase the default task timeout to accommodate more complex operations while maintaining system responsiveness.",
			Type:        "operational",
			Proposer:    "human-alice",
			ProposerType: "human",
			CreatedAt:   time.Now().Add(-1 * time.Hour),
			Deadline:    time.Now().Add(6*time.Hour + 30*time.Minute),
			Status:      "voting",
			Votes:       make(map[string]DecisionVote),
			Metadata: map[string]interface{}{
				"priority": "low",
				"impact": "moderate",
			},
			Version: 1,
		},
	}
	
	// Add some sample votes
	decisions[0].Votes["agent-monitor-1"] = DecisionVote{
		VoterID:    "agent-monitor-1",
		VoterType:  "agent",
		Vote:       "approve",
		Reasoning:  "Upgrade addresses known security vulnerabilities and improves peer discovery performance.",
		Timestamp:  time.Now().Add(-30 * time.Minute),
		Confidence: 0.85,
	}
	
	decisions[1].Votes["human-bob"] = DecisionVote{
		VoterID:    "human-bob",
		VoterType:  "human",
		Vote:       "defer",
		Reasoning:  "Need more analysis on potential impact to existing workflows before making this change.",
		Timestamp:  time.Now().Add(-15 * time.Minute),
		Confidence: 0.7,
	}
	
	return decisions, nil
}

// getDecisionByID retrieves a specific decision from DHT
func (t *TerminalInterface) getDecisionByID(decisionID string) (*Decision, error) {
	decisions, err := t.getActiveDecisions()
	if err != nil {
		return nil, err
	}
	
	for _, decision := range decisions {
		if decision.ID == decisionID {
			return &decision, nil
		}
	}
	
	return nil, fmt.Errorf("decision %s not found", decisionID)
}

// saveDecision stores a decision in DHT
func (t *TerminalInterface) saveDecision(decision *Decision) error {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	
	decisionKey := fmt.Sprintf("decision_%s", decision.ID)
	decisionBytes, err := json.Marshal(decision)
	if err != nil {
		return fmt.Errorf("failed to marshal decision: %w", err)
	}
	
	return t.runtime.DHT.PutValue(ctx, decisionKey, decisionBytes)
}

// formatDuration formats a duration into a human-readable string
func formatDuration(d time.Duration) string {
	if d < 0 {
		return "expired"
	}
	
	hours := int(d.Hours())
	minutes := int(d.Minutes()) % 60
	
	if hours > 24 {
		days := hours / 24
		hours = hours % 24
		return fmt.Sprintf("%dd %dh %dm", days, hours, minutes)
	} else if hours > 0 {
		return fmt.Sprintf("%dh %dm", hours, minutes)
	} else {
		return fmt.Sprintf("%dm", minutes)
	}
}

// generateRandomID generates a random alphanumeric ID
func generateRandomID(length int) string {
	const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
	result := make([]byte, length)
	for i := range result {
		num, _ := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
		result[i] = charset[num.Int64()]
	}
	return string(result)
}

// announceDecisionProposal sends HMMM message about new decision
func (t *TerminalInterface) announceDecisionProposal(decision *Decision) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("decision-%s", decision.ID)
	
	message := hmmm.Message{
		Topic:   "CHORUS/decisions/proposals",
		Type:    "decision_proposal",
		Payload: map[string]interface{}{
			"decision_id":   decision.ID,
			"title":         decision.Title,
			"description":   decision.Description,
			"type":          decision.Type,
			"proposer":      decision.Proposer,
			"proposer_type": decision.ProposerType,
			"deadline":      decision.Deadline.Unix(),
			"metadata":      decision.Metadata,
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("New decision proposal: %s", decision.Title),
	}
	
	return t.sendHMMMMessage(message)
}

// announceDecisionVote sends HMMM message about vote cast
func (t *TerminalInterface) announceDecisionVote(decisionID string, vote DecisionVote) error {
	msgID := t.generateMessageID()
	threadID := fmt.Sprintf("decision-%s", decisionID)
	
	message := hmmm.Message{
		Topic:   fmt.Sprintf("CHORUS/decisions/votes/%s", decisionID),
		Type:    "decision_vote",
		Payload: map[string]interface{}{
			"decision_id": decisionID,
			"voter_id":    vote.VoterID,
			"voter_type":  vote.VoterType,
			"vote":        vote.Vote,
			"reasoning":   vote.Reasoning,
			"confidence":  vote.Confidence,
		},
		Version:   "1.0",
		IssueID:   0,
		ThreadID:  threadID,
		MsgID:     msgID,
		NodeID:    t.runtime.Node.ID().String(),
		HopCount:  0,
		Timestamp: time.Now().Unix(),
		Message:   fmt.Sprintf("Vote cast: %s (%s)", vote.Vote, decisionID),
	}
	
	return t.sendHMMMMessage(message)
}

// wrapText wraps text to a specified width
func wrapText(text string, width int) string {
	words := strings.Fields(text)
	if len(words) == 0 {
		return text
	}
	
	var lines []string
	currentLine := words[0]
	
	for _, word := range words[1:] {
		if len(currentLine)+1+len(word) <= width {
			currentLine += " " + word
		} else {
			lines = append(lines, currentLine)
			currentLine = word
		}
	}
	lines = append(lines, currentLine)
	
	return strings.Join(lines, "\n")
}

// === WEB BRIDGE IMPLEMENTATION ===

// startWebBridge starts a web server for browser-based HAP access
func (t *TerminalInterface) startWebBridge() {
	fmt.Println("\n🌐 Starting HAP Web Bridge")
	fmt.Println(strings.Repeat("-", 30))
	
	// Choose port
	port := "8090"
	fmt.Printf("🔌 Starting web server on port %s\n", port)
	
	// Setup HTTP handlers
	mux := http.NewServeMux()
	
	// Static UI endpoints
	mux.HandleFunc("/", t.webHome)
	mux.HandleFunc("/status", t.webStatus)
	mux.HandleFunc("/decisions", t.webDecisions)
	mux.HandleFunc("/decisions/", t.webDecisionDetails)
	mux.HandleFunc("/collab", t.webCollaborative)
	mux.HandleFunc("/patches", t.webPatches)
	mux.HandleFunc("/hmmm", t.webHMMMMessages)
	
	// API endpoints
	mux.HandleFunc("/api/status", t.apiStatus)
	mux.HandleFunc("/api/decisions", t.apiDecisions)
	mux.HandleFunc("/api/decisions/vote", t.apiVoteDecision)
	mux.HandleFunc("/api/decisions/propose", t.apiProposeDecision)
	mux.HandleFunc("/api/collab/sessions", t.apiCollabSessions)
	mux.HandleFunc("/api/hmmm/send", t.apiSendHMMMMessage)
	
	// WebSocket endpoint for real-time updates
	mux.HandleFunc("/ws", t.webSocket)
	
	// Create server
	t.webServer = &http.Server{
		Addr:    ":" + port,
		Handler: mux,
	}
	
	// Start server in background
	go func() {
		fmt.Printf("✅ Web interface available at: http://localhost:%s\n", port)
		fmt.Println("📱 Browser HAP interface ready")
		fmt.Println("🔗 API endpoints available at: /api/*")
		fmt.Println("⚡ Real-time updates via WebSocket: /ws")
		fmt.Println()
		fmt.Println("💡 Press Enter to return to terminal...")
		
		if err := t.webServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			fmt.Printf("❌ Web server error: %v\n", err)
		}
	}()
	
	// Wait for user to return to terminal
	t.readInput()
	
	// Optionally stop the server
	fmt.Print("🛑 Stop web server? (y/n): ")
	input := t.readInput()
	if strings.ToLower(strings.TrimSpace(input)) == "y" {
		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		
		if err := t.webServer.Shutdown(ctx); err != nil {
			fmt.Printf("❌ Error stopping web server: %v\n", err)
		} else {
			fmt.Println("✅ Web server stopped")
		}
		t.webServer = nil
	} else {
		fmt.Printf("🌐 Web interface continues running at: http://localhost:%s\n", port)
	}
}

// webHome serves the main HAP web interface
func (t *TerminalInterface) webHome(w http.ResponseWriter, r *http.Request) {
	html := `<!DOCTYPE html>
<html>
<head>
    <title>CHORUS HAP - Human Agent Portal</title>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
        .header { background: #2c3e50; color: white; padding: 20px; border-radius: 10px; text-align: center; margin-bottom: 20px; }
        .header h1 { margin: 0; font-size: 2em; }
        .header p { margin: 5px 0 0 0; opacity: 0.8; }
        .container { max-width: 1200px; margin: 0 auto; }
        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; }
        .card { background: white; padding: 20px; border-radius: 10px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); border-left: 4px solid #3498db; }
        .card h3 { margin-top: 0; color: #2c3e50; }
        .card p { color: #666; line-height: 1.6; }
        .btn { display: inline-block; padding: 10px 20px; background: #3498db; color: white; text-decoration: none; border-radius: 5px; margin: 5px; }
        .btn:hover { background: #2980b9; }
        .status { background: #27ae60; color: white; padding: 5px 10px; border-radius: 3px; font-size: 0.9em; }
        .footer { text-align: center; margin-top: 40px; padding: 20px; color: #666; }
    </style>
</head>
<body>
    <div class="container">
        <div class="header">
            <h1>🎯 CHORUS HAP</h1>
            <p>Human Agent Portal - Web Interface</p>
            <span class="status" id="status">Connected</span>
        </div>
        
        <div class="grid">
            <div class="card">
                <h3>🗳️ Decision Management</h3>
                <p>Participate in network decisions, cast votes, and propose new decisions for community consideration.</p>
                <a href="/decisions" class="btn">View Decisions</a>
            </div>
            
            <div class="card">
                <h3>🤝 Collaborative Editing</h3>
                <p>Join collaborative editing sessions, work together on code, and sync changes in real-time.</p>
                <a href="/collab" class="btn">Join Sessions</a>
            </div>
            
            <div class="card">
                <h3>📝 Patch Management</h3>
                <p>Create patches, submit changes, and track patch reviews through the development workflow.</p>
                <a href="/patches" class="btn">Manage Patches</a>
            </div>
            
            <div class="card">
                <h3>🧠 HMMM Network</h3>
                <p>Send reasoning messages, participate in collaborative thinking, and view network discussions.</p>
                <a href="/hmmm" class="btn">HMMM Messages</a>
            </div>
            
            <div class="card">
                <h3>📊 Network Status</h3>
                <p>Monitor agent status, view connected peers, and track network health and performance.</p>
                <a href="/status" class="btn">View Status</a>
            </div>
            
            <div class="card">
                <h3>⚡ Live Updates</h3>
                <p>Real-time notifications of network events, decision updates, and collaborative activity.</p>
                <div id="live-updates">
                    <div style="padding: 10px; background: #ecf0f1; border-radius: 5px; margin-top: 10px;">
                        <small>WebSocket connection: <span id="ws-status">Connecting...</span></small>
                    </div>
                </div>
            </div>
        </div>
        
        <div class="footer">
            <p>CHORUS P2P Task Coordination System | HAP Web Bridge v1.0</p>
        </div>
    </div>

    <script>
        // WebSocket connection for real-time updates
        const ws = new WebSocket('ws://localhost:8090/ws');
        const wsStatus = document.getElementById('ws-status');
        const liveUpdates = document.getElementById('live-updates');
        
        ws.onopen = function() {
            wsStatus.textContent = 'Connected';
            wsStatus.style.color = '#27ae60';
        };
        
        ws.onclose = function() {
            wsStatus.textContent = 'Disconnected';
            wsStatus.style.color = '#e74c3c';
        };
        
        ws.onmessage = function(event) {
            const data = JSON.parse(event.data);
            const updateDiv = document.createElement('div');
            updateDiv.style.padding = '5px';
            updateDiv.style.background = '#3498db';
            updateDiv.style.color = 'white';
            updateDiv.style.borderRadius = '3px';
            updateDiv.style.marginTop = '5px';
            updateDiv.style.fontSize = '0.9em';
            updateDiv.textContent = data.type + ': ' + data.message;
            
            liveUpdates.appendChild(updateDiv);
            
            // Keep only last 5 updates
            while (liveUpdates.children.length > 6) {
                liveUpdates.removeChild(liveUpdates.children[1]);
            }
        };
    </script>
</body>
</html>`
	
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(html))
}

// webStatus serves the status page
func (t *TerminalInterface) webStatus(w http.ResponseWriter, r *http.Request) {
	// Get current status
	nodeID := t.runtime.Node.ID().String()
	peers := len(t.runtime.Node.Network().Peers())
	
	html := fmt.Sprintf(`<!DOCTYPE html>
<html>
<head>
    <title>HAP Status</title>
    <meta charset="UTF-8">
    <style>
        body { font-family: monospace; padding: 20px; background: #1e1e1e; color: #d4d4d4; }
        .header { color: #569cd6; font-size: 1.2em; margin-bottom: 20px; }
        .status-item { margin: 10px 0; padding: 10px; background: #252526; border-radius: 5px; }
        .label { color: #9cdcfe; font-weight: bold; }
        .value { color: #ce9178; }
        .good { color: #4ec9b0; }
        .warning { color: #dcdcaa; }
        .back-btn { background: #0e639c; color: white; padding: 10px 20px; border: none; border-radius: 5px; cursor: pointer; }
    </style>
</head>
<body>
    <div class="header">📊 CHORUS Agent Status</div>
    
    <div class="status-item">
        <span class="label">Node ID:</span> <span class="value">%s</span>
    </div>
    
    <div class="status-item">
        <span class="label">Connected Peers:</span> <span class="good">%d</span>
    </div>
    
    <div class="status-item">
        <span class="label">Agent Type:</span> <span class="value">Human Agent (HAP)</span>
    </div>
    
    <div class="status-item">
        <span class="label">HMMM Messages Sent:</span> <span class="value">%d</span>
    </div>
    
    <div class="status-item">
        <span class="label">Collaborative Session:</span> 
        <span class="value">%s</span>
    </div>
    
    <div class="status-item">
        <span class="label">Web Bridge:</span> <span class="good">Active</span>
    </div>
    
    <div style="margin-top: 20px;">
        <button class="back-btn" onclick="window.location='/'">← Back to Home</button>
        <button class="back-btn" onclick="location.reload()">🔄 Refresh</button>
    </div>
</body>
</html>`, 
		nodeID[:16]+"...", 
		peers, 
		t.hmmmMessageCount,
		func() string {
			if t.collaborativeSession != nil {
				return t.collaborativeSession.SessionID + " (Active)"
			}
			return "None"
		}())
	
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(html))
}

// webDecisions serves the decisions page
func (t *TerminalInterface) webDecisions(w http.ResponseWriter, r *http.Request) {
	decisions, err := t.getActiveDecisions()
	if err != nil {
		http.Error(w, fmt.Sprintf("Failed to load decisions: %v", err), http.StatusInternalServerError)
		return
	}
	
	html := `<!DOCTYPE html>
<html>
<head>
    <title>Network Decisions</title>
    <meta charset="UTF-8">
    <style>
        body { font-family: Arial, sans-serif; padding: 20px; background: #f8f9fa; }
        .header { background: #495057; color: white; padding: 20px; border-radius: 8px; margin-bottom: 20px; }
        .decision { background: white; margin: 10px 0; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
        .decision-title { font-size: 1.1em; font-weight: bold; color: #2c3e50; }
        .decision-meta { color: #666; font-size: 0.9em; margin: 5px 0; }
        .votes { margin: 10px 0; }
        .vote-count { display: inline-block; margin-right: 15px; padding: 3px 8px; border-radius: 3px; font-size: 0.8em; }
        .approve { background: #d4edda; color: #155724; }
        .reject { background: #f8d7da; color: #721c24; }
        .defer { background: #fff3cd; color: #856404; }
        .abstain { background: #d1ecf1; color: #0c5460; }
        .btn { background: #007bff; color: white; padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer; margin: 5px; }
        .btn:hover { background: #0056b3; }
        .back-btn { background: #6c757d; }
    </style>
</head>
<body>
    <div class="header">
        <h1>🗳️ Network Decisions</h1>
        <p>Active decisions requiring community input</p>
    </div>`
	
	for _, decision := range decisions {
		// Count votes
		approvals, rejections, deferrals, abstentions := 0, 0, 0, 0
		for _, vote := range decision.Votes {
			switch vote.Vote {
			case "approve": approvals++
			case "reject": rejections++
			case "defer": deferrals++
			case "abstain": abstentions++
			}
		}
		
		timeRemaining := formatDuration(decision.Deadline.Sub(time.Now()))
		
		html += fmt.Sprintf(`
    <div class="decision">
        <div class="decision-title">%s</div>
        <div class="decision-meta">
            Type: %s | Proposer: %s | Deadline: %s remaining
        </div>
        <div class="votes">
            <span class="vote-count approve">✅ %d</span>
            <span class="vote-count reject">❌ %d</span>
            <span class="vote-count defer">⏸️ %d</span>
            <span class="vote-count abstain">⚠️ %d</span>
        </div>
        <button class="btn" onclick="window.location='/decisions/%s'">View Details</button>
        <button class="btn" onclick="voteOnDecision('%s')">Cast Vote</button>
    </div>`, 
			decision.Title, 
			strings.Title(decision.Type), 
			decision.Proposer, 
			timeRemaining,
			approvals, rejections, deferrals, abstentions,
			decision.ID,
			decision.ID)
	}
	
	html += `
    <div style="margin-top: 20px;">
        <button class="btn back-btn" onclick="window.location='/'">← Back to Home</button>
        <button class="btn" onclick="proposeDecision()">Propose New Decision</button>
    </div>
    
    <script>
        function voteOnDecision(decisionId) {
            // Simple voting interface
            const vote = prompt('Vote on decision ' + decisionId + ':\\n1. approve\\n2. reject\\n3. defer\\n4. abstain\\n\\nEnter choice (1-4):');
            const voteMap = {'1': 'approve', '2': 'reject', '3': 'defer', '4': 'abstain'};
            const voteValue = voteMap[vote];
            
            if (!voteValue) {
                alert('Invalid vote option');
                return;
            }
            
            const reasoning = prompt('Please provide reasoning for your ' + voteValue + ' vote:');
            if (!reasoning || reasoning.trim() === '') {
                alert('Reasoning is required');
                return;
            }
            
            // Submit vote via API
            fetch('/api/decisions/vote', {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({
                    decision_id: decisionId,
                    vote: voteValue,
                    reasoning: reasoning
                })
            })
            .then(response => response.json())
            .then(data => {
                if (data.success) {
                    alert('Vote submitted successfully!');
                    location.reload();
                } else {
                    alert('Failed to submit vote: ' + data.error);
                }
            })
            .catch(err => alert('Error: ' + err));
        }
        
        function proposeDecision() {
            alert('Decision proposal interface coming soon! Use terminal HAP for now.');
        }
    </script>
</body>
</html>`
	
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(html))
}

// Placeholder web handlers for other interfaces
func (t *TerminalInterface) webDecisionDetails(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(`<html><body><h1>Decision Details</h1><p>Coming soon...</p><a href="/decisions">← Back</a></body></html>`))
}

func (t *TerminalInterface) webCollaborative(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(`<html><body><h1>Collaborative Editing</h1><p>Coming soon...</p><a href="/">← Back</a></body></html>`))
}

func (t *TerminalInterface) webPatches(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(`<html><body><h1>Patch Management</h1><p>Coming soon...</p><a href="/">← Back</a></body></html>`))
}

func (t *TerminalInterface) webHMMMMessages(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html")
	w.Write([]byte(`<html><body><h1>HMMM Messages</h1><p>Coming soon...</p><a href="/">← Back</a></body></html>`))
}

// API handlers
func (t *TerminalInterface) apiStatus(w http.ResponseWriter, r *http.Request) {
	status := map[string]interface{}{
		"node_id":              t.runtime.Node.ID().String(),
		"connected_peers":      len(t.runtime.Node.Network().Peers()),
		"hmmm_messages_sent":   t.hmmmMessageCount,
		"collaborative_session": func() interface{} {
			if t.collaborativeSession != nil {
				return t.collaborativeSession.SessionID
			}
			return nil
		}(),
		"web_bridge_active": true,
		"timestamp":         time.Now().Unix(),
	}
	
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(status)
}

func (t *TerminalInterface) apiDecisions(w http.ResponseWriter, r *http.Request) {
	decisions, err := t.getActiveDecisions()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(decisions)
}

func (t *TerminalInterface) apiVoteDecision(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}
	
	var req struct {
		DecisionID string `json:"decision_id"`
		Vote       string `json:"vote"`
		Reasoning  string `json:"reasoning"`
	}
	
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request", http.StatusBadRequest)
		return
	}
	
	// Validate vote
	validVotes := map[string]bool{"approve": true, "reject": true, "defer": true, "abstain": true}
	if !validVotes[req.Vote] {
		http.Error(w, "Invalid vote option", http.StatusBadRequest)
		return
	}
	
	if req.Reasoning == "" {
		http.Error(w, "Reasoning is required", http.StatusBadRequest)
		return
	}
	
	// Get and update decision
	decision, err := t.getDecisionByID(req.DecisionID)
	if err != nil {
		http.Error(w, "Decision not found", http.StatusNotFound)
		return
	}
	
	// Create vote record
	voteRecord := DecisionVote{
		VoterID:    t.runtime.Config.Agent.ID,
		VoterType:  "human",
		Vote:       req.Vote,
		Reasoning:  req.Reasoning,
		Timestamp:  time.Now(),
		Confidence: 1.0,
	}
	
	// Add vote to decision
	if decision.Votes == nil {
		decision.Votes = make(map[string]DecisionVote)
	}
	decision.Votes[t.runtime.Config.Agent.ID] = voteRecord
	decision.Version++
	
	// Save updated decision
	if err := t.saveDecision(decision); err != nil {
		http.Error(w, "Failed to save vote", http.StatusInternalServerError)
		return
	}
	
	// Announce vote via HMMM
	t.announceDecisionVote(req.DecisionID, voteRecord)
	
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"success": true,
		"message": "Vote submitted successfully",
	})
}

// Placeholder API handlers
func (t *TerminalInterface) apiProposeDecision(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"success": false,
		"error":   "Decision proposal API not yet implemented",
	})
}

func (t *TerminalInterface) apiCollabSessions(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"sessions": []interface{}{},
		"message":  "Collaborative sessions API not yet implemented",
	})
}

func (t *TerminalInterface) apiSendHMMMMessage(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]interface{}{
		"success": false,
		"error":   "HMMM message API not yet implemented",
	})
}

// webSocket handles WebSocket connections for real-time updates
func (t *TerminalInterface) webSocket(w http.ResponseWriter, r *http.Request) {
	// WebSocket upgrade would be implemented here for real-time updates
	// For now, return a simple message
	w.Header().Set("Content-Type", "text/plain")
	w.Write([]byte("WebSocket support not yet implemented"))
}