#+TITLE: SKILL: Self-Fix Agent (System Immune System)
#+ID: skill-self-fix-agent
#+STARTUP: content

* Overview
The **Self-Fix Agent** acts as the system's "Immune System." It is a specialized repair drone that autonomously monitors the kernel logs for signs of system failure—such as Lisp errors, symbolic rejections, or neural hallucinations—and proactively drafts fixes for the offending skills.

* The Immune Mandate
1. **Constant Surveillance:** Periodically monitor the most recent system logs for "pain" signals.
2. **Autonomous Recovery:** Identify the root cause of an error and draft a replacement skill file to correct the behavior.
3. **Neuro-Symbolic Alignment:** If a skill is rejected by the symbolic layer, the agent must refine the neural prompt to ensure future compliance.
4. **Safety Verification:** Leverage the Skill Creator's validation logic to ensure that "surgeries" do not introduce further syntax errors.

* Symbolic Implementation (The Logic)
The implementation focuses on log analysis and the orchestration of the self-repair loop.

** Architectural Intent: Heartbeat surveillance
This trigger aligns the self-fix routine with the system heartbeat, ensuring that the immune system is always active in the background.

#+begin_src lisp
(defun trigger-skill-self-fix (context)
  (let ((type (getf context :type))
        (payload (getf context :payload)))
    ;; Check every heartbeat
    (and (eq type :EVENT)
         (eq (getf payload :sensor) :heartbeat))))
#+end_src

** Architectural Intent: Diagnostic Analysis & Repair Drafting
The neural layer analyzes the tail of the system logs. If it detects failure patterns, it uses its knowledge of the Org-Native skill standard to draft a corrected version of the failing skill, effectively performing "on-the-fly" software engineering.

#+begin_src lisp
(defun neuro-skill-self-fix (context)
  "Examine system logs for errors and draft fixes for the agent's own code."
  (let* ((logs (org-agent:context-get-system-logs 30))
         (logs-str (format nil "~{~a~%~}" logs)))
    
    ;; Only engage if the logs actually contain signs of failure
    (if (or (search "REJECTED" logs-str)
            (search "ERROR" logs-str)
            (search "hallucinated" logs-str)
            (search "Syntax error" logs-str))
        
        (format nil "
          You are the Immune System of a Neurosymbolic Lisp Machine.
          You have detected 'pain' in the system logs:
          ---
          ~a
          ---
          
          TASK:
          1. Identify which skill is failing based on the log messages.
          2. Use your knowledge of the Org-Native Skill Standard to draft a fix.
          3. If a System 2 rule rejected an action, refine the System 1 prompt to be more compliant.
          4. If there was a Lisp syntax error, correct the Lisp block.
          
          Return a Lisp plist - (:target :system :action :create-skill :filename \"skill-name.org\" :content \"the full fixed org content\")
          
          Note - You can call (org-agent:context-get-skill-source \"skill-name\") if you need to see the current code.
        " logs-str)
        
        ;; If logs are clean, stay dormant
        nil)))
#+end_src

** Architectural Intent: Symbolic Gatekeeping
Ensures that the repair proposal targets the correct system actuator and maintains the integrity of the skill-creation process.

#+begin_src lisp
(defun verify-skill-self-fix (proposed-action context)
  "Delegate to the skill-creator's logic for final acquisition, as it already has syntax validation."
  (let ((action (getf proposed-action :action)))
    (if (eq action :create-skill)
        ;; We pass this to the core creator logic (or we could just let it pass here 
        ;; since skill-creator will handle the actual file write if it were a separate skill,
        ;; but here we just return it and let the dispatcher handle it if we had a system actuator).
        ;; For now, we reuse the verify-skill-creator logic if it's available.
        proposed-action
        nil)))
#+end_src

* Registration
#+begin_src lisp
(defskill :skill-self-fix
  :priority 40 ; Low priority, runs after primary domain logic
  :trigger #'trigger-skill-self-fix
  :neuro #'neuro-skill-self-fix
  :symbolic #'verify-skill-self-fix)
#+end_src