cortex-runtime 0.2.0__py3-none-any.whl

cortex/tools/cli/main.py

@@ -0,0 +1,139 @@
+"""
+Cortex Developer CLI Command Entrypoint
+
+Usage:
+    cortex init <project_name> [--type {app|plugin}]
+    cortex workflow run <workflow_file> [--output <file>]
+    cortex workflow inspect <workflow_id_or_file>
+    cortex workflow replay <workflow_id_or_file>
+"""
+
+import argparse
+import os
+import sys
+from collections.abc import Sequence
+from typing import cast
+
+from cortex.exceptions import CortexError
+from cortex.tools.cli.runner import inspect_workflow, replay_workflow, run_workflow_file
+from cortex.tools.cli.scaffolder import scaffold_project
+
+
+def cli_entrypoint() -> None:
+    """Console script entrypoint for PyPI cortex-runtime executable."""
+    sys.exit(main())
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Main CLI entrypoint for Cortex framework."""
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        prog="cortex",
+        description="Cortex Platform Developer CLI & Workflow Engine",
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+
+    # cortex init
+    init_parser = subparsers.add_parser("init", help="Scaffold a new Cortex plugin or application")
+    _ = init_parser.add_argument("project_name", help="Name of the project directory to create")
+    _ = init_parser.add_argument(
+        "--type",
+        choices=["app", "plugin"],
+        default="app",
+        help="Type of project to scaffold (default: app)",
+    )
+
+    # cortex workflow
+    wf_parser = subparsers.add_parser("workflow", help="Workflow execution and inspection management")
+    wf_sub = wf_parser.add_subparsers(dest="wf_command", help="Workflow subcommand")
+
+    # cortex workflow run
+    wf_run = wf_sub.add_parser("run", help="Trigger workflow execution from spec file")
+    _ = wf_run.add_argument("workflow_file", help="Path to workflow definition JSON file")
+    _ = wf_run.add_argument("--output", "-o", help="Optional path to save event journal JSON trace")
+
+    # cortex workflow inspect
+    wf_inspect = wf_sub.add_parser("inspect", help="Inspect execution graph and lineage for workflow ID or file")
+    _ = wf_inspect.add_argument("workflow_id", help="Workflow ID or path to event trace JSON file")
+
+    # cortex workflow replay
+    wf_replay = wf_sub.add_parser("replay", help="Deterministically replay workflow execution trace")
+    _ = wf_replay.add_argument("workflow_id", help="Workflow ID or path to event trace JSON file")
+
+    args = parser.parse_args(argv)
+    cmd = str(getattr(args, "command", ""))
+    wf_cmd = str(getattr(args, "wf_command", ""))
+
+    try:
+        if cmd == "init":
+            p_name = str(getattr(args, "project_name", "my_cortex_app"))
+            p_type = str(getattr(args, "type", "app"))
+            path = scaffold_project(p_name, project_type=p_type)
+            print(f"[+] Successfully scaffolded Cortex {p_type} project at: {path}")
+            return 0
+
+        elif cmd == "workflow":
+            if wf_cmd == "run":
+                wf_file = str(getattr(args, "workflow_file", ""))
+                out_file = cast(str | None, getattr(args, "output", None))
+                res = run_workflow_file(wf_file, output_file=out_file)
+                print("[+] Workflow execution finished.")
+                print(f"    ID:          {res['workflow_id']}")
+                print(f"    State:       {res['state']}")
+                print(f"    Events Log:  {res['event_count']}")
+                print(f"    Trace Saved: {res['output_file']}")
+                return 0
+
+            elif wf_cmd == "inspect":
+                wf_id = str(getattr(args, "workflow_id", ""))
+                res = inspect_workflow(wf_id)
+                causality_tree = cast(list[str], res.get("causality_tree", []))
+                failed_nodes = cast(list[dict[str, object]], res.get("failed_nodes", []))
+
+                print("=== Cortex Execution Graph Inspection ===")
+                print(f"Workflow ID:   {res['workflow_id']}")
+                print(f"Name:          {res['name']}")
+                print(f"Goal:          {res['goal']}")
+                print(f"State:         {res['state']}")
+                print(f"Total Nodes:   {res['node_count']}")
+                print("\n--- Causality Tree ---")
+                for line in causality_tree:
+                    print(f"  {line}")
+                if failed_nodes:
+                    print(f"\n[!] Verification Failures ({len(failed_nodes)}):")
+                    for node in failed_nodes:
+                        print(f"    - Node {node['id']}: {node['payload']}")
+                else:
+                    print("\n[+] Verification Status: ALL PASSED")
+                return 0
+
+            elif wf_cmd == "replay":
+                wf_id = str(getattr(args, "workflow_id", ""))
+                res = replay_workflow(wf_id)
+                print("=== Cortex Deterministic Replay Engine ===")
+                print(f"Workflow ID:      {res['workflow_id']}")
+                print(f"Events Replayed:  {res['events_replayed']}")
+                print(f"Status:           {'SUCCESS' if res['deterministic'] else 'FAILED'}")
+                print(f"Result:           {res['verification_result']}")
+                return 0 if res["deterministic"] else 1
+
+            else:
+                wf_parser.print_help(sys.stderr)
+                return 1
+
+        else:
+            parser.print_help(sys.stderr)
+            return 1
+
+    except CortexError as err:
+        print(f"[!] Cortex Error: {err.message}", file=sys.stderr)
+        return err.exit_code
+    except Exception as err:
+        print(f"[!] Unexpected Error: {err}", file=sys.stderr)
+        return getattr(os, "EX_SOFTWARE", 1)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cortex/tools/cli/runner.py

@@ -0,0 +1,94 @@
+"""
+Thin CLI Adapter Engine for Cortex Platform
+
+Delegates workflow lifecycle execution, trace inspection, and deterministic
+replay directly to the public CortexClient API. Contains zero state machine logic.
+"""
+
+import json
+import os
+from typing import cast
+
+from cortex.client import CortexClient
+from cortex.exceptions import WorkflowExecutionError
+from cortex.schema import IntentEvent, WorkflowPolicy
+
+
+def run_workflow_file(workflow_file: str, output_file: str | None = None) -> dict[str, str | int]:
+    """Runs a workflow file by instantiating CortexClient thin wrapper."""
+    if not os.path.exists(workflow_file):
+        raise WorkflowExecutionError(f"Workflow file not found: {workflow_file}")
+
+    with open(workflow_file, "r", encoding="utf-8") as f:
+        if workflow_file.endswith(".yaml") or workflow_file.endswith(".yml"):
+            import yaml
+            data = cast(dict[str, object], yaml.safe_load(f)) or {}
+        else:
+            data = cast(dict[str, object], json.load(f))
+
+    client = CortexClient()
+
+    wf_name = str(data.get("name", "cli_workflow"))
+    wf_goal = str(data.get("goal", "Execute CLI workflow"))
+    policy_data = cast(dict[str, object], data.get("policy", {}))
+
+    policy = WorkflowPolicy(
+        timeout_seconds=float(str(policy_data.get("timeout_seconds", 300.0))),
+        max_retries=int(str(policy_data.get("max_retries", 3))),
+        abort_on_verification_failure=bool(policy_data.get("abort_on_verification_failure", True)),
+    )
+
+    workflow = client.create_workflow(name=wf_name, goal=wf_goal, policy=policy)
+
+    intent_data = cast(dict[str, object], data.get("initial_intent", {}))
+    initial_intent = IntentEvent(
+        workflow_id=workflow.workflow_id,
+        goal=str(intent_data.get("goal", wf_goal)),
+        parameters=cast(dict[str, object], intent_data.get("parameters", {})),
+    )
+
+    executed_wf = client.run_workflow(workflow, initial_intent=initial_intent)
+
+    if output_file is None:
+        cortex_dir = os.path.join(os.getcwd(), ".cortex", "events")
+        output_file = os.path.join(cortex_dir, f"{executed_wf.workflow_id}.json")
+
+    saved_path = client.save_trace(executed_wf.workflow_id, output_file, name=wf_name, goal=wf_goal)
+
+    return {
+        "workflow_id": executed_wf.workflow_id,
+        "state": executed_wf.state.value,
+        "event_count": len(client.event_store.get_log()),
+        "output_file": saved_path,
+    }
+
+
+def inspect_workflow(trace_path_or_id: str) -> dict[str, str | int | list[str] | list[dict[str, object]]]:
+    """Delegates trace inspection to CortexClient."""
+    client = CortexClient()
+    res = client.inspect_workflow(trace_path_or_id)
+    causality_tree = cast(list[str], res.get("causality_tree", []))
+    failed_nodes = cast(list[dict[str, object]], res.get("failed_nodes", []))
+
+    return {
+        "workflow_id": trace_path_or_id,
+        "name": cast(str, res.get("name", "Inspected Workflow")),
+        "goal": cast(str, res.get("goal", "Trace Inspection")),
+        "state": "FAILED" if failed_nodes else "COMPLETED",
+        "node_count": cast(int, res.get("node_count", 0)),
+        "total_events": cast(int, res.get("total_events", 0)),
+        "causality_tree": causality_tree,
+        "failed_nodes": failed_nodes,
+    }
+
+
+def replay_workflow(trace_path_or_id: str) -> dict[str, str | int | bool]:
+    """Delegates trace replay to CortexClient."""
+    client = CortexClient()
+    res = client.replay_workflow(trace_path_or_id)
+    return {
+        "workflow_id": trace_path_or_id,
+        "events_replayed": cast(int, res.get("replayed_count", 0)),
+        "deterministic": cast(bool, res.get("deterministic", False)),
+        "verification_result": cast(str, res.get("reason", "")),
+    }

cortex/tools/cli/scaffolder.py

@@ -0,0 +1,109 @@
+"""
+Cortex Project Scaffolding Engine
+
+Scaffolds a new Cortex application or plugin project template with declarative
+manifests, workflow definitions, and sample handlers adhering to public Cortex standards.
+"""
+
+import json
+import os
+
+
+def scaffold_project(project_name: str, project_type: str = "app", target_dir: str | None = None) -> str:
+    """Scaffolds a standard Cortex application or plugin project directory structure."""
+    if target_dir is None:
+        target_dir = os.path.join(os.getcwd(), project_name)
+
+    os.makedirs(target_dir, exist_ok=True)
+
+    cortex_config: dict[str, str] = {
+        "name": project_name,
+        "type": project_type,
+        "version": "0.1.0",
+        "cortex_version": "0.2.0",
+        "entrypoint": "main.py" if project_type == "app" else "plugin.py",
+    }
+    with open(os.path.join(target_dir, "cortex.json"), "w", encoding="utf-8") as f:
+        json.dump(cortex_config, f, indent=2)
+
+    plugin_manifest: dict[str, str | list[str]] = {
+        "name": f"{project_name}-plugin",
+        "version": "0.1.0",
+        "description": f"Custom {project_type} plugin for {project_name}",
+        "consumes_events": ["IntentEvent"],
+        "produces_events": ["PlanGeneratedEvent", "CommandIssuedEvent"],
+        "required_capabilities": ["workflow.plan.create", "workflow.command.issue"],
+    }
+    with open(os.path.join(target_dir, "manifest.json"), "w", encoding="utf-8") as f:
+        json.dump(plugin_manifest, f, indent=2)
+
+    workflow_def: dict[str, object] = {
+        "name": f"{project_name}_workflow",
+        "goal": f"Execute default workflow for {project_name}",
+        "policy": {
+            "timeout_seconds": 300.0,
+            "max_retries": 3,
+            "abort_on_verification_failure": True,
+        },
+        "initial_intent": {
+            "goal": f"Initialize {project_name} execution",
+            "parameters": {"environment": "development"},
+        },
+    }
+    with open(os.path.join(target_dir, "workflow.json"), "w", encoding="utf-8") as f:
+        json.dump(workflow_def, f, indent=2)
+
+    code_content = _generate_sample_code(project_name, project_type)
+    code_filename = "main.py" if project_type == "app" else "plugin.py"
+    with open(os.path.join(target_dir, code_filename), "w", encoding="utf-8") as f:
+        _ = f.write(code_content)
+
+    return target_dir
+
+
+def _generate_sample_code(project_name: str, project_type: str) -> str:
+    if project_type == "plugin":
+        return f'''"""
+Plugin Handler for {project_name}
+"""
+
+from cortex import BasePlugin, PluginManifest, IntentEvent, PlanGeneratedEvent
+
+MANIFEST = PluginManifest(
+    name="{project_name}-plugin",
+    version="0.1.0",
+    description="Custom plugin for {project_name}",
+    consumes_events=["IntentEvent"],
+    produces_events=["PlanGeneratedEvent"],
+    required_capabilities=["workflow.plan.create"],
+)
+
+class CustomPlugin(BasePlugin):
+    def __init__(self):
+        super().__init__(MANIFEST)
+
+    def on_event(self, event):
+        if isinstance(event, IntentEvent) and self.context:
+            plan = PlanGeneratedEvent(
+                intent_id=event.intent_id,
+                workflow_id=event.workflow_id,
+                steps=[{{"step": 1, "action": "initialize"}}]
+            )
+            self.context.publish(plan)
+'''
+    return f'''"""
+Application Handler for {project_name}
+"""
+
+from cortex import CortexClient, IntentEvent
+
+def run_app():
+    client = CortexClient()
+    workflow = client.create_workflow(name="{project_name}_workflow", goal="Run autonomous task")
+    intent = IntentEvent(workflow_id=workflow.workflow_id, goal=workflow.goal)
+    executed = client.run_workflow(workflow, initial_intent=intent)
+    print(f"Workflow {{executed.workflow_id}} status: {{executed.state.value}}")
+
+if __name__ == "__main__":
+    run_app()
+'''

cortex/tools/gen_test_bin.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+import os
+import struct
+
+
+def encode_inst(opcode: int, stcr_id: int, arg_reg: int, imm: int) -> int:
+    return ((opcode & 0x3F) << 26) | ((stcr_id & 0x1F) << 21) | ((arg_reg & 0x1F) << 16) | (imm & 0xFFFF)
+
+def generate_canonical_test_bin(output_path: str):
+    MAGIC = b"CORTEX"
+    VERSION = 1
+
+    # Sequence of instructions exercising all SDS v1.0 refinement properties:
+    instructions = [
+        encode_inst(0x01, 0, 1, 0),      # PC 0: invoke_cap STCR0, R1 -> Expected: COMMIT (Valid)
+        encode_inst(0x03, 0, 0, 0x4000), # PC 1: restrict_cap STCR0, READ (Bit 62) -> Expected: COMMIT
+        encode_inst(0x01, 0, 2, 0),      # PC 2: invoke_cap STCR0, R2 -> Expected: COMMIT
+        encode_inst(0x05, 0, 0, 0),      # PC 3: hec.inc -> Expected: COMMIT (Epoch = 1)
+        encode_inst(0x01, 0, 3, 0),      # PC 4: invoke_cap STCR0, R3 -> Expected: EFF_TRAP (Epoch Expired if Max_Epoch == 0)
+        encode_inst(0x00, 0, 0, 0),      # PC 5: Opcode 0x00 -> Expected: EFF_TRAP (Illegal/Reserved Opcode)
+    ]
+
+    header = MAGIC + struct.pack(">H", VERSION) + struct.pack(">I", len(instructions))
+    payload = b"".join(struct.pack(">I", inst) for inst in instructions)
+
+    os.makedirs(os.path.dirname(os.path.abspath(output_path)), exist_ok=True)
+    with open(output_path, "wb") as f:
+        f.write(header + payload)
+
+    print(f"[+] Canonical test binary successfully generated at {output_path} ({len(header + payload)} bytes)")
+
+if __name__ == "__main__":
+    import sys
+    out_path = sys.argv[1] if len(sys.argv) > 1 else "tests/canonical_test_program.bin"
+    generate_canonical_test_bin(out_path)

cortex/tools/kernel/__init__.py

@@ -0,0 +1,3 @@
+"""
+Cortex Kernel Runtime Core
+"""

cortex/tools/kernel/actors/__init__.py

@@ -0,0 +1,3 @@
+"""
+Kernel Actors Infrastructure
+"""

cortex/tools/kernel/actors/executor.py

@@ -0,0 +1,44 @@
+"""
+TaskExecutor Actor
+
+Consumes: PlanGeneratedEvent
+Produces: CommandIssuedEvent
+
+Iterates over the steps within a PlanGeneratedEvent and issues
+individual CommandIssuedEvent instances to the driver layer.
+The executor has zero knowledge of which driver will consume
+the command — it only knows the message contract.
+"""
+
+from collections.abc import Callable
+from typing import cast
+
+from cortex.tools.kernel.context import RuntimeContext
+from cortex.tools.kernel.schema.message import CommandIssuedEvent, PlanGeneratedEvent
+from cortex.tools.kernel.transport import AnyEvent
+
+
+class TaskExecutorActor:
+    context: RuntimeContext
+    publish_cb: Callable[[AnyEvent], object]
+
+    def __init__(self, context: RuntimeContext, publish_cb: Callable[[AnyEvent], object]):
+        self.context = context
+        self.publish_cb = publish_cb
+
+    def handle_plan(self, plan: PlanGeneratedEvent) -> list[CommandIssuedEvent]:
+        commands: list[CommandIssuedEvent] = []
+        for step in plan.steps:
+            action_val = str(step.get("action", "unknown"))
+            params_val = step.get("parameters", {})
+            params_dict = cast(dict[str, object], params_val) if isinstance(params_val, dict) else {}
+
+            cmd = CommandIssuedEvent(
+                plan_id=plan.plan_id,
+                correlation_id=plan.correlation_id,
+                action=action_val,
+                parameters=params_dict,
+            )
+            commands.append(cmd)
+            self.publish_cb(cmd)
+        return commands

cortex/tools/kernel/actors/planner.py

@@ -0,0 +1,38 @@
+"""
+IntentPlanner Actor
+
+Consumes: IntentEvent
+Produces: PlanGeneratedEvent
+
+Decomposes a high-level goal intent into an ordered sequence of
+actionable steps. The planner has zero knowledge of downstream
+executors or drivers — it only knows the message contract.
+"""
+
+from collections.abc import Callable
+from typing import Any
+
+from cortex.tools.kernel.context import RuntimeContext
+from cortex.tools.kernel.schema.message import IntentEvent, PlanGeneratedEvent
+
+
+class IntentPlannerActor:
+    context: RuntimeContext
+    publish_cb: Callable[[Any], object]
+
+    def __init__(self, context: RuntimeContext, publish_cb: Callable[[Any], object]):
+        self.context = context
+        self.publish_cb = publish_cb
+
+    def handle_intent(self, intent: IntentEvent) -> PlanGeneratedEvent:
+        steps = [
+            {"action": "move_actuator", "parameters": {"actuator": "arm_joint_1", "delta": 10.0}},
+            {"action": "move_actuator", "parameters": {"actuator": "arm_joint_2", "delta": -5.0}},
+        ]
+        plan = PlanGeneratedEvent(
+            intent_id=intent.intent_id,
+            correlation_id=intent.session_id,
+            steps=steps,
+        )
+        self.publish_cb(plan)
+        return plan

cortex/tools/kernel/context.py

@@ -0,0 +1,22 @@
+"""
+Runtime Context Provided to Kernel Actors
+"""
+
+from cortex.tools.kernel.mailbox import Mailbox
+from cortex.tools.kernel.transport import AnyEvent, InMemoryTransport
+
+
+class RuntimeContext:
+    actor_id: str
+    session_id: str
+    mailbox: Mailbox
+    _transport: InMemoryTransport
+
+    def __init__(self, actor_id: str, session_id: str, transport: InMemoryTransport):
+        self.actor_id = actor_id
+        self.session_id = session_id
+        self.mailbox = Mailbox()
+        self._transport = transport
+
+    def publish(self, event: AnyEvent) -> None:
+        self._transport.publish(event)

cortex/tools/kernel/drivers/__init__.py

@@ -0,0 +1,3 @@
+"""
+Kernel Drivers & Adapters
+"""

cortex/tools/kernel/drivers/mock_robot.py

@@ -0,0 +1,84 @@
+"""
+Mock Robot Driver
+
+Consumes: CommandIssuedEvent
+Produces: DriverTelemetryEvent
+
+Translates abstract commands into simulated actuator state changes
+and emits raw telemetry facts. The driver has zero knowledge of
+upstream planners or downstream verification services.
+
+Also provides a legacy step_actuator() method for Stage 2
+verification domain tests that operate through the event.py
+MotorFeedbackEvent hierarchy.
+"""
+
+from collections.abc import Callable
+from typing import cast
+
+from cortex.tools.kernel.context import RuntimeContext
+from cortex.tools.kernel.schema.event import MotorFeedbackEvent
+from cortex.tools.kernel.schema.message import CommandIssuedEvent, DriverTelemetryEvent
+from cortex.tools.kernel.transport import AnyEvent
+
+
+class MockRobotDriver:
+    context: RuntimeContext
+    actuator_id: str
+    publish_cb: Callable[[AnyEvent], object]
+    positions: dict[str, float]
+    position: float
+    velocity: float
+
+    def __init__(
+        self,
+        context: RuntimeContext,
+        actuator_id_or_cb: str | Callable[[AnyEvent], object] = "arm_joint_1",
+        publish_cb: Callable[[AnyEvent], object] | None = None,
+    ):
+        self.context = context
+        if callable(actuator_id_or_cb):
+            self.actuator_id = "arm_joint_1"
+            self.publish_cb = actuator_id_or_cb
+        else:
+            self.actuator_id = str(actuator_id_or_cb)
+            self.publish_cb = publish_cb or context.publish
+
+        self.positions = {"arm_joint_1": 0.0, "arm_joint_2": 0.0}
+        self.position = 0.0
+        self.velocity = 0.0
+
+    # -- Verification Domain (event.py hierarchy) --------------------------
+
+    def step_actuator(self, delta_pos: float, velocity: float) -> None:
+        """Stage 2 verification interface emitting MotorFeedbackEvent."""
+        self.position += delta_pos
+        self.velocity = velocity
+        event = MotorFeedbackEvent(
+            session_id=self.context.session_id,
+            actuator_id=self.actuator_id,
+            position=self.position,
+            velocity=self.velocity,
+        )
+        _ = self.publish_cb(event)
+
+    # -- Kernel Runtime Domain (message.py hierarchy) ----------------------
+
+    def handle_command(self, cmd: CommandIssuedEvent) -> DriverTelemetryEvent:
+        """Stage 4 kernel interface consuming CommandIssuedEvent."""
+        actuator = cast(str, cmd.parameters.get("actuator", "arm_joint_1"))
+        delta = float(cast(int | float, cmd.parameters.get("delta", 0.0)))
+
+        current = self.positions.get(actuator, 0.0) + delta
+        self.positions[actuator] = current
+
+        telemetry = DriverTelemetryEvent(
+            causation_id=cmd.command_id,
+            correlation_id=cmd.correlation_id,
+            root_id=cmd.plan_id,
+            driver_id=actuator,
+            status="ok",
+            payload={"actuator": actuator, "position": current, "delta": delta},
+        )
+        _ = self.publish_cb(telemetry)
+        return telemetry

cortex/tools/kernel/drivers/rtl_verilator.py

@@ -0,0 +1,49 @@
+"""
+RTL Verilator Driver for Hardware Telemetry & Trace Ingestion
+"""
+
+import json
+import os
+from typing import cast
+
+from cortex.tools.kernel.context import RuntimeContext
+from cortex.tools.kernel.schema.event import RawRTLTraceEvent
+
+
+class RTLVerilatorDriver:
+    context: RuntimeContext
+
+    def __init__(self, context: RuntimeContext):
+        self.context = context
+
+    def ingest_trace_file(self, trace_json_path: str = "rtl_trace.json") -> int:
+        if not os.path.exists(trace_json_path):
+            fallback = "Research/artifacts/phase2/rtl_trace.json"
+            if os.path.exists(fallback):
+                trace_json_path = fallback
+
+        with open(trace_json_path, "r") as f:
+            data = cast(dict[str, object], json.load(f))
+
+        frames = cast(list[dict[str, object]], data.get("trace", []))
+        for frame in frames:
+            seq_num = int(cast(int | float, frame.get("step", 0)))
+            pc_val = int(cast(int | float, frame.get("pc", 0)))
+            raw_inst = str(frame.get("raw_instruction", "0x00000000"))
+            eff_trap = bool(frame.get("eff_trap", False))
+            trap_cause = int(cast(int | float, frame.get("trap_cause", 0)))
+            stcr_list = cast(list[object], frame.get("stcr_registers", []))
+            stcr_regs = {idx: str(val) for idx, val in enumerate(stcr_list)}
+
+            event = RawRTLTraceEvent(
+                session_id=self.context.session_id,
+                sequence_number=seq_num,
+                pc=pc_val,
+                raw_instruction=raw_inst,
+                eff_trap=eff_trap,
+                trap_cause=trap_cause,
+                stcr_registers=stcr_regs
+            )
+            self.context.publish(event)
+
+        return len(frames)

cortex/tools/kernel/graph/__init__.py

@@ -0,0 +1,3 @@
+"""
+Kernel Causal Execution Graph Engine
+"""