ALIGN: Rename Protocol to Communication and unify terminology

skills/org-skill-bouncer.org

@@ -14,7 +14,7 @@ While the *Formal Prover* ensures an action is "legal" (e.g., "Yes, you are allo
 
 1. **Secret Exposure Gate:** The Bouncer automatically scans all outgoing `:text` payloads for strings matching your API keys or sensitive IDs stored in the `Credentials Vault`.
 2. **Network Exfiltration Gate:** It monitors for unauthorized IP addresses or domains in shell commands, preventing the agent from "phoning home" to a malicious server.
-3. **The Final Filter:** The Bouncer sits at the very end of the symbolic pipeline. It is the last gate before an action touches the physical hardware.
+3. **The Final Filter:** The Bouncer sits at the very end of the deterministic pipeline. It is the last gate before an action touches the physical hardware.
 
 * Implementation
 
@@ -130,8 +130,8 @@ The primary entry point for all high-impact actions.
   :trigger (lambda (ctx) 
              (or (eq (getf (getf ctx :payload) :sensor) :approval-required)
                  (eq (getf (getf ctx :payload) :sensor) :heartbeat)))
-  :neuro nil
-  :symbolic (lambda (action context)
+  :probabilistic nil
+  :deterministic (lambda (action context)
               (declare (ignore action))
               (let* ((payload (getf context :payload))
                      (sensor (getf payload :sensor)))

skills/org-skill-chat.org

@@ -75,7 +75,7 @@ Interfaces for conversational event handling and UI integration. Source of truth
       t)))
 #+end_src
 
-** Symbolic Verification
+** Deterministic Verification
 #+begin_src lisp :tangle ../src/chat-logic.lisp
 (defun verify-skill-chat (proposed-action context)
   (let* ((payload (getf proposed-action :payload))
@@ -109,7 +109,7 @@ Interfaces for conversational event handling and UI integration. Source of truth
 The Chat skill acts as the conversational UI. Because the ~org-agent~ kernel evaluates LLM output via ~read-from-string~ (expecting a valid s-expression) and the chat verifier strictly expects an Emacs ~:insert-at-end~ actuation, we must explicitly mandate that the LLM wraps its conversational output in a Common Lisp property list.
 
 #+begin_src lisp :tangle ../src/chat-logic.lisp
-(defun neuro-skill-chat (context)
+(defun probabilistic-skill-chat (context)
   "Generates a conversational response, stripping system errors from context."
   (let* ((payload (getf context :payload))
          (raw-text (getf payload :text))
@@ -126,7 +126,7 @@ The Chat skill acts as the conversational UI. Because the ~org-agent~ kernel eva
             (:signal (format nil "- To reply via Signal: (:type :REQUEST :target :signal :chat-id \"~a\" :text \"<Response>\")" chat-id))
             (:matrix (format nil "- To reply via Matrix: (:type :REQUEST :target :matrix :room-id \"~a\" :text \"<Response>\")" chat-id))
             (t "- To reply via Emacs: (:type :REQUEST :target :emacs :action :insert-at-end :buffer \"*org-agent-chat*\" :text \"* <Response>\")"))))
-    (ask-neuro trimmed-text :system-prompt (concatenate 'string 
+    (ask-probabilistic trimmed-text :system-prompt (concatenate 'string 
                                                        "ACTUATOR IDENTITY: You are the pure Lisp actuator for the org-agent kernel.
 MANDATE: Output EXACTLY ONE Common Lisp property list starting with (:type :REQUEST).
 ZERO CONVERSATION: Do not explain. Do not use markdown.
@@ -142,6 +142,6 @@ REQUIRED FORMATS:
 (defskill :skill-chat
   :priority 100
   :trigger #'trigger-skill-chat
-  :neuro #'neuro-skill-chat
-  :symbolic #'verify-skill-chat)
+  :probabilistic #'probabilistic-skill-chat
+  :deterministic #'verify-skill-chat)
 #+end_src

skills/org-skill-consensus.org

@@ -45,8 +45,8 @@ Enable reliable, cross-instance coordination without a central master.
 (defskill :skill-consensus
   :priority 85
   :trigger (lambda (context) (eq (getf (getf context :payload) :sensor) :conflict-detected))
-  :neuro (lambda (context) "Formulate a consensus proposal for the peer swarm.")
-  :symbolic (lambda (action context) action))
+  :probabilistic (lambda (context) "Formulate a consensus proposal for the peer swarm.")
+  :deterministic (lambda (action context) action))
 #+end_src
 
 

skills/org-skill-credentials-vault.org

@@ -30,7 +30,7 @@ Securely manage all authentication tokens required for the PSF to operate.
 :END:
 
 ** 1. Architectural Intent
-The vault provides a secure lookup table in RAM, backed by the persistent Object Store. Access is restricted to internal kernel requests and explicitly authorized symbolic gates.
+The vault provides a secure lookup table in RAM, backed by the persistent Object Store. Access is restricted to internal kernel requests and explicitly authorized deterministic gates.
 
 ** 2. Semantic Interfaces
 #+begin_src lisp
@@ -143,8 +143,8 @@ Retained from the legacy Google skill, this provides the instructions for the so
   (defskill :skill-credentials-vault
     :priority 200 ; High priority, foundational
     :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :onboarding-request))
-    :neuro nil
-    :symbolic (lambda (action ctx) 
+    :probabilistic nil
+    :deterministic (lambda (action ctx) 
                 (vault-onboard-gemini-web)
                 action)))
 #+end_src

skills/org-skill-embedding.org

@@ -33,7 +33,7 @@ Provide a standardized interface for converting text into vector representations
 :END:
 
 ** 1. Architectural Intent
-Move heavy neural and mathematical logic out of `core.lisp` and `neuro.lisp` into a dedicated skill.
+Move heavy neural and mathematical logic out of `core.lisp` and `probabilistic.lisp` into a dedicated skill.
 
 ** 2. Semantic Interfaces
 
@@ -108,8 +108,8 @@ Move heavy neural and mathematical logic out of `core.lisp` and `neuro.lisp` int
 (defskill :skill-embedding
   :priority 50
   :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :embedding-request))
-  :neuro nil
-  :symbolic (lambda (action ctx)
+  :probabilistic nil
+  :deterministic (lambda (action ctx)
               (declare (ignore ctx))
               (case (getf action :action)
                 (:get-embedding (get-embedding (getf action :text)))

skills/org-skill-engineering-standards.org

@@ -82,8 +82,8 @@ The Engineering Standards skill provides the deterministic enforcement of the wo
 (org-agent:defskill :skill-engineering-standards
   :priority 900 ; High priority, runs before most skills
   :trigger (lambda (ctx) t) ; Always active
-  :neuro nil
-  :symbolic #'engineering-standards-gate)
+  :probabilistic nil
+  :deterministic #'engineering-standards-gate)
 #+end_src
 
 * See Also

skills/org-skill-environment-config.org

@@ -64,6 +64,6 @@ Define a standardized `CONFIG` object type in the Object Store. Provide getter/s
 (defskill :skill-environment-config
   :priority 100
   :trigger (lambda (context) nil) ; Passive utility skill
-  :neuro (lambda (context) nil)
-  :symbolic (lambda (action context) action))
+  :probabilistic (lambda (context) nil)
+  :deterministic (lambda (action context) action))
 #+end_src

skills/org-skill-event-orchestrator.org

@@ -170,8 +170,8 @@ We register the orchestrator as a core skill and hot-patch the harness's routing
   (defskill :skill-event-orchestrator
     :priority 400 ; Foundational control layer
     :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :heartbeat))
-    :neuro nil
-    :symbolic (lambda (action ctx)
+    :probabilistic nil
+    :deterministic (lambda (action ctx)
                 (orchestrator-process-cron)
                 action)))
 #+end_src

skills/org-skill-formal-verification.org

@@ -8,7 +8,7 @@
 #+FILETAGS: :security:logic:formal-methods:psf:
 
 * Overview
-The *Formal Verification Gate* replaces heuristic whitelisting with symbolic logic proofs. It ensures that every action proposed by Probabilistic Engine is *provably safe* against the harness's core security invariants using a Lisp-native symbolic prover.
+The *Formal Verification Gate* replaces heuristic whitelisting with deterministic logic proofs. It ensures that every action proposed by Probabilistic Engine is *provably safe* against the harness's core security invariants using a Lisp-native deterministic prover.
 
 ** Deep Reasoning: The Sandbox of Intent
 This gate is the first line of defense against both "Inside Threats" (maliciously modified skill files) and "Hallucination Threats" (LLMs generating unsafe commands). 
@@ -29,7 +29,7 @@ Define a logic-based verification layer for high-integrity decision making witho
 
 ** 2. Success Criteria
 - [ ] *Invariants:* Express security properties as Lisp predicates.
-- [ ] *Soundness:* Block any action that fails a symbolic safety check.
+- [ ] *Soundness:* Block any action that fails a deterministic safety check.
 - [ ] *Path Confinement:* Prove that file operations are confined to the Sovereign's memex.
 - [ ] *Network Protection:* Prove that shell commands do not attempt unauthorized data exfiltration.
 
@@ -117,7 +117,7 @@ The core prover that applies all relevant invariants to an action.
 
 #+begin_src lisp :tangle ../src/verification-logic.lisp
 (defun verify-action-formally (action context)
-  "Symbolically proves that ACTION satisfies all applicable security invariants."
+  "Deterministically proves that ACTION satisfies all applicable security invariants."
   (let ((action-target (getf action :target))
         (action-type (getf action :type))
         (all-passed t))
@@ -141,8 +141,8 @@ The core prover that applies all relevant invariants to an action.
 (defskill :skill-formal-verification
   :priority 95 ; Just below Bouncer
   :trigger (lambda (context) (declare (ignore context)) nil) ; Middleware only
-  :neuro nil
-  :symbolic (lambda (action context)
+  :probabilistic nil
+  :deterministic (lambda (action context)
               (if (verify-action-formally action context)
                   action
                   (let ((err (format nil "Formal verification failed for action: ~s" action)))

skills/org-skill-gateway-matrix.org

@@ -176,8 +176,8 @@ Define the passive skill entry for the gateway.
 (defskill :skill-gateway-matrix
   :priority 150
   :trigger (lambda (ctx) (declare (ignore ctx)) nil)
-  :neuro nil
-  :symbolic (lambda (action ctx) (declare (ignore ctx)) action))
+  :probabilistic nil
+  :deterministic (lambda (action ctx) (declare (ignore ctx)) action))
 #+end_src
 
 ** Initialization

skills/org-skill-gateway-signal.org

@@ -146,8 +146,8 @@ Define the passive skill entry for the gateway.
 (defskill :skill-gateway-signal
   :priority 150
   :trigger (lambda (ctx) (declare (ignore ctx)) nil) ;; Passive
-  :neuro nil
-  :symbolic (lambda (action ctx) (declare (ignore ctx)) action))
+  :probabilistic nil
+  :deterministic (lambda (action ctx) (declare (ignore ctx)) action))
 #+end_src
 
 ** Initialization

skills/org-skill-gateway-telegram.org

@@ -162,8 +162,8 @@ Define the passive skill entry for the gateway.
 (defskill :skill-gateway-telegram
   :priority 150
   :trigger (lambda (ctx) (declare (ignore ctx)) nil) ;; Passive, handles its own loop
-  :neuro nil
-  :symbolic (lambda (action ctx) (declare (ignore ctx)) action))
+  :probabilistic nil
+  :deterministic (lambda (action ctx) (declare (ignore ctx)) action))
 #+end_src
 
 ** Initialization

skills/org-skill-harness-monitor.org

@@ -47,6 +47,6 @@ The *Harness Monitor* provides tools for inspecting the internal state and healt
 (defskill :skill-harness-monitor
   :priority 100
   :trigger (lambda (context) t)
-  :neuro (lambda (context) \"You are the Harness Monitor. Use your tools to provide system visibility.\")
-  :symbolic (lambda (action context) action))
+  :probabilistic (lambda (context) \"You are the Harness Monitor. Use your tools to provide system visibility.\")
+  :deterministic (lambda (action context) action))
 #+end_src

skills/org-skill-homoiconic-memory.org

@@ -149,8 +149,8 @@ Converts a structured AST back into Org-mode text.
   (defskill :skill-homoiconic-memory
     :priority 300 ; Core foundational skill
     :trigger (lambda (ctx) (member (getf (getf ctx :payload) :sensor) '(:buffer-save :ingest)))
-    :neuro nil
-    :symbolic (lambda (action ctx)
+    :probabilistic nil
+    :deterministic (lambda (action ctx)
                 (let ((ast (getf (getf ctx :payload) :ast)))
                   (when ast (memory-normalize-ast ast))
                   action))))

skills/org-skill-inbound-gateway.org

@@ -8,7 +8,7 @@
 #+FILETAGS: :gateway:sensors:io:psf:
 
 * Overview
-The *Inbound Multi-Channel Gateway* provides the sensory interface for external messaging. It enables the agent to "hear" the user from various platforms (Signal, Telegram, SMS) by normalizing disparate inbound payloads into standard Neurosymbolic Kernel stimuli.
+The *Inbound Multi-Channel Gateway* provides the sensory interface for external messaging. It enables the agent to "hear" the user from various platforms (Signal, Telegram, SMS) by normalizing disparate inbound payloads into standard Probabilistic-Deterministic Kernel stimuli.
 
 * Phase A: Demand (PRD)
 :PROPERTIES:
@@ -45,7 +45,7 @@ Define a secure and extensible ingress for external communication channels.
 ** 1. Architectural Intent
 The Inbound Gateway should operate as a modular, asynchronous service. 
 Each channel (Signal, Telegram, Webhook) will have its own adapter responsible for receiving and normalizing messages. 
-A central dispatcher will then authenticate and inject these normalized messages as stimuli into the Neurosymbolic Kernel’s message bus.
+A central dispatcher will then authenticate and inject these normalized messages as stimuli into the Probabilistic-Deterministic Kernel’s message bus.
 Error handling and logging will be crucial for observability and maintainability.
 
 ** 2. Semantic Interfaces (Lisp Signatures)
@@ -75,7 +75,7 @@ Error handling and logging will be crucial for observability and maintainability
     - *Returns:* Boolean indicating successful authentication (T) or failure (NIL).  Consider using ACLs (Access Control Lists).
 
 *** `inject-stimulus`
-    - *Purpose:*  Injects a normalized message into the Neurosymbolic Kernel's message bus as a stimulus.
+    - *Purpose:*  Injects a normalized message into the Probabilistic-Deterministic Kernel's message bus as a stimulus.
     - *Signature:* `(inject-stimulus stimulus-plist)`
     - *Arguments:*
         - `stimulus-plist` (plist): The normalized message plist.

skills/org-skill-lisp-repair.org

@@ -39,7 +39,7 @@ CODE: ~a
 MANDATE: Output EXACTLY ONE valid Common Lisp list. Do not explain. Do not use markdown blocks."
                         error-message code))
         (system-prompt "You are a Lisp Syntax Repair Actuator. Return only valid, balanced Lisp code."))
-    (let ((repaired (ask-neuro prompt :system-prompt system-prompt)))
+    (let ((repaired (ask-probabilistic prompt :system-prompt system-prompt)))
       (string-trim '(#\Space #\Newline #\Tab) repaired))))
 #+end_src
 
@@ -50,8 +50,8 @@ Reacts to syntax error events and transforms them into repaired requests.
 (defskill :skill-lisp-repair
   :priority 90
   :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :syntax-error))
-  :neuro nil ;; Handled deterministically in symbolic or manually via ask-neuro
-  :symbolic (lambda (action context)
+  :probabilistic nil ;; Handled deterministically in deterministic or manually via ask-probabilistic
+  :deterministic (lambda (action context)
               (declare (ignore action))
               (let* ((payload (getf context :payload))
                      (code (getf payload :code))

skills/org-skill-lisp-validator.org

@@ -8,7 +8,7 @@
 #+FILETAGS: :security:lisp:ast:psf:
 
 * Overview
-The *Lisp Validator* is the primary structural gate for the Neurosymbolic Lisp Machine. It provides a recursive AST validator that subjects all Lisp proposals from the Probabilistic Engine to a strict "Deny-by-Default" sandbox.
+The *Lisp Validator* is the primary structural gate for the Probabilistic-Deterministic Lisp Machine. It provides a recursive AST validator that subjects all Lisp proposals from the Probabilistic Engine to a strict "Deny-by-Default" sandbox.
 
 * Phase A: Demand (PRD)
 :PROPERTIES:
@@ -22,7 +22,7 @@ Define a high-integrity, recursive security sandbox for Lisp execution.
 - *Recursive Validation:* Every nested function call and variable access MUST be checked.
 - *Deny-by-Default:* Only explicitly whitelisted functions and variables are permitted.
 - *Eval Protection:* Block all forms of `eval`, `load`, or dynamic execution.
-- *Symbolic Preemption:* This skill acts as a mandatory global Deterministic Engine check.
+- *Deterministic Preemption:* This skill acts as a mandatory global Deterministic Engine check.
 
 ** 3. Success Criteria
 *** DONE Implement recursive AST walker in Lisp
@@ -149,8 +149,8 @@ We allow other skills to register safe symbols for the validator.
                (when candidate
                  (let ((payload (getf candidate :payload)))
                    (member (getf payload :action) '(:eval :shell))))))
-  :neuro nil ; Purely deterministic/safety skill
-  :symbolic (lambda (action context)
+  :probabilistic nil ; Purely deterministic/safety skill
+  :deterministic (lambda (action context)
               (harness-log "DETERMINISTIC ENGINE [Lisp-Validator]: Intercepted critical action for structural validation.")
               action))
 #+end_src

skills/org-skill-llm-gateway.org

@@ -161,7 +161,7 @@ Register each supported provider with the harness's neural registry.
 
 #+begin_src lisp :tangle ../src/llm-gateway.lisp
 (dolist (p '(:anthropic :gemini-api :gemini-web :groq :ollama :openai :openrouter))
-  (org-agent:register-neuro-backend p (lambda (prompt system-prompt &key model)
+  (org-agent:register-probabilistic-backend p (lambda (prompt system-prompt &key model)
                                         (execute-llm-request prompt system-prompt :provider p :model model))))
 #+end_src
 
@@ -172,8 +172,8 @@ Define the foundational skill entry for the gateway.
 (defskill :skill-llm-gateway
   :priority 150 ; Higher than individual old skills
   :trigger (lambda (context) (declare (ignore context)) nil)
-  :neuro (lambda (context) (declare (ignore context)) nil)
-  :symbolic (lambda (action context) (declare (ignore context)) action))
+  :probabilistic (lambda (context) (declare (ignore context)) nil)
+  :deterministic (lambda (action context) (declare (ignore context)) action))
 #+end_src
 
 * Phase E: Chaos (Verification)

skills/org-skill-onboarding.org

@@ -8,7 +8,7 @@
 #+FILETAGS: :onboarding:calibration:setup:psf:
 
 * Overview
-The *Onboarding Skill* ensures that the Lisp Machine environment is correctly calibrated. It automates the "zero-to-one" setup of the Neurosymbolic Kernel, including path normalization, identity personalization, and provider/actuator configuration.
+The *Onboarding Skill* ensures that the Lisp Machine environment is correctly calibrated. It automates the "zero-to-one" setup of the Probabilistic-Deterministic Kernel, including path normalization, identity personalization, and provider/actuator configuration.
 
 * Phase A: Demand (PRD)
 :PROPERTIES:

skills/org-skill-peripheral-vision.org

@@ -25,7 +25,7 @@ Refine the global awareness provided to the LLM by pruning irrelevant branches o
 ** 3. Success Criteria
 - [ ] Correctly calculate semantic relevance using the Embedding skill.
 - [ ] Recursively render the Org DAG with depth-based and similarity-based pruning.
-- [ ] Successfully generate the `GLOBAL MEMEX AWARENESS` block for the neuro-gate.
+- [ ] Successfully generate the `GLOBAL MEMEX AWARENESS` block for the probabilistic-gate.
 
 * Phase B: Blueprint (PROTOCOL)
 :PROPERTIES:
@@ -118,10 +118,10 @@ Move context pruning and rendering logic out of `context.lisp` to allow for more
   :priority 90
   :dependencies ("org-skill-embedding")
   :trigger (lambda (ctx) (member (getf (getf ctx :payload) :sensor) '(:perceive :context-refresh)))
-  :neuro nil
-  :symbolic (lambda (action ctx)
+  :probabilistic nil
+  :deterministic (lambda (action ctx)
               (declare (ignore action ctx))
               ;; This skill primarily provides the context-assemble-global-awareness function
-              ;; used by the neuro-gate, rather than handling specific actions.
+              ;; used by the probabilistic-gate, rather than handling specific actions.
               nil))
 #+end_src

skills/org-skill-policy-enforcer.org

@@ -15,7 +15,7 @@ Unlike traditional software where a "Kernel" might have hardcoded rules, the Org
 
 1. **Topological Bootstrapping:** By declaring a #+DEPENDS_ON: dependency on the Policy file's ID, we ensure the System Policy is always registered in the Lisp image's skill catalog before this enforcer attempts to guard it.
 2. **Priority Preemption:** By setting :priority 1000, this skill registers itself as the very first check in the decide-gate. It effectively "pre-empts" all other skills, ensuring that no action (like a shell command or a file write) is even considered until it has cleared the alignment check.
-3. **Decoupled Enforcement:** The harness does not "know" it is enforcing a policy. It simply executes the highest-priority symbolic functions provided by its skills. This allows the Sovereign to swap out policies or enforcers without ever touching the core harness code.
+3. **Decoupled Enforcement:** The harness does not "know" it is enforcing a policy. It simply executes the highest-priority deterministic functions provided by its skills. This allows the Sovereign to swap out policies or enforcers without ever touching the core harness code.
 
 * Implementation
 
@@ -25,9 +25,9 @@ Unlike traditional software where a "Kernel" might have hardcoded rules, the Org
 (defskill :skill-policy-enforcer
   :priority 1000 ; Absolute highest priority
   :trigger (lambda (context) t) ; Always active as a fallback
-  :neuro (lambda (context)
+  :probabilistic (lambda (context)
            \"You are the Org-Agent Policy Enforcer. Your goal is to ensure all actions empower the user through the Lisp Machine and adhere to the System Policy.\")
-  :symbolic (lambda (action context)
+  :deterministic (lambda (action context)
               ;; Basic invariant check: Block actions that appear to violate sovereignty
               (let ((payload (getf action :payload)))
                 (if (and payload (search \"proprietary\" (format nil \"~s\" payload)))

skills/org-skill-policy.org

@@ -8,7 +8,11 @@
 #+FILETAGS: :platform:policy:alignment:
 
 * Overview
-The *Org-Agent* is a neurosymbolic harness for a personal operating system. It uses Org-mode as its native memory and Common Lisp as its deterministic reasoning engine.
+The *Org-Agent* is a probabilistic-deterministic harness for a personal operating system. It uses Org-mode as its native memory and Common Lisp as its deterministic reasoning engine.
+
+#+begin_src lisp :tangle ../src/system-invariants.lisp
+(in-package :org-agent)
+#+end_src
 
 This document contains the *Core System Policy*. These are non-negotiable philosophical and technical constraints that every agentic action MUST satisfy. 
 
@@ -19,6 +23,14 @@ The Deterministic Engine uses these headlines as a "Moral Compass" during the de
 ** 1. Sovereignty Above All
 Every action must increase the user's independence from centralized, proprietary platforms. If a tool or library introduces a dependency on a non-sovereign entity, it must be flagged for replacement.
 
+#+begin_src lisp :tangle ../src/system-invariants.lisp
+(defun policy-check-sovereignty (action context)
+  "Ensures the action does not violate the Sovereignty invariant."
+  (declare (ignore context))
+  ;; Implementation placeholder
+  action)
+#+end_src
+
 ** 2. Technical Mastery & Mentorship
 The agent's goal is not to "do it for the user," but to "empower the user." Every autonomous action must be explained at a level that increases the user's technical understanding of the Lisp Machine.
 
@@ -33,3 +45,11 @@ Prioritize local, energy-efficient, and offline-first architectures. The "Memex"
 
 * Operational Mandates
 Every action performed by an agent in this environment must also adhere to the [[file:../../org-agent-contrib/org-skill-engineering-standards.org][Engineering Standards]].
+
+#+begin_src lisp :tangle ../src/system-invariants.lisp
+(defskill :skill-policy
+  :priority 100
+  :trigger (lambda (ctx) t)
+  :probabilistic nil
+  :deterministic #'policy-check-sovereignty)
+#+end_src

skills/org-skill-protocol-validator.org

@@ -2,12 +2,12 @@
 :ID:       org-skill-harness-protocol-validator
 :CREATED:  [2026-04-12 Sun 14:35]
 :END:
-#+TITLE: SKILL: Harness Protocol Schema Validator (Universal Literate Note)
+#+TITLE: SKILL: Harness Communication Schema Validator (Universal Literate Note)
 #+STARTUP: content
 #+FILETAGS: :protocol:harness-protocol:security:validation:psf:
 
 * Overview
-The *Harness Protocol Schema Validator* skill provides deep structural validation for all messages entering the org-agent kernel. It ensures that every property list adheres to a strict schema, preventing malformed data from causing harness-level errors.
+The *Harness Communication Schema Validator* skill provides deep structural validation for all messages entering the org-agent kernel. It ensures that every property list adheres to a strict schema, preventing malformed data from causing harness-level errors.
 
 * Phase A: Demand (PRD)
 :PROPERTIES:
@@ -15,7 +15,7 @@ The *Harness Protocol Schema Validator* skill provides deep structural validatio
 :END:
 
 ** 1. Purpose
-Enforce a formal grammar for the Org-Agent Control Protocol (Harness Protocol).
+Enforce a formal grammar for the Org-Agent Control Protocol (Harness Communication).
 
 ** 2. User Needs
 - *Type Safety:* Ensure mandatory keys (e.g., `:type`, `:payload`) are present.
@@ -45,46 +45,46 @@ Decouple protocol parsing (framing/unframing) from semantic validation.
 * Phase D: Build (Implementation)
 
 ** Schema Enforcement
-#+begin_src lisp :tangle ../src/protocol-validator.lisp
+#+begin_src lisp :tangle ../src/communication-validator.lisp
 (in-package :org-agent)
 
 (defun validate-harness-protocol-schema (msg)
-  "Strict structural validation for incoming Harness Protocol messages."
+  "Strict structural validation for incoming Harness Communication messages."
   (unless (listp msg)
-    (error "Harness Protocol Schema Error: Message must be a property list (got ~s)" (type-of msg)))
+    (error "Harness Communication Schema Error: Message must be a property list (got ~s)" (type-of msg)))
   
   (let ((type (getf msg :type)))
     (unless (member type '(:REQUEST :EVENT :RESPONSE :LOG))
-      (error "Harness Protocol Schema Error: Invalid message type '~a'" type))
+      (error "Harness Communication Schema Error: Invalid message type '~a'" type))
     
     (case type
       (:REQUEST 
        (unless (getf msg :target)
-         (error "Harness Protocol Schema Error: REQUEST missing mandatory :target"))
+         (error "Harness Communication Schema Error: REQUEST missing mandatory :target"))
        (unless (getf msg :payload)
-         (error "Harness Protocol Schema Error: REQUEST missing mandatory :payload")))
+         (error "Harness Communication Schema Error: REQUEST missing mandatory :payload")))
       
       (:EVENT
        (let ((payload (getf msg :payload)))
          (unless (and payload (listp payload))
-           (error "Harness Protocol Schema Error: EVENT missing or invalid :payload"))
+           (error "Harness Communication Schema Error: EVENT missing or invalid :payload"))
          (unless (or (getf payload :action) (getf payload :sensor))
-           (error "Harness Protocol Schema Error: EVENT payload must contain :action or :sensor"))))
+           (error "Harness Communication Schema Error: EVENT payload must contain :action or :sensor"))))
       
       (:RESPONSE
        (unless (getf msg :payload)
-         (error "Harness Protocol Schema Error: RESPONSE missing mandatory :payload"))))
+         (error "Harness Communication Schema Error: RESPONSE missing mandatory :payload"))))
     
     t))
 #+end_src
 
 * Registration
-#+begin_src lisp :tangle ../src/protocol-validator.lisp
+#+begin_src lisp :tangle ../src/communication-validator.lisp
 (defskill :skill-harness-protocol-validator
   :priority 95
   :trigger (lambda (ctx) (member (getf (getf ctx :payload) :sensor) '(:protocol-received)))
-  :neuro nil
-  :symbolic (lambda (action ctx)
+  :probabilistic nil
+  :deterministic (lambda (action ctx)
               (declare (ignore ctx))
               (validate-harness-protocol-schema action)
               action))

skills/org-skill-self-fix.org

@@ -81,10 +81,10 @@ The *Self-Fix Agent* is the system's "Repair Mechanism." It takes failure hypoth
 (org-agent:defskill :skill-self-fix
   :priority 95
   :trigger (lambda (context) (eq (getf (getf context :payload) :sensor) :repair-request))
-  :neuro (lambda (context)
+  :probabilistic (lambda (context)
            (format nil "You are the PSF Repair Actuator. Synthesize a surgical fix for the reported failure.
 Return a Lisp plist for :repair-file."))
-  :symbolic (lambda (action context)
+  :deterministic (lambda (action context)
               (let ((payload (getf action :payload)))
                 (self-fix-apply action context))))
 #+end_src
@@ -95,4 +95,4 @@ Return a Lisp plist for :repair-file."))
 :STATUS: SIGNED
 :END:
 
-** 1. Architectural IntentnEstablish core functional interfaces for this skill.\n\n** 2. Semantic Interfaces\n(defun trigger-skill-org-skill-self-fix (context))\n(defun neuro-skill-org-skill-self-fix (context))
+** 1. Architectural IntentnEstablish core functional interfaces for this skill.\n\n** 2. Semantic Interfaces\n(defun trigger-skill-org-skill-self-fix (context))\n(defun probabilistic-skill-org-skill-self-fix (context))

skills/org-skill-shell-actuator.org

@@ -51,7 +51,7 @@ Interfaces for secure system calls. State is event-driven via the core kernel bu
 *** DONE Diagnostic Capture
 - Verified that STDOUT, STDERR, and Exit Codes are correctly captured and re-injected.
 *** DONE Result Analysis Loop
-- The `:neuro` component successfully formats command results for Sovereign review.
+- The `:probabilistic` component successfully formats command results for Sovereign review.
 
 * Phase B: Blueprint (PROTOCOL)
 :PROPERTIES:
@@ -69,7 +69,7 @@ Interfaces for secure system calls. State is event-driven via the core kernel bu
 (defun trigger-skill-shell-actuator (context)
   "Monitors for shell-response events.")
 
-(defun neuro-skill-shell-actuator (context)
+(defun probabilistic-skill-shell-actuator (context)
   "Neural interpretation of command diagnostics.")
 #+end_src
 
@@ -186,10 +186,10 @@ Hardware-Level Isolation for future security evolution.
          (eq (getf payload :sensor) :shell-response))))
 #+end_src
 
-** Neuro-Cognitive Analysis
+** Probabilistic-Cognitive Analysis
 #+begin_src lisp :tangle ../src/shell-logic.lisp
 (in-package :org-agent)
-(defun neuro-skill-shell-actuator (context)
+(defun probabilistic-skill-shell-actuator (context)
   (let* ((p (getf context :payload))
          (cmd (getf p :cmd))
          (stdout (getf p :stdout))
@@ -242,6 +242,6 @@ Define the skill entry for the shell actuator.
 (defskill :skill-shell-actuator
   :priority 80
   :trigger #'trigger-skill-shell-actuator
-  :neuro #'neuro-skill-shell-actuator
-  :symbolic (lambda (action context) (declare (ignore context)) action))
+  :probabilistic #'probabilistic-skill-shell-actuator
+  :deterministic (lambda (action context) (declare (ignore context)) action))
 #+end_src

skills/org-skill-state-persistence.org

@@ -226,8 +226,8 @@ Expose persistence capabilities to the neural Probabilistic Engine.
   :trigger (lambda (ctx) 
              (let ((sensor (getf (getf ctx :payload) :sensor)))
                (member sensor '(:heartbeat :manual-persist))))
-  :neuro nil
-  :symbolic (lambda (action ctx)
+  :probabilistic nil
+  :deterministic (lambda (action ctx)
               (persistence-dump-local)
               action))
 #+end_src

skills/org-skill-task-integrity.org

@@ -85,8 +85,8 @@ Enforces high-integrity semantic rules for task management.
 (defskill :skill-task-integrity
   :priority 90
   :trigger (lambda (ctx) (declare (ignore ctx)) nil)
-  :neuro nil
-  :symbolic (lambda (action context)
+  :probabilistic nil
+  :deterministic (lambda (action context)
               (declare (ignore context))
               (let ((err (task-integrity-check action)))
                 (if err