feat(v0.2.0): Self-Improvement & Structural Integrity

- Fix critical paren balance issues across harness/skills.org, act.org,
  loop.org, memory.org, and skills/self-edit|emacs-edit.org
- Add :reload-skill cognitive tool for hot-reloading without restart
- Add :generate-embeddings tool and self-edit hot-reload infrastructure
- Wire all new skills (self-edit, emacs-edit, lisp-utils) into main ASDF
- Regenerate all .lisp tangled files via emacs --batch org-babel-tangle
- Add :opencortex/tests ASDF system with 14 test suites
- Fix test files to compile cleanly (self-edit-tests symbol vis, etc.)

tests/boot-sequence-tests.lisp

@@ -0,0 +1,47 @@
+(defpackage :opencortex-boot-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:boot-suite))
+
+(in-package :opencortex-boot-tests)
+
+(def-suite boot-suite :description "Verification of the Skill Engine loader")
+
+(in-suite boot-suite)
+
+(test test-parse-skill-metadata
+  "Verify extraction of ID and DEPENDS_ON from Org headers."
+  (let ((tmp-file "/tmp/org-skill-test-metadata.org"))
+    (with-open-file (out tmp-file :direction :output :if-exists :supersede)
+      (format out ":PROPERTIES:~%:ID: test-id~%:END:~%#+DEPENDS_ON: dep1 dep2~%"))
+    (unwind-protect
+         (multiple-value-bind (id deps) (opencortex::parse-skill-metadata tmp-file)
+           (is (equal "test-id" id))
+           (is (member "dep1" deps :test #'string=))
+           (is (member "dep2" deps :test #'string=)))
+       (uiop:delete-file-if-exists tmp-file))))
+
+(test test-topological-sort-basic
+  "Verify that skills are ordered by dependency."
+  (let ((tmp-dir "/tmp/opencortex-boot-test/"))
+    (uiop:ensure-all-directories-exist (list tmp-dir))
+    (with-open-file (out (merge-pathnames "org-skill-a.org" tmp-dir) :direction :output :if-exists :supersede)
+      (format out "#+DEPENDS_ON: skill-b-id~%"))
+    (with-open-file (out (merge-pathnames "org-skill-b.org" tmp-dir) :direction :output :if-exists :supersede)
+      (format out ":PROPERTIES:~%:ID: skill-b-id~%:END:~%"))
+    (unwind-protect
+         (let ((sorted (opencortex::topological-sort-skills tmp-dir)))
+           (let ((pos-a (position "org-skill-a" sorted :key #'pathname-name :test #'string-equal))
+                 (pos-b (position "org-skill-b" sorted :key #'pathname-name :test #'string-equal)))
+             (is (< pos-b pos-a)))
+       (uiop:delete-directory-tree (uiop:ensure-directory-pathname tmp-dir) :validate t))))
+
+(test test-skill-jailing
+  "Verify that skills are loaded into their own packages."
+  (let ((tmp-skill "/tmp/org-skill-jail-test.org"))
+    (with-open-file (out tmp-skill :direction :output :if-exists :supersede)
+      (format out ":PROPERTIES:~%:ID: jail-test-id~%:END:~%#+TITLE: Jail Test Skill~%#+begin_src lisp :tangle no~(defun jail-test-fn () t)~#+end_src"))
+    (unwind-protect
+         (progn
+           (opencortex::load-skill-from-org tmp-skill)
+           (is (not (null (gethash "org-skill-jail-test" opencortex::*skills-registry*)))))
+       (uiop:delete-file-if-exists tmp-skill)))))

tests/emacs-edit-tests.lisp

@@ -13,7 +13,7 @@
   (let ((id1 (emacs-edit-generate-id))
         (id2 (emacs-edit-generate-id)))
     (is (plusp (length id1)))
-    (is (not (string= id1 id2)))))
+    (is (not (string= id1 id2))))) ;; Likely unique
 
 (test id-format
   (let ((formatted (emacs-edit-id-format "abc12345")))
@@ -31,4 +31,4 @@
                   :properties (list :ID "id:todo001" :TITLE "Task")
                   :contents nil)))
     (emacs-edit-set-todo ast "id:todo001" "DONE")
-    (is (string= (getf (getf ast :properties) :TODO) "DONE"))))
+    (is (string= (getf (getf ast :properties) :TODO) "DONE"))))

tests/immune-system-tests.lisp

@@ -0,0 +1,23 @@
+(defpackage :opencortex-immune-system-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:immune-suite))
+
+(in-package :opencortex-immune-system-tests)
+
+(def-suite immune-suite
+  :description "Verification of the Immune System (Core Error Hooks)")
+
+(in-suite immune-suite)
+
+(test loop-error-injection
+  "Verify that a crash in think/decide triggers a :loop-error stimulus."
+  (clrhash opencortex::*skills-registry*)
+  (opencortex:defskill :evil-skill
+    :priority 100
+    :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :user-input))
+    :probabilistic (lambda (ctx) (error "CRITICAL BRAIN FAILURE"))
+    :deterministic nil)
+  (opencortex:harness-log "CLEAN LOG")
+  (opencortex:process-signal '(:type :EVENT :payload (:sensor :user-input)))
+  (let ((logs (opencortex:context-get-system-logs 20)))
+    (is (not (null (find-if (lambda (line) (search "CRITICAL BRAIN FAILURE" line)) logs))))))

tests/lisp-utils-tests.lisp

@@ -94,8 +94,3 @@
   (let ((result (opencortex::lisp-utils-validate "(delete-file \"x.txt\")" :strict t)))
     (is (eq (getf result :status) :error))
     (is (eq (getf result :failed) :semantic))))
-
-(test unified-semantic-fail
-  (let ((result (opencortex::lisp-utils-validate "(delete-file \"x.txt\")" :strict t)))
-    (is (eq (getf result :status) :error))
-    (is (eq (getf result :failed) :semantic))))

tests/lisp-validator-tests.lisp

@@ -0,0 +1,54 @@
+(defpackage :opencortex-lisp-validator-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:lisp-validator-suite))
+
+(in-package :opencortex-lisp-validator-tests)
+
+(def-suite lisp-validator-suite
+  :description "Tests for the Lisp Validator structural, syntactic, and semantic gates")
+
+(in-suite lisp-validator-suite)
+
+(test structural-balanced
+  (let ((result (opencortex::lisp-validator-check-structural "(+ 1 2)")))
+    (is (eq result t))))
+
+(test structural-unbalanced-open
+  (multiple-value-bind (ok reason line col)
+      (opencortex::lisp-validator-check-structural "(+ 1 2")
+    (is (null ok))
+    (is (search "Unbalanced" reason))))
+
+(test structural-unbalanced-close
+  (multiple-value-bind (ok reason line col)
+      (opencortex::lisp-validator-check-structural "+ 1 2)")
+    (is (null ok))
+    (is (search "Unbalanced" reason))))
+
+(test syntactic-valid
+  (multiple-value-bind (ok reason line col)
+      (opencortex::lisp-validator-check-syntactic "(+ 1 2)")
+    (is (eq ok t))))
+
+(test syntactic-invalid-reader
+  (multiple-value-bind (ok reason line col)
+      (opencortex::lisp-validator-check-syntactic "(1+ 2 #\")")
+    (is (not ok))))
+
+(test semantic-safe
+  (multiple-value-bind (ok reason line col)
+      (opencortex::lisp-validator-check-semantic "(+ 1 2)")
+    (is (eq ok t))))
+
+(test semantic-blocked-eval
+  (multiple-value-bind (ok reason line col)
+      (opencortex::lisp-validator-check-semantic "(eval '(+ 1 2))")
+    (is (not ok))))
+
+(test unified-success
+  (let ((result (opencortex::lisp-validator-validate "(+ 1 2)" :strict t)))
+    (is (eq (getf result :status) :success))))
+
+(test unified-failure
+  (let ((result (opencortex::lisp-validator-validate "(+ 1 2" :strict nil)))
+    (is (eq (getf result :status) :error))))

tests/memory-tests.lisp

@@ -0,0 +1,115 @@
+(defpackage :opencortex-memory-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:memory-suite))
+
+(in-package :opencortex-memory-tests)
+
+(def-suite memory-suite
+  :description "Tests for the Merkle-Tree Memory.")
+
+(in-suite memory-suite)
+
+(test merkle-hash-consistency
+  (let* ((ast1 '(:type :HEADLINE :properties (:ID "test-1" :TITLE "Node 1") :contents nil))
+         (ast2 '(:type :HEADLINE :properties (:ID "test-1" :TITLE "Node 1") :contents nil)))
+    (clrhash *memory*)
+    (let ((id1 (ingest-ast ast1)))
+      (let ((hash1 (org-object-hash (lookup-object id1))))
+        (clrhash *memory*)
+        (let ((id2 (ingest-ast ast2)))
+          (let ((hash2 (org-object-hash (lookup-object id2))))
+            (is (equal hash1 hash2))))))))
+
+(test merkle-hash-cascading
+  (let* ((ast-leaf '(:type :HEADLINE :properties (:ID "leaf" :TITLE "Leaf") :contents nil))
+         (ast-root-full '(:type :HEADLINE :properties (:ID "root" :TITLE "Root") 
+                           :contents ((:type :HEADLINE :properties (:ID "leaf" :TITLE "Leaf") :contents nil))))
+         (id-root (progn (clrhash *memory*) (ingest-ast ast-root-full)))
+         (initial-root-hash (org-object-hash (lookup-object id-root))))
+      
+      ;; Now ingest a modified version (title change)
+      (let* ((ast-root-modified '(:type :HEADLINE :properties (:ID "root" :TITLE "Root") 
+                                 :contents ((:type :HEADLINE :properties (:ID "leaf" :TITLE "Leaf Modified") :contents nil))))
+             (id-root-mod (progn (clrhash *memory*) (ingest-ast ast-root-modified)))
+             (modified-root-hash (org-object-hash (lookup-object id-root-mod))))
+        (is (not (equal initial-root-hash modified-root-hash))))))
+
+(test history-store-immutability
+  "Verify that *history-store* retains old versions even after *memory* updates."
+  (clrhash *memory*)
+  (clrhash *history-store*)
+  (let* ((ast-v1 '(:type :HEADLINE :properties (:ID "test-node" :TITLE "Version 1") :contents nil))
+         (id-v1 (ingest-ast ast-v1))
+         (obj-v1 (lookup-object id-v1))
+         (hash-v1 (org-object-hash obj-v1)))
+    
+    (let* ((ast-v2 '(:type :HEADLINE :properties (:ID "test-node" :TITLE "Version 2") :contents nil))
+           (id-v2 (ingest-ast ast-v2))
+           (obj-v2 (lookup-object id-v2))
+           (hash-v2 (org-object-hash obj-v2)))
+      
+      ;; The active pointer should be v2
+      (is (equal (org-object-hash (lookup-object "test-node")) hash-v2))
+      
+      ;; Both v1 and v2 should exist in the immutable history store
+      (is (not (null (gethash hash-v1 *history-store*))))
+      (is (not (null (gethash hash-v2 *history-store*))))
+      
+      ;; Modifying v2 should not affect v1 in the history store
+      (is (equal (org-object-content (gethash hash-v1 *history-store*)) "Version 1
+"))
+      (is (equal (org-object-content (gethash hash-v2 *history-store*)) "Version 2
+")))))
+
+(test cow-snapshot-and-rollback
+  "Verify that lightweight snapshots can accurately restore previous pointer states."
+  (clrhash *memory*)
+  (clrhash *history-store*)
+  (setf *object-store-snapshots* nil)
+  
+  (let* ((ast-v1 '(:type :HEADLINE :properties (:ID "cow-node" :TITLE "State A") :contents nil))
+         (id-v1 (ingest-ast ast-v1))
+         (hash-v1 (org-object-hash (lookup-object id-v1))))
+     
+    ;; Take a snapshot at State A
+    (snapshot-memory)
+    
+    (let* ((ast-v2 '(:type :HEADLINE :properties (:ID "cow-node" :TITLE "State B") :contents nil))
+           (id-v2 (ingest-ast ast-v2))
+           (hash-v2 (org-object-hash (lookup-object id-v2))))
+      
+      ;; Verify we are currently in State B
+      (is (equal (org-object-hash (lookup-object "cow-node")) hash-v2))
+      
+      ;; Rollback to State A (index 0 because we only took 1 snapshot)
+      (rollback-memory 0)
+      
+      ;; Verify we are back in State A
+      (is (equal (org-object-hash (lookup-object "cow-node")) hash-v1))
+      
+;; Verify State B is still safely in the history store (no data loss)
+      (is (not (null (gethash hash-v2 *history-store*)))))))
+
+(test merkle-hash-consistency
+  "Verify that identical ASTs produce identical Merkle hashes."
+  (let* ((ast1 '(:type :HEADLINE :properties (:ID "test-1" :TITLE "Node 1") :contents nil)))
+    (clrhash *memory*)
+    (let ((id1 (ingest-ast ast1)))
+      (let ((hash1 (org-object-hash (lookup-object id1))))
+        (clrhash *memory*)
+        (let ((id2 (ingest-ast ast1)))
+          (let ((hash2 (org-object-hash (lookup-object id2))))
+            (is (equal hash1 hash2))))))))
+
+(test merkle-hash-cascading
+  "Verify that child changes propagate to parent hashes."
+  (let* ((ast-root '(:type :HEADLINE :properties (:ID "root" :TITLE "Root")
+                      :contents ((:type :HEADLINE :properties (:ID "leaf" :TITLE "Leaf") :contents nil))))
+         (id-root (progn (clrhash *memory*) (ingest-ast ast-root)))
+         (root-hash (org-object-hash (lookup-object id-root))))
+    ;; Now ingest a modified child - parent hash should change
+    (let* ((ast-mod '(:type :HEADLINE :properties (:ID "root" :TITLE "Root")
+                    :contents ((:type :HEADLINE :properties (:ID "leaf" :TITLE "Changed") :contents nil))))
+           (id-mod (progn (clrhash *memory*) (ingest-ast ast-mod)))
+            (mod-hash (org-object-hash (lookup-object id-mod))))
+      (is (not (equal root-hash mod-hash))))))

tests/pipeline-act-tests.lisp

@@ -0,0 +1,33 @@
+(defpackage :opencortex-pipeline-act-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:pipeline-act-suite))
+
+(in-package :opencortex-pipeline-act-tests)
+
+(def-suite pipeline-act-suite
+  :description "Test suite for Act pipeline")
+
+(in-suite pipeline-act-suite)
+
+(test test-act-gate-symbolic-guard-bypass
+  "Verify that act-gate proceeds normally when no skill intercepts."
+  (clrhash opencortex::*skills-registry*)
+  (let* ((signal (list :type :EVENT :status nil :depth 0 :approved-action '(:target :cli :payload (:text "Hello"))))
+         (result (opencortex:act-gate signal)))
+    (is (eq :acted (getf signal :status)))
+    (is (null result))))
+
+(test test-act-gate-symbolic-guard-interception
+  "Verify that act-gate intercepts actions when a skill returns a LOG/EVENT."
+  (clrhash opencortex::*skills-registry*)
+  (opencortex::defskill :mock-bouncer
+    :priority 200
+    :trigger (lambda (ctx) t)
+    :deterministic (lambda (action ctx)
+                     (list :type :LOG :payload '(:text "BLOCKED BY SYMBOLIC GUARD"))))
+  (let* ((signal (list :type :EVENT :status nil :depth 0 :approved-action '(:target :shell :payload (:cmd "ls"))))
+         (result (opencortex:act-gate signal)))
+    (is (eq :acted (getf signal :status)))
+    (is (not (null result)))
+    (is (eq :LOG (getf result :type)))
+    (is (search "BLOCKED BY SYMBOLIC GUARD" (getf (getf result :payload) :text)))))

tests/pipeline-perceive-tests.lisp

@@ -0,0 +1,23 @@
+(defpackage :opencortex-pipeline-perceive-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:pipeline-perceive-suite))
+
+(in-package :opencortex-pipeline-perceive-tests)
+
+(def-suite pipeline-perceive-suite
+  :description "Test suite for Perceive pipeline")
+
+(in-suite pipeline-perceive-suite)
+
+(test test-perceive-gate
+  "Perceive gate should update the object store and normalize signal."
+  (clrhash opencortex::*memory*)
+  (let* ((signal (list :type :EVENT :payload (list :sensor :buffer-update :ast (list :type :HEADLINE :properties (list :ID "test-node" :TITLE "Test") :contents nil))))
+         (result (perceive-gate signal)))
+    (is (eq :perceived (getf result :status)))
+    (is (not (null (gethash "test-node" opencortex::*memory*))))))
+
+(test test-depth-limiting
+  "Verify that the pipeline terminates runaway feedback loops."
+  (let ((runaway-signal (list :type :EVENT :depth 11 :payload (list :sensor :heartbeat))))
+    (is (null (process-signal runaway-signal)))))

tests/pipeline-reason-tests.lisp

@@ -0,0 +1,26 @@
+(defpackage :opencortex-pipeline-reason-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:pipeline-reason-suite))
+
+(in-package :opencortex-pipeline-reason-tests)
+
+(def-suite pipeline-reason-suite
+  :description "Test suite for Reason pipeline")
+
+(in-suite pipeline-reason-suite)
+
+(test test-decide-gate-safety
+  "Decide gate should block unsafe LLM proposals."
+  ;; Setup: clear skills and register mock
+  (clrhash opencortex::*skills-registry*)
+  (opencortex::defskill :mock-safety
+    :priority 50
+    :trigger (lambda (ctx) t)
+    :probabilistic (lambda (ctx) "Mock probabilistic")
+    :deterministic (lambda (action ctx)
+                (list :type :LOG :payload (list :text "Action rejected by skill heuristics"))))
+  (let* ((candidate (list :type :REQUEST :payload (list :action :eval :code "(shell-command \"rm -rf /\")")))
+         (signal (list :type :EVENT :candidate candidate))
+         (result (deterministic-verify candidate signal)))
+    (is (eq :LOG (getf result :type)))
+    (is (search "Action rejected by skill heuristics" (getf (getf result :payload) :text)))))

tests/self-edit-tests.lisp

@@ -10,25 +10,25 @@
 (in-suite self-edit-suite)
 
 (test balance-parens-balanced
-  (let ((result (opencortex:self-edit-balance-parens "(+ 1 2)")))
+  (let ((result (opencortex::self-edit-balance-parens "(+ 1 2)")))
     (is (string= result "(+ 1 2)"))
     (is (not (null (read-from-string result))))))
 
 (test balance-parens-missing-open
-  (let ((result (opencortex:self-edit-balance-parens "+ 1 2)")))
+  (let ((result (opencortex::self-edit-balance-parens "+ 1 2)")))
     (is (string= result "(+ 1 2)"))
     (is (not (null (read-from-string result))))))
 
 (test balance-parens-missing-close
-  (let ((result (opencortex:self-edit-balance-parens "(+ 1 2")))
+  (let ((result (opencortex::self-edit-balance-parens "(+ 1 2")))
     (is (string= result "(+ 1 2)"))
     (is (not (null (read-from-string result))))))
 
 (test balance-parens-deep
-  (let ((result (opencortex:self-edit-balance-parens "((lambda (x) (if x (+ 1 2) 3))")))
+  (let ((result (opencortex::self-edit-balance-parens "((lambda (x) (if x (+ 1 2) 3))")))
     (is (string= result "((lambda (x) (if x (+ 1 2) 3)))"))
     (is (not (null (read-from-string result))))))
 
 (test balance-parens-empty
-  (let ((result (opencortex:self-edit-balance-parens "")))
+  (let ((result (opencortex::self-edit-balance-parens "")))
     (is (string= result ""))))

tests/tool-permissions-tests.lisp

@@ -0,0 +1,34 @@
+(defpackage :opencortex-tool-permissions-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:tool-permissions-suite))
+
+(in-package :opencortex-tool-permissions-tests)
+
+(def-suite tool-permissions-suite
+  :description "Tests for Tool Permissions skill")
+
+(in-suite tool-permissions-suite)
+
+(test default-permission-is-allow
+  "Verify default permission is :allow."
+  (is (eq (get-tool-permission "unknown-tool") :allow)))
+
+(test set-and-get-permission
+  "Verify setting and getting permissions."
+  (set-tool-permission "test-tool-abc" :deny)
+  (is (eq (get-tool-permission "test-tool-abc") :deny)))
+
+(test permission-gate-allow
+  "Verify :allow tier passes through."
+  (set-tool-permission "gate-allow-tool" :allow)
+  (is (eq (check-tool-permission-gate "gate-allow-tool" nil) :allow)))
+
+(test permission-gate-deny
+  "Verify :deny tier blocks."
+  (set-tool-permission "gate-deny-tool" :deny)
+  (is (eq (check-tool-permission-gate "gate-deny-tool" nil) :deny)))
+
+(test permission-gate-ask
+  "Verify :ask tier returns ask list."
+  (set-tool-permission "gate-ask-tool" :ask)
+  (is (listp (check-tool-permission-gate "gate-ask-tool" nil))))