REFAC: Consolidate System Control into Event Orchestrator

src/event-orchestrator.lisp

@@ -0,0 +1,72 @@
+(in-package :org-agent)
+
+(defvar *hook-registry* (make-hash-table :test 'equal)
+  "Maps hook-names (symbols) to lists of functions.")
+
+(defvar *cron-registry* (make-hash-table :test 'equal)
+  "Maps task-ids to plists containing schedule and function.")
+
+(defun orchestrator-register-hook (hook-name fn)
+  "Registers a function for a named hook. Triggers a Merkle snapshot."
+  (pushnew fn (gethash hook-name *hook-registry*))
+  (kernel-log "ORCHESTRATOR - Registered hook function for ~a" hook-name)
+  (snapshot-object-store)
+  t)
+
+(defun orchestrator-trigger-hook (hook-name &rest args)
+  "Executes all registered functions for the given hook name."
+  (let ((functions (gethash hook-name *hook-registry*)))
+    (dolist (fn functions)
+      (handler-case (apply fn args)
+        (error (c) (kernel-log "ORCHESTRATOR ERROR - Hook ~a failed: ~a" hook-name c))))))
+
+(defun orchestrator-schedule-task (task-id schedule fn)
+  "Schedules a task for execution. Schedule can be an interval (integer seconds) or 'heartbeat'."
+  (setf (gethash task-id *cron-registry*) (list :schedule schedule :fn fn :last-run 0))
+  (kernel-log "ORCHESTRATOR - Scheduled task ~a (~a)" task-id schedule)
+  (snapshot-object-store)
+  t)
+
+(defun orchestrator-process-cron ()
+  "Checked by the kernel on every heartbeat."
+  (let ((now (get-universal-time)))
+    (maphash (lambda (id task)
+               (let ((schedule (getf task :schedule))
+                     (last-run (getf task :last-run))
+                     (fn (getf task :fn)))
+                 (when (or (eq schedule :heartbeat)
+                           (and (integerp schedule) (>= (- now last-run) schedule)))
+                   (handler-case (funcall fn)
+                     (error (c) (kernel-log "ORCHESTRATOR ERROR - Cron task ~a failed: ~a" id c)))
+                   (setf (getf (gethash id *cron-registry*) :last-run) now))))
+             *cron-registry*)))
+
+(defun orchestrator-classify-complexity (context)
+  "Returns the complexity tier (:REFLEX, :COGNITION, :REASONING) for a stimulus."
+  (let* ((payload (getf context :payload))
+         (sensor (getf payload :sensor))
+         (skill (find-triggered-skill context))
+         (skill-name (when skill (skill-name skill))))
+    (cond
+      ;; reasoning: generative or architectural
+      ((member skill-name '("skill-architect" "skill-tech-analyst" "skill-scientist" "skill-self-fix") :test #'string-equal) :REASONING)
+      ((member sensor '(:user-command)) :REASONING)
+      
+      ;; cognition: human interaction or semantic data
+      ((member sensor '(:chat-message :delegation)) :COGNITION)
+      ((member skill-name '("skill-scribe" "skill-web-research") :test #'string-equal) :COGNITION)
+      
+      ;; reflex: system infrastructure and background automation
+      (t :REFLEX))))
+
+(progn
+  ;; Hook into kernel routing
+  (setf org-agent::*model-selector-fn* #'orchestrator-classify-complexity)
+  
+  (defskill :skill-event-orchestrator
+    :priority 400 ; Foundational control layer
+    :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :heartbeat))
+    :neuro nil
+    :symbolic (lambda (action ctx)
+                (orchestrator-process-cron)
+                action)))