the-grid-cc 1.1.0

package/core/io_tower.py

@@ -0,0 +1,242 @@
+"""
+I/O Tower - Human checkpoints where Users connect to The Grid.
+
+"The I/O Tower is sacred. It's where we commune with the Users."
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Any, Callable
+from enum import Enum
+import uuid
+
+
+class CheckpointReason(Enum):
+    """Reason for I/O Tower checkpoint."""
+    FISSION_DEPTH = "fission_depth"
+    BEFORE_COMMIT = "before_commit"
+    ERROR_OCCURRED = "error_occurred"
+    LOW_ENERGY = "low_energy"
+    RECOGNIZER_FAILED = "recognizer_failed"
+    USER_REQUESTED = "user_requested"
+    DECISION_REQUIRED = "decision_required"
+    REVIEW_REQUIRED = "review_required"
+
+
+class UserDecision(Enum):
+    """User decision at checkpoint."""
+    AUTHORIZE = "authorize"      # Allow action to proceed
+    DENY = "deny"               # Block action
+    MODIFY = "modify"           # Modify before proceeding
+    MERGE = "merge"             # Merge operations (for fission)
+    ABORT = "abort"             # Abort entire operation
+    DEFER = "defer"             # Defer decision
+
+
+@dataclass
+class CheckpointOption:
+    """An option presented at a checkpoint."""
+    key: str
+    label: str
+    description: str
+    decision: UserDecision
+
+
+@dataclass
+class CheckpointContext:
+    """Context for an I/O Tower checkpoint."""
+    reason: CheckpointReason
+    program_id: str
+    program_name: str
+    depth: int
+    energy_remaining: int
+    energy_allocated: int
+    pending_actions: list[str] = field(default_factory=list)
+    details: dict = field(default_factory=dict)
+
+
+@dataclass
+class CheckpointResult:
+    """Result of a checkpoint interaction."""
+    decision: UserDecision
+    timestamp: datetime
+    user_input: Optional[str] = None
+    modifications: dict = field(default_factory=dict)
+
+
+class IOTower:
+    """
+    I/O Tower - Human checkpoint interface.
+
+    Provides human checkpoints at critical moments:
+    - Fission depth >= configured threshold
+    - Before commits
+    - On errors
+    - Energy running low
+    - Recognizer flags issues
+    """
+
+    # Default options for common checkpoint types
+    DEFAULT_OPTIONS = {
+        CheckpointReason.FISSION_DEPTH: [
+            CheckpointOption("A", "Authorize", "Allow fission to continue", UserDecision.AUTHORIZE),
+            CheckpointOption("M", "Merge", "Combine into single Program (saves Energy)", UserDecision.MERGE),
+            CheckpointOption("D", "Deny", "Block spawning, continue with current Program", UserDecision.DENY),
+            CheckpointOption("V", "View Disc", "See full context before deciding", UserDecision.DEFER),
+        ],
+        CheckpointReason.BEFORE_COMMIT: [
+            CheckpointOption("C", "Commit", "Proceed with commit", UserDecision.AUTHORIZE),
+            CheckpointOption("R", "Review", "Review changes first", UserDecision.DEFER),
+            CheckpointOption("M", "Modify", "Modify commit message/contents", UserDecision.MODIFY),
+            CheckpointOption("A", "Abort", "Cancel commit", UserDecision.ABORT),
+        ],
+        CheckpointReason.ERROR_OCCURRED: [
+            CheckpointOption("R", "Retry", "Retry the operation", UserDecision.AUTHORIZE),
+            CheckpointOption("S", "Skip", "Skip this operation", UserDecision.DENY),
+            CheckpointOption("A", "Abort", "Abort the entire process", UserDecision.ABORT),
+            CheckpointOption("D", "Debug", "View debug information", UserDecision.DEFER),
+        ],
+        CheckpointReason.LOW_ENERGY: [
+            CheckpointOption("C", "Continue", "Continue with remaining energy", UserDecision.AUTHORIZE),
+            CheckpointOption("A", "Allocate", "Allocate more energy", UserDecision.MODIFY),
+            CheckpointOption("P", "Pause", "Pause and save state", UserDecision.DEFER),
+            CheckpointOption("S", "Stop", "Stop execution", UserDecision.ABORT),
+        ],
+        CheckpointReason.RECOGNIZER_FAILED: [
+            CheckpointOption("F", "Fix", "Fix issues and retry", UserDecision.MODIFY),
+            CheckpointOption("O", "Override", "Override and continue", UserDecision.AUTHORIZE),
+            CheckpointOption("R", "Review", "Review issues in detail", UserDecision.DEFER),
+            CheckpointOption("A", "Abort", "Abort due to validation failure", UserDecision.ABORT),
+        ],
+    }
+
+    def __init__(
+        self,
+        require_at_depth: int = 3,
+        require_before_commit: bool = True,
+        require_on_error: bool = True,
+        require_on_low_energy: bool = True,
+        timeout_seconds: int = 300,
+    ):
+        self.require_at_depth = require_at_depth
+        self.require_before_commit = require_before_commit
+        self.require_on_error = require_on_error
+        self.require_on_low_energy = require_on_low_energy
+        self.timeout_seconds = timeout_seconds
+
+        # Checkpoint history
+        self.checkpoints: list[tuple[CheckpointContext, CheckpointResult]] = []
+
+        # Callback for user input (to be set by CLI)
+        self.input_handler: Optional[Callable[[CheckpointContext, list[CheckpointOption]], CheckpointResult]] = None
+
+    def should_checkpoint(
+        self,
+        reason: CheckpointReason,
+        depth: int = 0,
+        energy_percentage: float = 100.0,
+    ) -> bool:
+        """Determine if a checkpoint is required."""
+        if reason == CheckpointReason.FISSION_DEPTH:
+            return depth >= self.require_at_depth
+        elif reason == CheckpointReason.BEFORE_COMMIT:
+            return self.require_before_commit
+        elif reason == CheckpointReason.ERROR_OCCURRED:
+            return self.require_on_error
+        elif reason == CheckpointReason.LOW_ENERGY:
+            return self.require_on_low_energy and energy_percentage < 10
+        elif reason == CheckpointReason.RECOGNIZER_FAILED:
+            return True  # Always checkpoint on validation failure
+        elif reason == CheckpointReason.USER_REQUESTED:
+            return True
+        return False
+
+    def checkpoint(
+        self,
+        context: CheckpointContext,
+        options: list[CheckpointOption] = None,
+    ) -> CheckpointResult:
+        """
+        Trigger a checkpoint and await user decision.
+
+        In actual use, this would pause execution and present
+        options to the user through the CLI.
+        """
+        if options is None:
+            options = self.DEFAULT_OPTIONS.get(context.reason, [])
+
+        # If we have an input handler, use it
+        if self.input_handler:
+            result = self.input_handler(context, options)
+        else:
+            # Default: authorize (for testing/non-interactive)
+            result = CheckpointResult(
+                decision=UserDecision.AUTHORIZE,
+                timestamp=datetime.now(),
+            )
+
+        self.checkpoints.append((context, result))
+        return result
+
+    def render_checkpoint(
+        self,
+        context: CheckpointContext,
+        options: list[CheckpointOption],
+    ) -> str:
+        """Render checkpoint display."""
+        lines = [
+            "╔" + "═" * 77 + "╗",
+            "║  ⛯ I/O TOWER - Human Input Required" + " " * 40 + "║",
+            "╠" + "═" * 77 + "╣",
+            "║" + " " * 77 + "║",
+            f"║  REASON: {context.reason.value:<65}║",
+            "║" + " " * 77 + "║",
+            "║  CONTEXT:" + " " * 67 + "║",
+        ]
+
+        # Program info
+        lines.append(f"║  Program \"{context.program_name}\" (depth: {context.depth})" + " " * (48 - len(context.program_name)) + "║")
+        lines.append(f"║  Energy: {context.energy_remaining}/{context.energy_allocated}" + " " * 55 + "║")
+
+        # Pending actions
+        if context.pending_actions:
+            lines.append("║" + " " * 77 + "║")
+            lines.append("║  Pending actions:" + " " * 59 + "║")
+            for action in context.pending_actions[:5]:  # Limit display
+                lines.append(f"║    • {action:<71}║")
+
+        # Details
+        if context.details:
+            lines.append("║" + " " * 77 + "║")
+            for key, value in list(context.details.items())[:5]:
+                lines.append(f"║  {key}: {str(value):<69}║")
+
+        # Options
+        lines.append("║" + " " * 77 + "║")
+        lines.append("║  ┌" + "─" * 73 + "┐  ║")
+        for opt in options:
+            lines.append(f"║  │  [{opt.key}] {opt.label} - {opt.description:<55}│  ║")
+        lines.append("║  └" + "─" * 73 + "┘  ║")
+        lines.append("║" + " " * 77 + "║")
+        lines.append("╚" + "═" * 77 + "╝")
+
+        return "\n".join(lines)
+
+    def get_history(self) -> list[dict]:
+        """Get checkpoint history."""
+        return [
+            {
+                "context": {
+                    "reason": ctx.reason.value,
+                    "program_id": ctx.program_id,
+                    "program_name": ctx.program_name,
+                    "depth": ctx.depth,
+                },
+                "result": {
+                    "decision": res.decision.value,
+                    "timestamp": res.timestamp.isoformat(),
+                    "user_input": res.user_input,
+                },
+            }
+            for ctx, res in self.checkpoints
+        ]

package/core/program.py

@@ -0,0 +1,268 @@
+"""
+Program - Autonomous executor on The Grid.
+
+"Programs are living entities on The Grid. They execute, they adapt, they spawn."
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional, Callable, Any
+from enum import Enum
+import uuid
+
+from .disc import IdentityDisc
+
+
+class ProgramStatus(Enum):
+    """Status of a Program."""
+    INITIALIZING = "initializing"
+    RUNNING = "running"
+    SPAWNING = "spawning"
+    WAITING = "waiting"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    DEREZZED = "derezzed"
+
+
+class ProgramType(Enum):
+    """Type of Program."""
+    STANDARD = "standard"
+    RECOGNIZER = "recognizer"
+    LIGHT_CYCLE = "light_cycle"  # Fast execution path
+
+
+@dataclass
+class SpawnRequest:
+    """Request to spawn a child Program."""
+    name: str
+    purpose: str
+    energy_budget: int
+    constraints: list[str] = field(default_factory=list)
+    approved: bool = False
+
+
+class Program:
+    """
+    Program - Autonomous executor (subagent) on The Grid.
+
+    Programs can:
+    - Execute tasks autonomously
+    - Spawn child Programs (fission)
+    - Carry context via Identity Disc
+    - Consume energy from their budget
+    """
+
+    def __init__(
+        self,
+        name: str,
+        purpose: str,
+        parent: Optional["Program"] = None,
+        energy_budget: int = 100,
+        program_type: ProgramType = ProgramType.STANDARD,
+    ):
+        self.id = str(uuid.uuid4())[:8]
+        self.name = name
+        self.purpose = purpose
+        self.program_type = program_type
+
+        self.status = ProgramStatus.INITIALIZING
+        self.created_at = datetime.now()
+        self.started_at: Optional[datetime] = None
+        self.completed_at: Optional[datetime] = None
+
+        # Fission lineage
+        self.parent = parent
+        self.children: list["Program"] = []
+        self.depth = 0 if parent is None else parent.depth + 1
+
+        # Identity Disc (context carrier)
+        parent_disc = parent.disc if parent else None
+        self.disc = IdentityDisc(
+            program_id=f"program:{self.id}",
+            purpose=purpose,
+            parent_disc=parent_disc,
+        )
+        self.disc.energy_allocated = energy_budget
+
+        # Execution state
+        self.current_action = "Initializing"
+        self.output: Any = None
+        self.error: Optional[str] = None
+
+        # Spawn requests (pending fission)
+        self.spawn_requests: list[SpawnRequest] = []
+
+    def start(self) -> None:
+        """Start Program execution."""
+        self.status = ProgramStatus.RUNNING
+        self.started_at = datetime.now()
+        self.current_action = "Running"
+
+    def update_action(self, action: str) -> None:
+        """Update current action."""
+        self.current_action = action
+
+    def request_spawn(
+        self,
+        name: str,
+        purpose: str,
+        energy_budget: int,
+        constraints: list[str] = None,
+    ) -> SpawnRequest:
+        """Request to spawn a child Program."""
+        request = SpawnRequest(
+            name=name,
+            purpose=purpose,
+            energy_budget=energy_budget,
+            constraints=constraints or [],
+        )
+        self.spawn_requests.append(request)
+        self.status = ProgramStatus.SPAWNING
+        return request
+
+    def spawn(self, request: SpawnRequest) -> Optional["Program"]:
+        """Spawn a child Program from approved request."""
+        if not request.approved:
+            return None
+
+        # Deduct energy for spawn
+        if not self.disc.consume_energy(request.energy_budget):
+            return None
+
+        child = Program(
+            name=request.name,
+            purpose=request.purpose,
+            parent=self,
+            energy_budget=request.energy_budget,
+        )
+        for constraint in request.constraints:
+            child.disc.add_constraint(constraint)
+
+        self.children.append(child)
+        return child
+
+    def consume_energy(self, amount: int, description: str = "") -> bool:
+        """Consume energy for an operation."""
+        success = self.disc.consume_energy(amount)
+        if success:
+            self.disc.record_discovery(
+                finding=f"Energy consumed: {amount}",
+                source="energy_system",
+                relevance="low",
+            )
+        return success
+
+    def complete(self, output: Any = None) -> None:
+        """Mark Program as completed."""
+        self.status = ProgramStatus.COMPLETED
+        self.completed_at = datetime.now()
+        self.output = output
+        self.current_action = "Completed"
+
+        # Return unused energy to parent
+        if self.parent:
+            unused = self.disc.energy_remaining()
+            if unused > 0:
+                self.parent.disc.energy_allocated += unused
+
+    def fail(self, error: str) -> None:
+        """Mark Program as failed."""
+        self.status = ProgramStatus.FAILED
+        self.completed_at = datetime.now()
+        self.error = error
+        self.current_action = f"Failed: {error}"
+
+    def derez(self) -> None:
+        """Derez (terminate) this Program and all children."""
+        self.status = ProgramStatus.DEREZZED
+        self.disc.derez()
+        for child in self.children:
+            child.derez()
+
+    def wait_for_children(self) -> None:
+        """Set status to waiting for children to complete."""
+        self.status = ProgramStatus.WAITING
+        self.current_action = "Waiting for child Programs"
+
+    def all_children_completed(self) -> bool:
+        """Check if all child Programs are completed."""
+        return all(
+            c.status in (ProgramStatus.COMPLETED, ProgramStatus.DEREZZED)
+            for c in self.children
+        )
+
+    def any_child_failed(self) -> bool:
+        """Check if any child Program failed."""
+        return any(
+            c.status == ProgramStatus.FAILED
+            for c in self.children
+        )
+
+    def get_lineage(self) -> list[str]:
+        """Get the lineage chain of Program names."""
+        return self.disc.get_lineage()
+
+    def depth_display(self) -> str:
+        """Get depth indicator for display."""
+        return "  " * self.depth
+
+    def status_icon(self) -> str:
+        """Get status icon for display."""
+        icons = {
+            ProgramStatus.INITIALIZING: "○",
+            ProgramStatus.RUNNING: "◐",
+            ProgramStatus.SPAWNING: "◎",
+            ProgramStatus.WAITING: "◑",
+            ProgramStatus.COMPLETED: "●",
+            ProgramStatus.FAILED: "✗",
+            ProgramStatus.DEREZZED: "◯",
+        }
+        return icons.get(self.status, "?")
+
+    def duration(self) -> Optional[float]:
+        """Get execution duration in seconds."""
+        if not self.started_at:
+            return None
+        end = self.completed_at or datetime.now()
+        return (end - self.started_at).total_seconds()
+
+    def energy_percentage(self) -> float:
+        """Get energy as percentage."""
+        return self.disc.energy_percentage()
+
+    def summary(self) -> str:
+        """Get Program summary."""
+        lines = [
+            f"Program: {self.name} [{self.id}]",
+            f"  Purpose: {self.purpose}",
+            f"  Status: {self.status.value}",
+            f"  Depth: {self.depth}",
+            f"  Energy: {self.disc.energy_remaining()}/{self.disc.energy_allocated}",
+            f"  Children: {len(self.children)}",
+            f"  Action: {self.current_action}",
+        ]
+        return "\n".join(lines)
+
+    def to_dict(self) -> dict:
+        """Serialize Program to dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "purpose": self.purpose,
+            "type": self.program_type.value,
+            "status": self.status.value,
+            "depth": self.depth,
+            "current_action": self.current_action,
+            "energy_remaining": self.disc.energy_remaining(),
+            "energy_allocated": self.disc.energy_allocated,
+            "children": [c.to_dict() for c in self.children],
+            "lineage": self.get_lineage(),
+            "output": str(self.output) if self.output else None,
+            "error": self.error,
+            "created_at": self.created_at.isoformat(),
+            "started_at": self.started_at.isoformat() if self.started_at else None,
+            "completed_at": self.completed_at.isoformat() if self.completed_at else None,
+        }
+
+    def __repr__(self) -> str:
+        return f"Program(id={self.id}, name={self.name}, depth={self.depth})"