memex/notes/org-skill-chaos.org

SKILL: Chaos Gauntlet (Universal Literate Note)

• Overview
• Phase A: Demand (PRD)
  • 1. Purpose
  • 2. User Needs
• Phase D: Build (Implementation)
  • Chaos Injection Logic
• Registration
• Phase B: Blueprint (PROTOCOL)
• Phase B: Blueprint (PROTOCOL)

Overview

The Chaos Gauntlet is an adversarial testing skill designed to ensure the system's resilience. It simulates environmental failures, malformed LLM responses, and network disruptions, forcing the kernel and its skills to handle "Byzantine" conditions gracefully.

Phase A: Demand (PRD)

1. Purpose

Verify the system's stability and error-handling capabilities under stress.

2. User Needs

• Failure Simulation: Ability to inject artificial delays or errors into the OACP bus.
• Byzantine Response Testing: Test how System 2 handles nonsensical or malicious System 1 proposals.
• Network Resilience: Simulate Gitea or LLM provider timeouts.
• Recovery Verification: Ensure the kernel can recover from a "skip-event" restart.

Phase D: Build (Implementation)

Chaos Injection Logic

(defun chaos-inject-error (sensor-type)
  "Injects a synthetic error into a specific sensor pipeline."
  (org-agent:kernel-log "CHAOS - Injecting synthetic error into ~a sensor..." sensor-type)
  (org-agent:inject-stimulus 
   `(:type :EVENT :payload (:sensor ,sensor-type :error "SYNTHETIC_CHAOS_ERROR"))))

(defun chaos-stress-test (action context)
  "Executes a randomized stress test by injecting failures into the system."
  (declare (ignore context))
  (let* ((payload (getf action :payload))
         (mode (or (getf payload :mode) :random))
         (intensity (or (getf payload :intensity) 3)))
    (org-agent:kernel-log "CHAOS - Commencing stress test (Mode: ~a, Intensity: ~a)" mode intensity)
    (case mode
      (:random (dotimes (i intensity)
                 (let ((failure-type (nth (random 3) '(:test-failure :shell-timeout :llm-error))))
                   (org-agent:inject-stimulus 
                    `(:type :EVENT :payload (:sensor :chaos-injection :type ,failure-type))))))
      (:shell (org-agent:inject-stimulus 
               `(:type :EVENT :payload (:sensor :shell-response :cmd "git push" :exit-code 128 :stderr "fatal: network unreachable")))))
    (format nil "SUCCESS - Chaos stress test initiated.")))

Registration

(defskill :skill-chaos
  :priority 10 ; Lower priority, used for background testing
  :trigger (lambda (context) (eq (getf (getf context :payload) :sensor) :chaos-trigger))
  :neuro (lambda (context) 
           (let ((p (getf context :payload)))
             (format nil "A chaos trigger was received (~a). Should I run a stress test?" (getf p :mode))))
  :symbolic #'chaos-stress-test)

Phase B: Blueprint (PROTOCOL)

Phase B: Blueprint (PROTOCOL)

* 1. Architectural Intent The *Chaos Gauntlet skill is designed to be non-invasive, running primarily in a background mode. It should not interfere with normal system operation unless explicitly triggered. The skill aims to provide a controlled environment for inducing and observing failures. Key intents:

• Controlled Chaos: Failures must be injected in a precise and controllable manner (specific sensor, specific error type).
• Observability: The system's response to failures must be easily observable through logging and system state.
• Minimal Impact: The skill should avoid causing permanent damage or corruption to the system or its data.
• Testability: Easy to run, configure, and verify success/failure. Reports failures through the regular error reporting mechanisms. Logs activity with 'CHAOS' tag.

• Recoverability: Emphasis on testing kernel's recovery from errors, by deliberately triggering skip-event type restarts. ** 2. Semantic Interfaces * A. Triggering Chaos `chaos-trigger` Sensor: Events of type `:EVENT` with a `:payload` containing `(:sensor :chaos-trigger)` trigger the skill. The payload can contain a `:mode` key to specify the type of chaos to inject (e.g., `:random`, `:shell`), and an `:intensity` to control the number of failures injected. Signature: `#+begin_src lisp ;; Triggers the chaos skill. (defun trigger-chaos (mode intensity) "Triggers the chaos gauntlet with a specified mode and intensity." (org-agent:inject-stimulus `(:type :EVENT :payload (:sensor :chaos-trigger :mode ,mode :intensity ,intensity)))) #+end_src * B. Injecting Synthetic Errors `chaos-inject-error` Function: Injects a synthetic error event into a specified sensor pipeline. Different sensor types will react differently to synthetic errors. Signature: `#+begin_src lisp ;; Injects a synthetic error into a specific sensor pipeline. (defun chaos-inject-error (sensor-type error-message) "Injects a specific synthetic error into a specific sensor." (org-agent:inject-stimulus `(:type :EVENT :payload (:sensor ,sensor-type :error ,error-message)))) #+end_src * C. Simulating Network Disruptions The `chaos-stress-test` function, when `mode` is `:shell`, simulates network disruptions by returning a specific error code from a shell command (e.g., `git push`). Signature: (covered by existing implementation in Phase D). * D. Kernel Restart Simulation Deliberately trigger `skip-event` to test recovery protocols. Signature: `#+begin_src lisp ;; simulates a skip event (a full org-agent reboot) (defun chaos-force-skip-event ()) #+end_src