feat: Add Lisp Validator skill with 3-phase deterministic gate

- Implements structural (O(n) paren balance), syntactic (reader with *read-eval* nil),
  and semantic (whitelist AST walk) validation.
- Exposes :validate-lisp cognitive tool for Probabilistic Engine self-correction.
- Replaces validate-lisp-syntax stub in harness/skills.org with delegation.
- Adds mandatory validation rule to Probabilistic Engine system prompt.
- Refactors org-skill-policy.org with 6 concrete invariants (Transparency, Autonomy,
  Zero-Bloat, Modularity, Mentorship, Sustainability) and explicit override hierarchy.
- Adds Harness Boundary Contract to harness/manifest.org.

harness/manifest.org

@@ -81,3 +81,16 @@ This system defines the native Croatoan TUI client.
   :depends-on (:opencortex :croatoan :usocket :bordeaux-threads)
   :components ((:file "library/tui-client")))
 #+end_src
+
+* The Harness Boundary Contract
+The harness is the minimal, unbreakable core of OpenCortex. It consists of the literate source files that define the kernel and the system manifest. Any proposed modification to these files must be justified, because the harness is the system's immune system and must never grow fat.
+
+** Primary Boundary Files
+- ~harness/*.org~ — The literate source of truth for all kernel modules.
+- ~opencortex.asd~ — The ASDF system manifest.
+
+** Generated Artifacts (NOT Primary Boundary)
+The files in ~library/*.lisp~ are derivative artifacts produced by tangling the harness Org files. They are NOT primary boundary files; modifying them directly violates the Engineering Standard of Literate-Only Modification. Any change to the harness must be made in the corresponding Org file and then tangled.
+
+** Enforcement
+The Policy skill's ~*modularity-protected-paths*~ variable guards the primary boundary locations by default. Any agent action that proposes to modify a file within these paths must include a ~:modularity-justification~ field explaining why the change cannot be implemented as a skill.

harness/reason.org

@@ -72,12 +72,14 @@ The Reason stage is the cognitive engine of the OpenCortex. It bridges the gap b
                              (if (and p (stringp p)) p "Maintain metabolic stasis."))))
            (system-prompt (format nil "IDENTITY: ~a. MANDATE: Respond with ONE Lisp plist. ~a ~a RECENT_LOGS: ~a
 IMPORTANT: To reply to the user, you MUST use:
-(:TYPE :REQUEST :PAYLOAD (:ACTION :MESSAGE :TEXT \"<Response Text>\"))
+(:TYPE :REQUEST :PAYLOAD (:ACTION :MESSAGE :TEXT "<Response Text>"))
 
 To call a tool, you MUST use:
-(:TYPE :REQUEST :TARGET :TOOL :ACTION :CALL :TOOL \"<name>\" :ARGS (:arg1 \"val\"))
+(:TYPE :REQUEST :TARGET :TOOL :ACTION :CALL :TOOL "<name>" :ARGS (:arg1 "val"))
 
-PROVIDER RULE: Always use the default cascade provider unless a specific model or capability is required for the task." 
+MANDATORY VALIDATION RULE: Before declaring any Lisp code edit complete, you MUST call the `:validate-lisp` tool with the proposed code. If the tool returns `:status :error`, read the `:reason` and `:failed` fields, fix the defect, and re-validate. You are strictly forbidden from relying on your own paren-balancing or syntax intuition.
+
+PROVIDER RULE: Always use the default cascade provider unless a specific model or capability is required for the task."
                                   assistant-name global-context tool-belt system-logs)))
       (let* ((thought (probabilistic-call raw-prompt :system-prompt system-prompt :context context))
              (cleaned (strip-markdown thought))

harness/skills.org

@@ -131,13 +131,14 @@ A static, hardcoded architecture is inherently fragile. The ~opencortex~ Skill E
 ** Jailed Loading (load-skill-from-org)
 #+begin_src lisp :tangle ../library/skills.lisp
 (defun validate-lisp-syntax (code-string)
-  "Checks if a string contains valid, readable Common Lisp forms."
-  (handler-case 
-      (let ((*read-eval* nil)) 
-        (with-input-from-string (stream (format nil "(progn ~a)" code-string))
-          (loop for form = (read stream nil :eof) until (eq form :eof)) 
-          (values t nil)))
-    (error (c) (values nil (format nil "~a" c)))))
+  "Checks if a string contains valid, readable Common Lisp forms.
+Delegates to the Lisp Validator skill for structural + syntactic validation."
+  (let* ((result (lisp-validator-validate code-string :strict nil))
+         (status (getf result :status))
+         (reason (getf result :reason)))
+    (if (eq status :success)
+        (values t nil)
+        (values nil (or reason "Lisp Validator rejected code.")))))
 
 (defun load-skill-from-org (filepath)
   "Parses and evaluates Lisp blocks from an Org file into a jailed package."