feat(core): Skills consolidation and v0.2.0 TUI integration

- NEW: org-skill-utils-lisp (consolidated from org-skill-lisp-utils)
  * 3-phase validation: structural, syntactic, semantic
  * Sandboxed eval, AST extraction/injection/wrapping
  * Format, list-definitions utilities

- NEW: org-skill-utils-org (consolidated from org-skill-emacs-edit)
  * Read/update/delete org headlines
  * Property management, TODO state handling
  * ID-link and internal link support

- DELETE: org-skill-lisp-utils (merged into utils-lisp)
- DELETE: org-skill-emacs-edit (merged into utils-org)
- RENAME: run-all-tests.lisp -> run-tests.lisp

- HARDEN: Skill loader with improved lisp keyword handling
- FIX: Package jailing issues with def-cognitive-tool macro conflicts
- ADD: Setup wizard (opencortex setup) and doctor (opencortex doctor)
- ADD: TUI client with Croatoan for native terminal rendering

- REMOVE: Dynamic loading from opencortex.asd (use :force t instead)
- CLEANUP: Test file consolidation (removed duplicate test suites)

Co-authored-by: Agent <agent@memex>

skills/org-skill-engineering-standards.lisp

@@ -1,38 +1,23 @@
 (in-package :opencortex)
 
-(defvar *engineering-std-project-root* nil
-  "Path to the project root for enforcement checks.")
+(defun verify-git-clean-p (dir)
+  "Checks if a directory has uncommitted changes."
+  (let ((status (uiop:run-program (list "git" "-C" (namestring dir) "status" "--porcelain")
+                                 :output :string
+                                 :ignore-error-status t)))
+    (string= "" (string-trim '(#\Space #\Newline #\Tab) status))))
 
-(defstruct engineering-violation
-  (phase nil)
-  (rule nil)
-  (message nil)
-  (severity nil))
+(defun engineering-standards-verify-lisp (code)
+  "Enforces Lisp structural and semantic standards using utils-lisp."
+  (let ((result (utils-lisp-validate code :strict t)))
+    (if (eq (getf result :status) :success)
+        t
+        (error (getf result :reason)))))
 
-(defun check-structural-balance (file-path)
-  "Tier 1 Chaos: Verifies that a Lisp file is syntactically balanced."
-  (handler-case
-      (with-open-file (s file-path)
-        (loop for form = (read s nil :eof)
-              until (eq form :eof))
-        t)
-    (error (c)
-      (harness-log "CHAOS ERROR [Tier 1]: ~a in ~a" c file-path)
-      nil)))
+(defun engineering-standards-format-lisp (code)
+  "Ensures Lisp code adheres to formatting standards."
+  (utils-lisp-format code))
 
-(defun verify-git-clean-p (&optional (dir *engineering-std-project-root*))
-  "Returns T if the git repository at DIR has no uncommitted changes."
-  (when dir
-    (let ((status (uiop:run-program (list "git" "-C" (namestring dir) "status" "--porcelain")
-                                    :output :string
-                                    :ignore-error-status t)))
-      (string= "" (string-trim '(#\Space #\Newline #\Tab) status)))))
-
-(defun engineering-std-init ()
-  "Initialize the enforcement system."
-  (let ((env-root (or (uiop:getenv "OC_DATA_DIR")
-                       "/home/user/.local/share/opencortex")))
-    (setf *engineering-std-project-root* (uiop:ensure-directory-pathname env-root))
-    (harness-log "ENGINEERING STANDARDS: CDD Protocol Active.")))
-
-(engineering-std-init)
+(defskill :skill-engineering-standards
+  :priority 100
+  :trigger (lambda (ctx) (declare (ignore ctx)) nil))