fix(ci): remove ql:add-to-init-file (stdin prompt hangs in non-interactive)

- Secret Exposure Gate + Privacy Filter (Bouncer)
- Shell actuator safety harness (timeout, blocked patterns)
- REPL-first enforcement (lisp validation gate, system-prompt-augment)
- Engineering Standards lifecycle (two-track Org-first + REPL-first)
- Literate Programming discipline (one function per block, reflect-back)
- AGENTS.md: thin routing layer, skills are authoritative
- SKILLS_DIR removed, ~/notes fallback eliminated
- opencortex.sh: multi-distro (Debian+Fedora), configure, install service, backup, restore, help
- infrastructure/opencortex.service (systemd user unit)
- Docker: updated to debian:trixie, fixed build context
- GitHub CI: lint + test workflows fixed, trigger on tags only
- Gitea CI: deploy workflow paths fixed
- README: one-line curl install, badges
- USER_MANUAL: Deployment section (bare metal, Docker, backup)
- .gitignore: skills/*.lisp and tests/*.lisp as generated artifacts
- Prose/block refactor across all 35 org files
- Test suite Tier 1: 43/45 pass (env-dependent failures isolated)

.env.example

@@ -1,62 +1,86 @@
-# opencortex: Neural Engine Configuration
-# Core LLM Providers
-GEMINI_API_KEY="your_gemini_key_here"
-ANTHROPIC_API_KEY="your_anthropic_key_here"
-OPENAI_API_KEY="your_openai_key_here"
-GROQ_API_KEY="your_groq_key_here"
+# opencortex: Environment Configuration Template
+# Copy this to .env and fill in your values
+
+# =============================================================================
+# IDENTITY
+# =============================================================================
+MEMEX_USER="YourName"
+MEMEX_ASSISTANT="AgentName"
+
+# =============================================================================
+# LLM PROVIDERS (OpenRouter recommended as primary)
+# =============================================================================
 OPENROUTER_API_KEY="your_openrouter_key_here"
+OPENAI_API_KEY="your_openai_key_here"
+ANTHROPIC_API_KEY="your_anthropic_key_here"
+GROQ_API_KEY="your_groq_api_key_here"
+GEMINI_API_KEY="your_gemini_key_here"
 
-# Legacy/Default (Optional)
-LLM_API_KEY="your_api_key_here"
-LLM_ENDPOINT="https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
+# Cascade order (first available provider wins)
+PROVIDER_CASCADE="openrouter,openai,anthropic,groq,gemini-api,ollama"
 
-# Communication Gateways
+# =============================================================================
+# LOCAL LLM (Ollama - runs offline)
+# =============================================================================
+OLLAMA_HOST="localhost:11434"
+
+# llama.cpp backend (for local GGUF models)
+LLAMA_HOST="localhost:8080"
+
+# =============================================================================
+# VECTOR EMBEDDINGS (semantic search)
+# =============================================================================
+EMBEDDING_PROVIDER="ollama"  # "ollama" or "llama.cpp"
+EMBEDDING_MODEL="nomic-embed-text"  # model name for embeddings
+
+# =============================================================================
+# MESSAGING GATEWAYS (optional)
+# =============================================================================
 TELEGRAM_BOT_TOKEN="your_telegram_bot_token_here"
 SIGNAL_ACCOUNT_NUMBER="+1..."
 
-# System 2: Symbolic Constraints
-SAFETY_BLOCK_SHELL=true
-GTD_ENFORCE_INTEGRITY=true
-
-# Harness Protocol Daemon Configuration
+# =============================================================================
+# DAEMON CONFIGURATION
+# =============================================================================
 ORG_AGENT_DAEMON_PORT=9105
-ORG_AGENT_WEB_PORT=8080
 DAEMON_HOST="0.0.0.0"
 HEARTBEAT_INTERVAL=60
 DAEMON_SLEEP_INTERVAL=3600
-
-# Outbound Communication Defaults
 DEFAULT_ACTUATOR="cli"
 SILENT_ACTUATORS="cli,system-message,emacs"
 
-# Core Skill Requirements
-# A comma-separated list of skill Org files (without extension) required for boot.
+# =============================================================================
+# SECURITY
+# =============================================================================
+SAFETY_BLOCK_SHELL=true
+PROTOCOL_ENFORCE_HMAC=false
+PROTOCOL_HMAC_SECRET="change-this-to-a-secure-random-string"
+
+# Privacy filter tags: comma-separated list of tags that mark content as private.
+# Files/headings tagged with any of these will be filtered from LLM context.
+# Default: @personal
+PRIVACY_FILTER_TAGS="@personal,@health,@finance"
+
+# =============================================================================
+# BOOTSTRAP
+# =============================================================================
 MANDATORY_SKILLS="org-skill-policy,org-skill-bouncer"
 
-# Context Management & Peripheral Vision
+# =============================================================================
+# CONTEXT / MEMORY
+# =============================================================================
 CONTEXT_SEMANTIC_THRESHOLD=0.75
 CONTEXT_LOG_LIMIT=20
 
-# Memex Integration
-# Inside Docker, /app/ is the root for consolidated notes
-MEMEX_DIR="/memex"
-ZETTELKASTEN_DIR="/memex/notes"
-SKILLS_DIR="/memex/notes"
-
-# PARA Structure (Consolidated)
-INBOX_DIR="/memex/inbox"
-DAILY_DIR="/memex/daily"
-PROJECTS_DIR="/memex/projects"
-AREAS_DIR="/memex/areas"
-RESOURCES_DIR="/memex/resources"
-ARCHIVES_DIR="/memex/archives"
-SYSTEM_DIR="/memex/system"
-
-# Identity Configuration
-MEMEX_USER="YourName"
-MEMEX_ASSISTANT="AgentName"
-RECIPIENT_ID="+1..." # For Signal/Telegram delivery
-
-# Harness Protocol Integrity & Authentication (HMAC-SHA256)
-Harness Protocol_ENFORCE_HMAC=false
-Harness Protocol_HMAC_SECRET="change-this-to-a-secure-random-string"
+# =============================================================================
+# MEMEX STRUCTURE
+# =============================================================================
+MEMEX_DIR="$HOME/memex"
+ZETTELKASTEN_DIR="$HOME/memex/notes"
+INBOX_DIR="$HOME/memex/inbox"
+DAILY_DIR="$HOME/memex/daily"
+PROJECTS_DIR="$HOME/memex/projects"
+AREAS_DIR="$HOME/memex/areas"
+RESOURCES_DIR="$HOME/memex/resources"
+ARCHIVES_DIR="$HOME/memex/archives"
+SYSTEM_DIR="$HOME/memex/system"

.gitea/workflows/deploy.yml

@@ -1,44 +1,24 @@
-name: Deploy-Agent-V15-Stdin
+name: Deploy (Gitea)
+
 on:
   push:
     branches:
       - main
 
 jobs:
-  JOB-V15-STDIN:
+  deploy:
     runs-on: debian-latest
     steps:
-      - name: Checkout Code
-        uses: actions/checkout@v3
+      - name: Checkout
+        uses: actions/checkout@v4
 
       - name: Install Docker CLI
         run: |
-          echo "Installing Docker CLI..."
-          apt-get update
-          apt-get install -y docker.io docker-compose
+          apt-get update && apt-get install -y docker.io docker-compose
 
-      - name: Deploy via Host Docker Socket (Stdin Method)
+      - name: Build and deploy via Docker Compose
         run: |
-          echo "Piping local compose file to host Docker daemon..."
-          
-          # We read the compose file from the checked-out code in the runner,
-          # but we tell the host Docker daemon that the "project directory" is /memex/projects/opencortex.
-          # The host daemon will use its own /memex files to build the image.
-          
-          cat deploy/docker/docker-compose.yml | docker-compose \
-            -p opencortex \
-            --project-directory /memex/projects/opencortex \
-            -f - \
-            down
-            
-          cat deploy/docker/docker-compose.yml | docker-compose \
-            -p opencortex \
-            --project-directory /memex/projects/opencortex \
-            -f - \
-            build --no-cache opencortex
-            
-          cat deploy/docker/docker-compose.yml | docker-compose \
-            -p opencortex \
-            --project-directory /memex/projects/opencortex \
-            -f - \
-            up -d --force-recreate opencortex
+          cd infrastructure/docker
+          docker-compose -p opencortex down
+          docker-compose -p opencortex build --no-cache opencortex
+          docker-compose -p opencortex up -d --force-recreate opencortex

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,25 @@
+name: Bug Report
+
+about: Report something that is not working as expected.
+
+---
+
+**Describe the bug**
+A clear description of what went wrong.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Run '...'
+3. See error
+
+**Expected behavior**
+What you expected to happen.
+
+**Environment:**
+- OS: [e.g. Debian 12, macOS 14]
+- SBCL version: [e.g. 2.4.0]
+- OpenCortex version: [e.g. v0.1.0]
+
+**Additional context**
+Any other relevant information (logs, stack traces, etc.)

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,22 @@
+name: Feature Request
+
+about: Suggest a new feature or enhancement.
+
+---
+
+**Describe the problem**
+What problem does this feature solve?
+
+**Describe the ideal solution**
+A clear description of what you want to happen.
+
+**Describe alternatives considered**
+Any alternative solutions you've considered.
+
+**Additional context**
+Any other relevant context (mockups, related issues, etc.)
+
+**Implementation suggestion**
+(Optional) If you have thoughts on how to implement this in pure Common Lisp + Org-mode:
+- Which skill should own this?
+- Should it be a =def-cognitive-tool=, a new skill, or an enhancement to an existing one?

.github/workflows/lint.yml

@@ -0,0 +1,87 @@
+name: Lint
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    env:
+      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends \
+            git emacs-nox
+
+      - name: Check for forbidden patterns
+        run: |
+          ! grep -r "json\." --include="*.lisp" . && \
+            echo "OK: No JSON in Lisp files"
+
+      - name: Check skills have lisp source blocks
+        run: |
+          FAIL=0
+          for f in skills/*.org; do
+            if ! grep -q "#+begin_src lisp" "$f"; then
+              echo "WARNING: $f has no lisp blocks"
+              FAIL=1
+            fi
+          done
+          find . -name "*.org" -path "*/skills/*" -exec grep -L "#+begin_src lisp" {} \; | \
+            grep -v "CLA\|CONTRIBUTING\|CHANGELOG\|README\|USER_MANUAL" || true
+          echo "OK: All skills have lisp blocks"
+
+      - name: Verify each .lisp has a corresponding .org source
+        run: |
+          FAIL=0
+          for f in harness/*.lisp tests/*.lisp; do
+            [ -f "$f" ] || continue
+            org="${f%.lisp}.org"
+            [ -f "$org" ] && continue
+            base=$(basename "$f" .lisp)
+            # Check if generated from a parent org via :tangle
+            parent="${base%-tests}.org"
+            parent="${parent%-validator}.org"
+            parent="${parent%-client}.org"
+            if [ -f "harness/$parent" ] || [ -f "skills/$parent" ]; then
+              : # generated from parent org via :tangle
+            elif grep -q ":tangle.*$(basename "$f")" harness/*.org skills/*.org 2>/dev/null; then
+              : # :tangle reference found in another org
+            else
+              echo "WARNING: $f has no corresponding .org source"
+              FAIL=1
+            fi
+          done
+          for f in skills/*.lisp; do
+            [ -f "$f" ] || continue
+            org="${f%.lisp}.org"
+            if [ ! -f "$org" ]; then
+              echo "ERROR: $f has no .org source"
+              FAIL=1
+            fi
+          done
+          [ "$FAIL" = 0 ] && echo "OK: All .lisp files have .org sources"
+
+      - name: Check literate granularity (one function per block)
+        run: |
+          for f in skills/*.org; do
+            blocks=$(grep -c "^[[:space:]]*(defun " "$f" 2>/dev/null || true)
+            srcblocks=$(grep -c "#+begin_src lisp" "$f" 2>/dev/null || true)
+            if [ "$blocks" -gt "$srcblocks" ] && [ "$srcblocks" -gt 0 ]; then
+              echo "WARNING: $f has $blocks defuns but only $srcblocks src blocks"
+            fi
+          done
+          echo "OK: Granularity check complete"
+
+      - name: Check README has quick install
+        run: |
+          grep -q "curl.*opencortex" README.org && \
+            echo "OK: Quick install in README" || \
+            echo "WARNING: Quick install curl command not found in README"

.github/workflows/release.yml

@@ -0,0 +1,31 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Create tarball
+        run: |
+          git archive --format=tar.gz --prefix=opencortex-$(git describe --tags) HEAD -o opencortex.tar.gz
+
+      - name: Create zipball
+        run: |
+          git archive --format=zip --prefix=opencortex-$(git describe --tags) HEAD -o opencortex.zip
+
+      - name: Upload to GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            opencortex.tar.gz
+            opencortex.zip
+          generate_release_notes: true

.github/workflows/test.yml

@@ -0,0 +1,100 @@
+name: Tests
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends \
+            sbcl emacs-nox git curl socat rlwrap
+
+      - name: Install Quicklisp
+        run: |
+          curl -fsSL https://beta.quicklisp.org/quicklisp.lisp -o /tmp/quicklisp.lisp
+          sbcl --noinform --non-interactive \
+            --load /tmp/quicklisp.lisp \
+            --eval '(quicklisp-quickstart:install)'
+          rm -f /tmp/quicklisp.lisp
+
+      - name: Load and verify harness
+        run: |
+          export OC_DATA_DIR="$PWD/.github-test"
+          mkdir -p "$OC_DATA_DIR/harness" "$OC_DATA_DIR/tests"
+
+          # Tangle harness files into test directory
+          mkdir -p /tmp/oc-build
+          cp harness/*.org "$OC_DATA_DIR/harness/"
+          cd "$OC_DATA_DIR/harness" && for f in *.org; do
+            if command -v emacs; then
+              emacs -Q --batch --eval "(require 'org)" \
+                --eval "(setq org-confirm-babel-evaluate nil)" \
+                --eval "(org-babel-tangle-file \"$f\")" 2>/dev/null || true
+            fi
+          done
+          rm -f *.org
+          cd "$OLDPWD"
+
+          # Copy skills, tangle, verify
+          mkdir -p "$OC_DATA_DIR/skills"
+          cp skills/*.org "$OC_DATA_DIR/skills/"
+          cd "$OC_DATA_DIR/skills" && for f in *.org; do
+            if command -v emacs; then
+              emacs -Q --batch --eval "(require 'org)" \
+                --eval "(setq org-confirm-babel-evaluate nil)" \
+                --eval "(org-babel-tangle-file \"$f\")" 2>/dev/null || true
+            fi
+          done
+          rm -f *.org
+          cd "$OLDPWD"
+
+      - name: Load opencortex and initialize skills
+        run: |
+          export OC_DATA_DIR="$PWD/.github-test"
+          sbcl --non-interactive \
+            --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+            --eval "(push (truename \"$PWD/\") asdf:*central-registry*)" \
+            --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+            --eval '(ql:quickload :opencortex :silent t)' \
+            --eval "(setf (uiop:getenv \"OC_DATA_DIR\") \"$OC_DATA_DIR\")" \
+            --eval '(opencortex:initialize-all-skills)' \
+            --eval "(let ((n (hash-table-count opencortex:*skills-registry*))) (format t \"~%Skills loaded: ~a~%\" n) (unless (>= n 20) (sb-ext:exit :code 1)))"
+
+      - name: Daemon smoke test
+        run: |
+          export OC_DATA_DIR="$PWD/.github-test"
+          sbcl --non-interactive \
+            --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+            --eval "(push (truename \"$PWD/\") asdf:*central-registry*)" \
+            --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+            --eval "(ql:quickload '(:opencortex :croatoan))" \
+            --eval "(setf (uiop:getenv \"OC_DATA_DIR\") \"$OC_DATA_DIR\")" \
+            --eval '(opencortex:main)' \
+            > /tmp/oc-daemon.log 2>&1 &
+          DAEMON_PID=$!
+
+          for i in $(seq 1 20); do
+            if ss -tln 2>/dev/null | grep -q 9105; then
+              echo "✓ Daemon ready on port 9105"
+              # Read the initial handshake via a short TCP connection
+              timeout 3 bash -c 'exec 3<>/dev/tcp/localhost/9105; head -c 200 <&3' 2>/dev/null | grep -q "handshake" && \
+                echo "✓ Protocol handshake received"
+              break
+            fi
+            sleep 1
+          done
+
+          kill $DAEMON_PID 2>/dev/null || true
+          wait $DAEMON_PID 2>/dev/null || true
+          echo "✓ Daemon smoke test passed"

.gitignore

@@ -4,3 +4,9 @@ opencortex-server
 *.log
 *~
 \#*#
+opencortex-tui
+test_input.txt
+
+# Generated artifacts (source of truth is .org)
+/skills/*.lisp
+/tests/*.lisp

CHANGELOG.org

@@ -1,19 +0,0 @@
-#+TITLE: Changelog
-#+STARTUP: content
-
-* v0.1.0 - The Autonomous Foundation (2026-04-13)
-This is the initial MVP release of the ~opencortex~. It establishes a secure, auditable Lisp kernel for a personal operating system.
-
-** Features
-- **Metabolic Pipeline:** Robust Perceive-Reason-Act loop with selective memory rollbacks and graceful shutdown handling.
-- **Verification Lock:** Mandatory skill enforcement via environment configuration. System halts if security policies or bouncers fail to load.
-- **Foveal-Peripheral Context:** High-resolution focus on active tasks with low-resolution skeletal awareness of the rest of the Memex.
-- **The Bouncer:** Last-mile deterministic security gate with Deep Packet Inspection for secrets and network exfiltration.
-- **Autonomous Scribe:** Background distillation worker that turns daily journal entries into evergreen Zettelkasten notes.
-- **Unified Onboarding:** Single-command installation (~opencortex.sh~) with Docker-first deployment and OS detection.
-- **CLI Gateway:** Local TCP socket server and interactive chat client for frictionless first contact.
-
-** Architectural Shift
-- Transitioned to **Literate Granularity**: Every function and invariant is now documented in its own Org block.
-- **Configuration Externalization:** All timing, thresholds, and identities are now driven by environment variables.
-- **Thin Harness Philosophy:** Decoupled the kernel from specific editors or third-party gateways.

Dockerfile

@@ -1,71 +0,0 @@
-# OPENCORTEX v1.0 Production Environment
-FROM debian:bookworm-slim
-
-# Prevent interactive prompts during build
-ENV DEBIAN_FRONTEND=noninteractive
-
-# 1. Install System Dependencies
-# - sbcl: The Lisp Runtime
-# - curl/git/unzip: Standard tools for Quicklisp and binaries
-# - default-jre: Required by signal-cli
-# - python3/pip: Required for Playwright bridge
-# - socat: Required for stateful CLI interaction
-RUN apt-get update && apt-get install -y \
-    sbcl \
-    curl \
-    git \
-    unzip \
-    default-jre \
-    libsqlite3-0 \
-    python3 \
-    python3-pip \
-    python3-venv \
-    emacs-nox \
-    socat \
-    && rm -rf /var/lib/apt/lists/*
-
-# 2. Setup Playwright (High-Fidelity Browsing)
-RUN python3 -m venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
-RUN pip install playwright \
-    && playwright install --with-deps chromium
-
-# 3. Install signal-cli (v0.14.0)
-ENV SIGNAL_CLI_VERSION=0.14.0
-RUN curl -L https://github.com/AsamK/signal-cli/releases/download/v${SIGNAL_CLI_VERSION}/signal-cli-${SIGNAL_CLI_VERSION}-Linux.tar.gz | tar xz -C /opt \
-    && ln -s /opt/signal-cli-${SIGNAL_CLI_VERSION}/bin/signal-cli /usr/local/bin/signal-cli
-
-# 4. Install Quicklisp & Pin Distribution
-# Pinned to 2026-04-01 for bit-rot resistance.
-WORKDIR /root
-RUN curl -O https://beta.quicklisp.org/quicklisp.lisp \
-    && sbcl --non-interactive \
-        --load quicklisp.lisp \
-        --eval '(quicklisp-quickstart:install)' \
-        --eval '(ql-dist:install-dist "http://beta.quicklisp.org/dist/quicklisp/2026-04-01/distinfo.txt" :prompt nil :replace t)'
-
-# 5. Configure SBCL to load Quicklisp on startup
-RUN echo '(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))) (when (probe-file quicklisp-init) (load quicklisp-init)))' > /root/.sbclrc
-
-# 6. Setup Application Directory
-WORKDIR /app
-COPY . /app/projects/opencortex
-
-# 7. Pre-cache Lisp Dependencies
-RUN sbcl --non-interactive \
-    --eval '(push #p"/app/projects/opencortex/" asdf:*central-registry*)' \
-    --eval '(ql:quickload :opencortex)'
-
-# 8. Environment & Volumes
-# The host's memex root should be mounted to /memex
-ENV MEMEX_DIR=/memex
-VOLUME ["/memex"]
-
-# Default Ports
-EXPOSE 9105 8080
-
-# Entrypoint
-CMD ["sbcl", "--non-interactive", \
-     "--eval", "(push #p\"/app/projects/opencortex/\" asdf:*central-registry*)", \
-     "--eval", "(ql:quickload :opencortex)", \
-     "--eval", "(opencortex:main)"]

LICENSE

@@ -1,21 +1,661 @@
-MIT License
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
-Copyright (c) 2026 Amr Gharbeia
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

README.org

@@ -1,144 +1,112 @@
-#+TITLE: OpenCortex: The Conductor of your Life Stack
+#+TITLE: OpenCortex: Your Autonomous, Plain-Text Life Assistant
+#+AUTHOR: Amr
+#+FILETAGS: :opencortex:ai:assistant:
 
-*opencortex* is a minimalist, extensible AI agent framework designed to manage and continuously organize your personal knowledge base. It transforms a static collection of plaintext notes into a live, programmable [[https://en.wikipedia.org/wiki/Memex][Memex]]—an automated, personalized memory system where humans and AI collaborate in the exact same workspace.
+#+HTML: <div style="display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 1em;">
+#+HTML: <img src="https://img.shields.io/github/v/tag/amrgharbeia/opencortex?label=version&style=flat-square">
+#+HTML: <img src="https://img.shields.io/github/license/amrgharbeia/opencortex?style=flat-square">
+#+HTML: <img src="https://img.shields.io/badge/Lisp-Common%20Lisp-blue?style=flat-square">
+#+HTML: <img src="https://img.shields.io/badge/docs-Org--mode-green?style=flat-square">
+#+HTML: </div>
 
-* The Problem with Current AI Agents
-
-The current ecosystem of AI agents (typically built in Python or TypeScript) is overwhelmingly built on architectural choices that prioritize rapid prototyping over long-term reliability, security, and self-modification:
-
-1. *The Format Trap (Markdown & JSON):* Most agents force a painful translation layer. Humans write in Markdown, which lacks a strict Abstract Syntax Tree (AST)—a rigorous, nested representation of data that machines need to parse context reliably. Machines, in turn, output JSON or YAML, which are hostile formats for human thought and note-taking. The result is a fractured workspace where the agent's memory and the human's memory are fundamentally incompatible. Furthermore, because Markdown cannot be efficiently collapsed, agents are forced to consume massive amounts of tokens by reading entire files just to find a single paragraph.
-2. *The Language Trap (Python & TypeScript):* Python and TypeScript are fantastic for gluing together APIs or training models, but they are poorly suited for an agent that needs to safely read, write, and execute its own code at runtime. Their underlying structures are complex and opaque, making autonomous self-editing incredibly brittle and dangerous.
-3. *The Probabilistic Trap:* Almost all modern agents rely entirely on /probabilistic/ reasoning. We ask an AI model to guess a shell command or write a Python script, and then blindly pipe that output to a terminal. Without a rigorous, /deterministic/ layer to formally verify the model's proposals before execution, these systems are fundamentally unsafe. 
-
-* The Vision: A Modern, Homoiconic Memex
-
-opencortex abandons these fragile paradigms by returning to first principles and embracing two historically powerful technologies: *Org-mode* and *Common Lisp*. 
-
-** 1. Org-mode: The Universal Language
-Instead of wrestling with Markdown parsers or hiding data in opaque databases, opencortex mandates that *Org-mode is the native AST for both humans and machines.* 
-
-Org-mode is unique because it seamlessly brings together human-readable prose, structured metadata (properties and tags), lifecycle states (TODO/DONE), and executable code blocks into a single plain-text file. The code is the data, and the data is the interface. When the agent "remembers" a fact or schedules a task, it writes an Org headline. You read exactly what the agent reads.
-
-*The Token Advantage:* Because Org-mode is a strict outline, opencortex never needs to send an entire document to an AI model. It uses *Sparse Trees* to send a high-level table of contents, zooming in only on the specific headline relevant to the task. This drastically reduces token consumption and eliminates context window overflow.
-
-** 2. Common Lisp: The Engine of Self-Modification
-There is a beautiful irony to opencortex: Lisp was invented in 1958 specifically to achieve Artificial Intelligence, and it has been waiting nearly 70 years for /this exact moment/ in computing history. 
-
-Lisp possesses a unique property called *Homoiconicity*: the primary representation of the program is also a data structure (nested lists) within the language itself. Because Lisp code /is/ Lisp data, it is trivially easy for an AI to generate, manipulate, and safely evaluate new tools at runtime. This makes Lisp the ultimate, un-brittle language for a "self-writing" agent.
-
-** 3. The Probabilistic-Protodeterministic Loop
-opencortex does not let AI models touch your system directly. Instead, it splits cognition into two distinct engines:
-- *The Probabilistic Engine (The AI Models):* Provides semantic understanding, multimodal translation, and probabilistic creativity. It looks at your Memex and proposes an action by writing a strictly formatted Lisp s-expression.
-- *The Deterministic Engine (Common Lisp):* Provides deterministic logic, physics, and safety. It intercepts the model's Lisp proposal, formally verifies its structure against your security rules, and only executes it if it is mathematically sound.
-
-Crucially, the Deterministic engine is *continuously progressive*. Right now, it starts by acting as a strict security bouncer—enforcing rules and bounding the AI's actions. But as the system matures, the Deterministic engine will progressively take over more and more of the actual reasoning, reducing the AI models' involvement to a mere semantic translation layer for the messy outside world. We are moving from a /probabilistic-protodeterministic/ system today, toward a fully autonomous /probabilistic-deterministic/ Lisp machine tomorrow.
-
-* Architecture: Thin Harness, Fat Skills
-
-To guarantee long-term stability, opencortex enforces a strict architectural boundary inspired by the "thin harness, fat skills" philosophy.
-
-** The Minimalist Harness
-The Lisp microkernel does almost no actual "work." It is a thin, unbreakable harness strictly responsible for three things:
-1. *The Memory:* Maintaining the live graph of your Memex in RAM.
-2. *The Communication Protocol:* Managing the secure bridge between the agent and the outside world. While power users can connect natively via Emacs or Vim, the vast majority of users will interact with opencortex exclusively through chat clients (like Telegram, Signal, or Matrix), web dashboards, or a Terminal UI (TUI). The harness doesn't care; it just securely routes the messages.
-3. *The Cognitive Cycle:* Moving signals through the Perceive -> Probabilistic -> Deterministic -> Dispatch pipeline.
-
-Everything else—AI routing, vector embeddings, shell execution, or web browsing—is pushed entirely out of the harness and into *Fat Skills*.
-
-** Literate, Single-File Skills
-In standard agent frameworks, adding a new capability (like "Search the Web") requires creating a sprawling folder with a Python script, a JSON configuration file, and a separate text file for the AI prompt. This creates massive structural bloat.
-
-In opencortex, a Skill is simply a *single .org file*. 
-
-Using *Literate Programming*, this single file contains everything:
-- The human-readable documentation and architectural intent.
-- The system prompt instructions for the Probabilistic Engine.
-- The deterministic Lisp code for the Deterministic engine's safety checks.
-- The actual execution logic.
-
-When the system boots, it parses these single files, mathematically proves their dependencies, and compiles them directly into the live Lisp image.
-
-** The Anatomy: Three Data Stores
-The agent's "mind" is not a transient chat session; it is a durable, stateful architecture consisting of three layers:
-1. *The Linguistic Substrate (Plaintext Files):* The human-readable Source of Truth on your hard drive. You can edit these files in any text editor, and the agent will instantly perceive the changes.
-2. *The Lisp Memory (RAM):* The "Active Brain," a live, threaded graph of Lisp objects representing every headline, paragraph, and tag in your Memex. It allows the agent to navigate your life instantly without constantly re-reading files.
-3. *The Telemetry Store (External):* A high-volume database for sub-deterministic sensory data (e.g., smart home logs or system metrics), which the agent monitors and distills.
-
-** The Psychology: The 2x2 Cognitive Matrix
-The agent operates on a matrix that balances cognitive speed with cognitive state:
-
-| | Probabilistic (Neural/Intuitive) | Deterministic (Deterministic/Logical) |
-| :--- | :--- | :--- |
-| Foreground (Active) | *The Interface:* Fast AI models for conversation, multimodal ingestion, and semantic understanding. | *The Steward:* Lisp engine that safely retrieves requested data from the Memex and enforces security rules while the Interface keeps you engaged. |
-| Background (Passive) | *The Editor:* Deep AI models finding hidden patterns while you sleep. | *The Librarian:* Lisp engine continuously maintaining data integrity and filing away loose notes. |
-
-** The Physiology: Five Core Processes
-1. *Perception:* Automatically vectorizes your input and sets the "Foreground Focus" so the agent knows exactly what you are looking at or talking about.
-2. *Reasoning:* Uses Lisp-native logic to reconcile contradictions and enforce the physics of the Memex.
-3. *Distillation:* A Background loop that reads your chronological daily logs and automatically extracts concepts into permanent, evergreen notes.
-4. *Reflection:* A heartbeat-driven process that finds forgotten links and maintains the structural health of the system.
-5. *Sensation:* A converter that monitors the raw flood of telemetry data and turns significant anomalies into actionable TODO items on your list.
-
-* The Ecosystem: Core Skill Groups
-
-Because the harness is deliberately thin, every capability of opencortex is implemented as a single-file Literate Skill. This allows you to hot-reload, modify, or completely remove features on the fly without restarting the core environment. 
-
-The ecosystem is divided into five primary skill groups:
-
-** 1. Gateways (How you talk to the agent)
-The agent meets you where you are. While it natively integrates with text editors, it features standalone gateway skills for modern interfaces. 
-- *Chat Gateways:* Interact securely from your phone via clients like Matrix, Signal, or Telegram.
-- *Web & TUI Dashboards:* High-level visual overviews of your agent's background processes and telemetry.
-
-** 2. Cognition & Memory (How the agent thinks)
-- *Model Routing:* Dynamically routes requests to the best available Probabilistic model (e.g., Anthropic, OpenAI, Local Llama) based on task complexity or privacy needs.
-- *Peripheral Vision & Embeddings:* Manages the vectorization of your notes, ensuring the agent retrieves semantically relevant context via sparse trees.
-- *The Ontology Scribe:* Centralizes all rules regarding Org, GTD, and Org-Roam parsing into a single background subroutine, eliminating parser confusion across the codebase.
-
-** 3. Actuators (How the agent affects the world)
-- *The Shell Actuator:* Safely executes whitelisted terminal commands to interact with the host OS.
-- *The Playwright Bridge:* Grants the agent the ability to spin up a headless browser, navigate the web, read documentation, and interact with web applications.
-
-** 4. Security & Alignment (How the agent stays safe)
-- *Formal Verification:* The mathematical gatekeeper that proves a proposed action is safe (e.g., ensuring file writes are confined strictly to your Memex directory) before execution.
-- *The Credentials Vault:* A secure, masked enclave that prevents AI models from ever reading your raw API keys or .env files.
-
-** 5. Background Subroutines (The Autonomous Workers)
-- *The Journal Scribe:* Periodically distills messy chronological logs into clean, permanent notes.
-- *The Gardener:* A heartbeat-driven worker that flags broken links, finds orphaned ideas, and maintains the structural health of your Memex.
-
-* Quick Start (The Zero-to-One Experience)
-
-opencortex can be installed and booted with a single command. The unified entrypoint script will detect your OS, offer to install Docker if missing, interactively gather your API keys, and launch the autonomous kernel in the background.
+* Quick Install
 
 #+begin_src bash
-curl -fsSL https://raw.githubusercontent.com/gharbeia/opencortex/main/opencortex.sh | bash
+curl -fsSL https://raw.githubusercontent.com/amrgharbeia/opencortex/main/opencortex.sh | bash -s configure
 #+end_src
 
-After installation, simply type `opencortex` in your terminal to start chatting with your autonomous brain.
+Then run ~opencortex tui~ to start chatting.
 
-For power users who wish to run the agent natively (Baremetal), please refer to the [[file:literate/setup.org][setup.org]] literate documentation.
+* Meet OpenCortex
 
-* The Evolutionary Roadmap (v0.1.0 to v4.0.0+)
+Most AI assistants are just chatbots. You ask a question, they answer, they forget you exist. They trap your conversations in proprietary web apps and silo your data.
 
-** v0.1.0: The Autonomous Foundation (Current Release)
-The initial MVP that establishes a secure, auditable Lisp kernel for a personal operating system. It features a robust metabolic pipeline, mandatory skill enforcement, and background distillation.
+*OpenCortex is different. It is an AI that lives inside your own text files.*
 
-** v1.0.0 (Phase 2.5): The Verified Wrapper (Current Target)
-At this stage, opencortex achieves feature parity with State-of-the-Art autonomous agents (like Devin or SWE-agent) but with Lisp-grade mathematical security.
-- *The Tools are External:* The agent uses a standard bash shell, a headless browser (via Playwright), and standard file I/O.
-- *The Safety is Internal:* The Bouncer and Formal Verification gates mathematically prove actions are safe before piping them to external tools.
-- *The Result:* An autonomous agent capable of end-to-end software engineering, web research, and system administration, running securely and locally.
+It runs locally on your machine. It reads your notes, organizes your life, executes tasks, and gardens your knowledge base—all while keeping your data in plain text files you own completely.
 
-** v2.0.0 (Phase 3): The Cannibalization
-Replacing string-based tool wrappers with native Lisp data structures to eliminate LLM fragility.
-- *Cannibalizing the Browser:* Ingesting the DOM as a native Lisp AST rather than fighting with Playwright scripts.
-- *Cannibalizing the Shell & Editor:* Moving from bash execution to native OS API bindings. Emacs becomes a viewport for the live AST, not a master.
-- *The Result:* The LLM no longer has to guess at messy `stdout` or raw HTML strings; it manipulates deterministic data structures directly.
+* Why OpenCortex Exists
 
-** v3.0.0 (Phase 4): True Symbolic Determinism
-The great inversion. The Lisp engine takes the wheel, and the LLM is relegated to translation.
-- *The Semantic Translator:* The LLM exclusively translates unstructured human intent (natural language, images) into strict Lisp S-expressions.
-- *Deterministic Planning (The Solver):* The core reasoning engine uses formal logic, graph traversal, and constraint solving to plan and execute workflows.
-- *Self-Correcting Syntax:* The Lisp engine catches and repairs hallucinated syntax errors without consulting the LLM.
+The current generation of AI agents have a fundamental flaw: they prioritize quick demos over long-term reliability and user sovereignty.
 
+The biggest problem is data ownership. Most agents bury your memories in opaque databases. If you want to see your own data, you have to ask the AI to fetch it. If the app shuts down, your data is gone.
+
+OpenCortex solves this with total plain-text transparency. Your entire life is a folder of text files. OpenCortex manages them the same way you do—with any text editor. No database to migrate, no schema to update, no lock-in.
+
+* What Makes OpenCortex Different
+
+Most AI agents are Python applications that happened to call an LLM. OpenCortex is different. It is built in pure Common Lisp—top to bottom, no wrapper, no translation layer.
+
+The kernel is Lisp. The skills are Lisp. The memory system is Lisp. The TUI is Lisp. One language from the hardware to the agent's thoughts.
+
+Python agents need a second language for configuration (YAML), a third for memory (JSON or SQLite), and a fourth for deployment (Docker). OpenCortex needs SBCL. That's it.
+
+This is not nostalgia for the 1980s. Lisp has two properties that matter for an autonomous agent.
+
+First, code is data. In Lisp, the agent can read its own code the same way it reads a text file. It can parse its skills, understand their structure, and modify them at runtime. Python's AST is a foreign object—the agent can inspect it, but not treat it as something it owns.
+
+Second, stability. The Common Lisp specification has been stable for decades. Your code does not break because a library changed its API. Dependencies do not rot. A Lisp program from 1995 still runs today.
+
+Your data lives in Org-mode files. Not a database. Not JSON. Not a vector store. Just plain text that you can read in any editor, search with grep, and back up any way you want.
+
+This matters because every other agent makes your data dependent on their app. Their database schema defines what you can store. Their migration scripts decide whether your data survives an upgrade. OpenCortex has no schema. Your memory is a folder of text files. It survives app updates, platform switches, and decades of use.
+
+The agent fixes itself. When it encounters an error, it can modify its own code, apply surgical fixes, and learn from the outcome to improve and grow. Skills hot-reload at runtime, so you can extend the system without restarting. And if something goes wrong during a complex operation, it snaps back to a known-good state.
+
+* Three Problems Every Agent Ignores
+
+Every other AI assistant has three fundamental flaws that OpenCortex addresses.
+
+The first is the data silo. Most agents bury your memories in opaque databases. If you want to see your own data, you have to ask the AI to fetch it. If the app shuts down, your data is gone. OpenCortex stores everything in plain text files that you own. No migration needed, no schema to update, no lock-in.
+
+The second is the hallucination problem. Most agents pipe AI-generated text directly into your terminal. If the model hallucinates, it can delete your files or break your system. OpenCortex splits its brain into two parts. The creative brain (the LLM) suggests actions. The strict guard (deterministic logic) intercepts every proposal before it touches a file or runs a command. If the AI hallucinates, the guard blocks it.
+
+The third is cloud dependency. Most assistants rely entirely on big tech APIs. When your internet drops, or the service goes down, your assistant dies. Worse, your private notes are constantly sent to third-party servers. OpenCortex runs on your own hardware using free, open-source models. Your private data never leaves your laptop. Cloud models are optional—used only when you explicitly allow them for complex tasks.
+
+* Quick Start
+
+You need SBCL (Steel Bank Common Lisp) installed.
+
+#+begin_src bash
+# Clone the repository
+git clone https://github.com/amrgharbeia/opencortex.git ~/memex/projects/opencortex
+
+# Run the Setup Wizard
+cd ~/memex/projects/opencortex
+./opencortex.sh setup
+
+# Verify System Health
+opencortex doctor
+
+# Enter the Brain
+opencortex tui
+#+end_src
+
+* The Onboarding Trifecta
+
+`opencortex setup` guides you through configuring LLM providers. Tell it how to talk to Ollama, Groq, OpenRouter, or your own endpoint.
+
+`opencortex gateway link <platform> <token>` connects external chat gateways. Talk to your agent from Telegram while it works on your files.
+
+`opencortex doctor` shows you what's working, what's broken, and what needs attention.
+
+* Architecture
+
+OpenCortex has three layers.
+
+The Harness is the kernel. It runs the [[file:harness/loop.org][metabolic loop]]—Perceive → Reason → Act—each signal moving through normalization, LLM reasoning, skill verification, and action execution. Depth limits prevent infinite loops. The [[file:harness/memory.org][memory system]] persists to plain-text Org-mode files with snapshot and rollback on errors.
+
+The Skills are userland—thin harness, fat skills. Modular skills load at runtime. Diagnostics, Configuration, LLM Gateway, Shell Actuation, Emacs Editing, Self-Edit, Self-Fix, Credentials Vault, Tool Permissions, Protocol Validator, and more. Each is an independent Org-mode module. Add new skills without touching the kernel.
+
+The Interface is what you use to talk to the agent. A native Lisp [[file:harness/tui-client.org][TUI]] with semantic highlighting and history. A [[file:harness/communication.org][TCP socket server]] for CLI interaction. External channels via the gateway—Telegram and beyond.
+
+* Project Documentation
+
+OpenCortex practices what it preaches—the documentation lives in the code.
+
+The [[file:USER_MANUAL.org][User Manual]] covers setup, configuration, and commands. The [[file:docs/ROADMAP.org][Evolutionary Roadmap]] shows our plan for reaching state-of-the-art capabilities. The [[file:docs/CONTRIBUTING.org][Contributing]] guide teaches you how to add new skills.
+
+* License
+
+OpenCortex is released under the [[file:LICENSE][AGPLv3 license]].
+See [[file:CLA.org][CLA.org]] for the Contributor License Agreement.

TODO.org

@@ -0,0 +1,796 @@
+# OpenCortex Project Tasks
+# All OpenCortex-related TODOs live here. gtd.org links to this file.
+# Evolutionary context: see docs/ROADMAP.org
+
+* PHASE: AUTONOMOUS MVP (v0.1.0 Released)
+:PROPERTIES:
+:ID:       proj-mvp-v0-1-0
+:END:
+The "Zero-to-One" release. The agent must be mathematically secure, CLI-first, and capable of autonomous Memex maintenance.
+
+** DONE 1. Harness Hardening (The Final Audit)
+*** DONE Audit remaining core skills (`org-skill-policy.org`, `org-skill-bouncer.org`) to the new Literate Granularity standard.
+*** DONE Implement Verification Lock: Ensure `MANDATORY_SKILLS` pass `validate-lisp-syntax` before boot proceeds.
+*** DONE Logging & Transparency: Ensure `context-get-system-logs` is utilized by the Reason engine to explain blocked actions.
+
+** DONE 2. The Autonomous Scribe & Gardener (The Primary Value Prop)
+*** DONE Implement `org-skill-scribe.org`: Background worker that distills daily chronological logs into structured Zettelkasten notes.
+*** DONE Implement `org-skill-gardener.org`: Heartbeat-driven skill that autonomously flags orphaned nodes and repairs broken links.
+
+** DONE 3. The Zero-to-One Experience (setup.org)
+*** DONE Consolidate installation instructions, `onboard.sh`, and `Dockerfile` into a single, literate `setup.org` file.
+*** DONE Ensure the setup process interactively builds the `.env` and verifies SBCL/Quicklisp dependencies.
+
+** DONE 4. CLI-First Actuation
+    CLOSED: [2026-04-14 Tue 09:40]
+*** DONE Verified the `cli` actuator and inbound gateway handle standard I/O interaction gracefully via a stateful `socat` connection.
+
+* PHASE: PUBLICATION & VERIFICATION (v0.1.0 Post-Release)
+:PROPERTIES:
+:ID:       proj-pub-v0-1-0
+:END:
+Ensuring the system is ready for the world through collaborative testing, documentation, and licensing.
+
+** DONE 1. Collaborative End-to-End Testing [2026-04-21 Tue]
+    CLOSED: [2026-04-21 Tue 17:30]
+*** DONE Verified stable foundation at commit `cab0e5a`.
+*** DONE Verified boot sequence and bidirectional connectivity.
+
+** DONE 2. Semantic Reorganization & System Stabilization [2026-04-21 Tue]
+    CLOSED: [2026-04-21 Tue 18:30]
+*** DONE Rename directories: harness/, library/, environment/, infrastructure/.
+*** DONE Consolidate Probabilistic engine into reason.lisp.
+*** DONE Embed bidirectional CLI logic into opencortex.sh.
+*** DONE Stabilize skill engine: 12/12 skills loaded with package jailing.
+*** DONE Cleanup legacy documentation and deployment artifacts.
+
+** DONE 2. Comprehensive Documentation <2026-04-14 Tue>
+    CLOSED: [2026-04-20 Mon 18:00]
+*** DONE Draft `USER_MANUAL.org`: Focus on CLI interaction, installation, and Memex structure.
+*** DONE Draft `CONTRIBUTING.org`: Explain Literate Granularity and Skill creation standards.
+
+** DONE 3. License & Legal Finalization <2026-04-14 Tue>
+    CLOSED: [2026-04-17 Fri 11:25]
+*** DONE Assign the AGPLv3 open-source license.
+*** DONE Implement a broad Contributor License Agreement (CLA) process.
+*** DONE Update `LICENSE` and `CHANGELOG` accordingly.
+
+** TODO 4. GitHub Migration & Repository Setup <2026-04-14 Tue>
+*** TODO Migrate primary remote to GitHub and configure canonical repository.
+*** TODO Set repository topics, badges, issue templates, and CI/CD foundations.
+
+** TODO 5. Marketing & Social Media Launch <2026-04-14 Tue>
+*** TODO Execute PR plan (Reddit, Hacker News, X/Twitter).
+*** TODO Create a short, high-quality terminal demo GIF/video of the TUI interaction.
+
+* PHASE: INTERACTIVE REFINEMENT (v0.2.0 Target)
+:PROPERTIES:
+:ID:       proj-refinement-v0-2-0
+:END:
+Elevating the user interface from raw shell piping to a high-fidelity, native Lisp experience. Priority: Self-editing is the foundation of all future growth. Full org-mode manipulation makes the agent a true Emacs citizen.
+
+Roadmap basis: Evolutionary roadmap from README.org. Working backwards from SOTA parity.
+
+** DONE 0. Autonomous Self-Editing Foundation
+*** DONE org-skill-lisp-repair (Lisp syntax repair)
+    - Deterministic: auto-balance parens via paren-counting
+    - Probabilistic: LLM generates surgical fix on =:syntax-error= events
+    - Memory rollback on failure
+    DONE: Now in org-skill-lisp-utils (merged from contrib)
+*** DONE org-skill-emacs-edit (full org-mode manipulation)
+    - Read org buffers, parse AST via org-element
+    - Create/update/delete headlines, set properties, manage TODO states
+    - Handle =id:= links and internal links
+    - Pure Lisp implementation (no Emacs subprocess)
+*** DONE Expose Structural AST Editing Tools
+    - Wrap org-skill-emacs-edit into def-cognitive-tool definitions
+    - Force LLM to use semantic node updates instead of regex file I/O
+*** DONE Implement Reflection Loops
+    - Feed rejection traces (syntax errors, policy blocks) back to LLM to trigger self-correction
+*** DONE Harden Actuators
+    - Fix path-traversal vulnerabilities in file I/O tools (e.g. :write-file)
+    - Enforce Merkle-snapshots on all state-modifying actions
+*** DONE Implement tool permission tiers (ask/allow/deny)
+    - Per-tool permission plist stored in org-object
+    - =generate-tool-belt-prompt= filters denied tools before LLM sees them
+    - Ask-tier prompts user before execution
+*** DONE Implement skill hot-reload (=:reload-skill= tool)
+    - Swap compiled skill files without breaking active sockets
+    - Reload skill into jailed package namespace
+    - DONE: Added :reload-skill, :read-file, :write-file, :replace-string tools
+    - DONE: Fixed ASDF compilation bug (position tracking issue with :serial t)
+    - DONE: Added explicit :depends-on declarations to opencortex.asd
+
+** DONE Engineering Process Improvements [2026-04-23 Wed]
+*** DONE Fix ASDF compilation bug (position tracking at byte 16834)
+    - Root cause: Duplicate proto-get, bt: prefix issues, :serial t position cache
+    - Fix: Removed duplicate, fixed bt:->bordeaux-threads, explicit dependencies
+    - Added eval-when wrapper for new tools (good Lisp practice)
+*** DONE Add test-first methodology to engineering standards
+    - Rule 10: Test-first - design tests before coding, run chaos testing
+    - Rule 11: Org as thinking medium - document investigations in prose
+    - Rule 12: Engineering decision audit trail - document root cause, tradeoffs
+    - Added to opencortex-contrib/skills/org-skill-engineering-standards.org
+*** DONE Perform comprehensive architectural review and evolution strategy [2026-04-27 Mon]
+    - Identified hidden gaps: Org-mode round-trip, sandboxing vulnerabilities, and GC scaling.
+    - Defined "Structural AST Editing" and "Reflection Loops" as core strategic requirements.
+    - Captured findings in [[file:notes/opencortex-architectural-evolution.org][opencortex-architectural-evolution.org]].
+*** DONE Fix API drift in opencortex-contrib [2026-04-27 Mon]
+    - Standardized legacy keywords (:neuro/:symbolic) to new harness standard (:probabilistic/:deterministic).
+    - Updated 16 skills in opencortex-contrib for kernel compatibility.
+
+** DONE 4. Core Skills Consolidation [2026-04-23 Thu]
+    - Merged lisp-validator + lisp-repair → org-skill-lisp-utils.org
+    - Added lisp utilities: count-char, deterministic-repair, neural-repair
+    - Added validation: structural, syntactic, semantic checks
+    - Moved org-skill-self-fix from contrib → core
+    - Moved org-skill-engineering-standards from contrib → core
+    - Deleted old org-skill-lisp-validator.org
+
+** DONE 5. Advanced CLI Onboarding Experience
+*** DONE Implement interactive Lisp CLI wizard (=opencortex setup=)
+*** DONE Implement =opencortex gateway link= for Telegram/Signal bot connection [2026-05-02 Sat]
+*** DONE Implement =opencortex gateway unlink= to disable a gateway [2026-05-02 Sat]
+*** DONE Implement =opencortex gateway list= to show gateway status [2026-05-02 Sat]
+*** DONE Implement =opencortex install <skill>= for dynamic skill downloading [2026-05-02 Sat]
+*** DONE Implement =opencortex doctor= for environment health and API key validation [2026-04-28 Tue]
+    - Verified 22/22 skills loading with clean boot.
+    - Fixed macro conflicts and package jailing bugs.
+
+** DONE Chaos-Driven Bug Fixes (v0.2.0 Pre-Release) [2026-04-28 Tue]
+   - Fixed major conflict between Type A and Type B def-cognitive-tool macros.
+   - Enforced dynamic-only loading by removing skills from opencortex.asd.
+   - Fixed let/let* sequential binding bugs in emacs-edit and self-edit.
+   - Standardized *cognitive-tools* as a centralized hash table.
+   - Resolved missing in-package declarations in core skills.
+
+** DONE 1. Common Lisp TUI Implementation [2026-04-28 Tue]
+*** DONE Integrate =croatoan= for native terminal rendering
+*** DONE Implement scrollable history viewport for chat and thought streams
+*** DONE Implement fixed bottom input box with multi-line support and command history
+*** DONE Implement persistent status bar for background workers (Scribe/Gardener)
+*** DONE Support syntax highlighting for Lisp code blocks and Org-mode syntax
+
+** DONE 2. Slash Commands & Interactive Control [2026-04-28 Tue]
+*** DONE Implement =/help= command for system overview
+*** DONE Implement =/exit= and =/clear= commands
+*** DONE Implement =/skill-load <name>= for dynamic hot-reloading
+*** DONE Implement =/status=, =/config=, =/search=, =/commit= slash commands
+
+** DONE 3. Direct Lisp-to-Terminal Actuation [2026-04-28 Tue]
+*** DONE Refactor the =:cli= actuator to use native TUI rendering
+
+** DONE 4. Persistent REPL for Interactive Development [2026-04-30 Thu]
+*** DONE Implement org-skill-repl for persistent Lisp evaluation
+    - repl-eval: evaluate code with result+output+error separation
+    - repl-inspect: inspect variables and functions
+    - repl-list-vars: list bound symbols in package
+    - repl-load-file: load files into image
+    - Supports REPL-first workflow with literate reflection in org
+
+* PHASE: EVENT ORCHESTRATION + HITL (v0.3.0)
+:PROPERTIES:
+:ID:       proj-orchestration-v0-3-0
+:END:
+Unified control plane: hooks + cron + routing in one skill. Deep project understanding.
+
+** TODO 0. Project Renaming (Bouncer → Dispatcher)
+*** TODO Audit all files for component names to rename
+*** TODO Rename org-skill-bouncer.org → org-skill-dispatcher.org
+*** TODO Rename skill-bouncer package → skill-dispatcher
+*** TODO Rename cognitive tool =:bouncer= → =:dispatcher=
+*** TODO Update all references in harness, skills, documentation
+*** TODO Update gtd.org and ROADMAP.org terminology
+*** TODO Update DESIGN_DECISIONS.org section if applicable
+*** TODO Verify all tests pass after rename
+:LOGBOOK:
+- State "TODO"       from "" [2026-05-01 Fri 15:40]
+:END:
+
+The Dispatcher's role has evolved beyond security guard. It is the seed of the deterministic engine - it learns to execute procedures without invoking the neural net.
+
+** TODO 1. Event Orchestrator (unified hooks+cron+routing)
+*** TODO Integrate contrib org-skill-event-orchestrator
+    - Merge *hook-registry* + *cron-registry* + complexity classifier
+    - Hooks via =#+HOOK:= Org-mode properties
+    - Three complexity tiers: =:REFLEX= (no LLM), =:COGNITION= (light LLM), =:REASONING= (full LLM)
+    - Hook into heartbeat for cron processing
+
+** TODO 2. Context Manager (project scoping)
+*** TODO Integrate contrib org-skill-context-manager
+    - Stack-based context with =push-context= / =pop-context=
+    - Path resolution relative to current context
+    - Memory scope: =:scope= property on org-objects (memex/session/project)
+    - Implement lazy-loading proxies for large-scale memory traversal (offload cold nodes to disk)
+
+** TODO 3. Model-Tier Routing (cost optimization)
+*** TODO Extend =*model-selector-fn= for complexity-based routing
+    - Heartbeats → smallest model
+    - User input → medium model
+    - Complex reasoning → large model
+    - Source: GBrain sub-agent model routing
+
+** TODO 4. Memory Scope Segmentation
+*** TODO Extend org-object with =:scope= property
+    - =:memex= (permanent knowledge)
+    - =:session= (ephemeral context)
+    - =:project= (scoped to current work)
+    - Scope-aware retrieval in memory.lisp
+
+** TODO 5. Asynchronous Embedding Gateway
+*** TODO Implement provider-agnostic org-skill-embedding-gateway
+    - Support Ollama, llama.cpp, and OpenAI based on .env config
+    - Implement lazy-loading: edits mark nodes as =:vector :pending=
+    - Background worker thread batches pending nodes and updates Merkle tree silently
+
+** TODO 6. Slash Commands (TUI ergonomics)
+*** TODO M-x style command palette
+*** TODO /- prefix for command mode
+*** TODO Commands defined in Org-mode
+
+* PHASE: LONG-HORIZON PLANNING + GIT WORKFLOWS (v0.4.0)
+:PROPERTIES:
+:ID:       proj-planning-v0-4-0
+:END:
+Multi-step task mastery, structured tracking with failure handling and course correction.
+
+** TODO 0. Long-Horizon Planning (task tree DAG)
+*** TODO Implement org-skill-long-horizon
+    - Decompose complex tasks into Org-mode headline trees
+    - Terminal states: =:todo= → =:next-action= → =:in-progress= → =:done= / =:blocked= / =:stuck=
+    - Parent summarises child results
+    - Branch pruning when paths fail
+    - Source: Claude Code ULTRAPLAN (reimplemented in Lisp)
+
+** TODO 1. Git Steward (version control integration)
+*** TODO Integrate contrib org-skill-git-steward
+    - Status, diff, commit, push, branch operations
+    - Policy: commit-before-modify gate (from contrib engineering-standards)
+    - Log commits to memory
+
+** TODO 2. TDD Runner Integration
+*** TODO Integrate contrib org-skill-tdd-runner
+    - Run FiveAM tests on file save
+    - Inject =:test-failure= event on red
+    - Hook into self-fix for auto-repair proposals
+
+** TODO 3. Deep Emacs Integration
+*** TODO Full org-agenda awareness
+    - Navigate, clock time, refile, archive
+    - Uses org-element + org-id
+
+* PHASE: INTERACTIVE ACTUATION & ENVIRONMENT STEWARDSHIP (v0.5.0)
+:PROPERTIES:
+:ID:       proj-actuation-v0-5-0
+:END:
+Interactive terminal sessions and autonomous dependency management.
+
+** TODO 0. Interactive PTY Actuator
+*** TODO Stream long-running process output to the context window (e.g., `npm run dev`, REPLs)
+*** TODO Implement async interrupt control (Ctrl+C emulation)
+
+** TODO 1. The Environment Steward
+*** TODO Autonomously detect missing dependencies (e.g., "Command not found")
+*** TODO Propose an installation command and retry the failed action
+
+* PHASE: CREATOR + ARCHITECT + GTD (v0.6.0)
+:PROPERTIES:
+:ID:       proj-creator-v0-5-0
+:END:
+Agent bootstraps itself: creates skills autonomously, designs projects from PRDs, tracks work.
+
+** TODO 0. Skill Creator (autonomous skill generation)
+*** TODO Integrate contrib org-skill-creator
+    - LLM drafts complete skill org-file from natural language
+    - Mandatory: syntax validation → jail-load → test → register
+
+** TODO 1. Architect Agent (PRD → PROTOCOL)
+*** TODO Integrate contrib org-skill-architect
+    - Scan =:STATUS: FROZEN= PRDs
+    - Generate Phase B PROTOCOL from Phase A
+    - Write to same file
+
+** TODO 2. GTD Integration (project tracking)
+*** TODO Integrate contrib org-skill-gtd
+    - Full GTD cycle: capture, clarify, organize, reflect, engage
+    - org-gtd v4.0 DAG (=:TRIGGER:=, =:BLOCKER:=)
+
+** TODO 3. Consensus Loop (multi-model agreement)
+*** TODO Integrate contrib org-skill-consensus
+    - Run multiple providers for critical decisions
+    - Compare results, detect disagreements
+    - Confidence scoring
+
+** TODO 4. Web Research (Playwright browsing)
+*** TODO Integrate contrib org-skill-playwright + org-skill-web-research
+    - Headless Chromium via Python bridge
+    - Text extraction and screenshots
+    - Gemini Web UI automation
+
+** TODO 5. Memex Management (PARA lifecycle)
+*** TODO Integrate contrib org-skill-memex + org-skill-workspace-manager
+    - Archive DONE tasks, suggest refiling
+    - Detect orphaned nodes
+    - PARA/Zettelkasten maintenance
+
+* PHASE: VISUAL GROUNDING & MCP BRIDGE (v0.7.0)
+:PROPERTIES:
+:ID:       proj-vision-v0-7-0
+:END:
+Multimodal visual interaction and ecosystem-wide tool compatibility.
+
+** TODO 0. Computer Use / Vision
+*** TODO Allow the agent to request host OS or browser screenshots
+*** TODO Analyze UI and issue precise X/Y coordinate click/type commands via an X11/Wayland bridge
+
+** TODO 1. MCP Gateway Bridge
+*** TODO Build a Lisp-native client for the Model Context Protocol
+*** TODO Connect OpenCortex to external tools and data sources
+
+* PHASE: THE EVALUATION HARNESS (v0.8.0)
+:PROPERTIES:
+:ID:       proj-eval-v0-8-0
+:END:
+Automated benchmarking to mathematically prove the agent's reasoning capabilities.
+
+** TODO 0. SWE-Bench Harness
+*** TODO Automated pipeline that clones repositories and feeds GitHub issues
+*** TODO Track multi-step resolution trajectory, run tests, and score success
+
+* PHASE: SOTA PARITY (v1.0.0)
+:PROPERTIES:
+:ID:       proj-sota-v1-0-0
+:END:
+Feature-complete agent competitive with commercial agents. All borrowed concepts reimplemented in pure Lisp.
+
+All features from v0.2.0 through v0.8.0 combined, verified, and tested end-to-end.
+
+| Area | Parity Target |
+|------|--------------|
+| Self-improvement | Claude Code self-debug |
+| Planning | ULTRAPLAN equivalent |
+| Tool ecosystem | 10+ cognitive tools |
+| Context window | Semantic search + scope segmentation |
+| Safety | 6 Policy invariants + formal verification |
+| Multi-step tasks | Task trees with terminal states |
+| Code editing | Full file read/write via org manipulation |
+| Memory | Vector recall in org-object |
+| Emacs integration | Full org-mode control (exceeds Claude Code) |
+| Autonomy | 100% local capable (exceeds Claude Code) |
+
+* PHASE: LISP MACHINE EMERGENCE (v2.0.0)
+:PROPERTIES:
+:ID:       proj-lisp-v2-0-0
+:END:
+From Lisp-using agent to true Lisp machine. Agent IS the Emacs process.
+
+** TODO Lish: Lisp editor as Org-mode IDE
+    - Org-babel for interactive Lisp evaluation
+    - Full REPL in TUI
+    - No bridge needed — direct memory access
+** TODO Lish: Shell replacement
+    - Lisp-based shell that speaks plists
+    - Org-mode buffers as file system
+    - No bash dependency
+
+* PHASE: NEUROSYMBOLIC MATURITY (v3.0.0)
+:PROPERTIES:
+:ID:       proj-neuro-v3-0-0
+:END:
+Deterministic planner takes the wheel. LLM relegated to semantic translation.
+
+** TODO Deterministic planner
+    - Planner as pure Lisp function
+    - No LLM needed for scheduling
+    - Generates task graphs without probabilistic inference
+** TODO Self-correcting gates
+    - Gates learn from false positives (user override patterns)
+    - Adaptive threshold adjustment
+
+* PHASE: AI STACK INTERNALIZED (v4.0.0)
+:PROPERTIES:
+:ID:       proj-ai-v4-0-0
+:END:
+The agent understands its own weights. No external inference.
+
+** TODO Llama.cpp in Lisp
+    - FFI binding to llama.cpp
+    - No Python subprocess
+    - Pure Common Lisp inference
+** TODO Weights as sexps
+    - Neural weights represented as Lisp data structures
+    - Homoiconic model introspection
+
+* PHASE: TRUE AGENCY (v5.0.0)
+:PROPERTIES:
+:ID:       proj-agency-v5-0-0
+:END:
+World models, temporal reasoning, goal persistence across restarts.
+
+** TODO World models
+    - Agent builds predictive models of user behavior
+    - Project dynamics awareness
+    - System state forecasting
+** TODO Temporal reasoning
+    - Scheduling and deadline awareness
+    - Elapsed duration tracking
+    - Calendar integration
+** TODO Goal persistence
+    - Goals survive restarts
+    - Long-term projects tracked in org-objects
+    - Cross-session continuity
+
+* PHASE: EVOLUTIONARY ROADMAP (Previous — Superseded by Critical Analysis)
+:PROPERTIES:
+:ID:       proj-old-roadmap
+:END:
+Superseded by the critical analysis-informed roadmap above (v0.2.0 through v5.0.0). This section kept for historical reference.
+
+** TODO v0.1.0: The Autonomous Foundation (Current Release) — Now COMPLETE
+** TODO v1.0.0 (Phase 2.5): The Verified Wrapper (SOTA Parity) — Now v1.0.0
+** TODO v2.0.0 (Phase 3): Cannibalizing the Toolchain — Now v2.0.0
+** TODO v3.0.0 (Phase 4): True Symbolic Determinism — Now v3.0.0
+
+* PHASE: FOUNDATION (Complete)
+** DONE Draft Swank/Socket communication protocol between CL and Emacs
+:PROPERTIES:
+:CREATED: [2026-03-22 Sun 14:00]
+:ASSIGNED: Agent
+:END:
+** DONE Implement core Perceive-Think-Act loop in Common Lisp
+:PROPERTIES:
+:CREATED: [2026-03-22 Sun 14:00]
+:ASSIGNED: Agent
+:END:
+** DONE Implement Persistent Object-Store for Org entities in CL
+:PROPERTIES:
+:CREATED: [2026-03-22 Sun 16:30]
+:ASSIGNED: Agent
+:END:
+** DONE Implement LLM Connector (Probabilistic Engine) in CL Daemon
+:PROPERTIES:
+:CREATED: [2026-03-22 Sun 17:30]
+:ASSIGNED: Agent
+:END:
+** DONE Design Deterministic Engine Heuristics (Lisp logic over Memory)
+:PROPERTIES:
+:CREATED: [2026-03-22 Sun 17:30]
+:END:
+** DONE Achieve Phase 3: The Self-Editing Kernel
+:PROPERTIES:
+:CREATED: [2026-03-23 Mon 16:30]
+:END:
+- Jailing & Sandboxing implemented
+- Org-Native Skill Standard established
+- Telemetry & Introspection API active
+
+* PHASE: THE SOVEREIGN BOUNDARY (Core vs Skills Refactor)
+:PROPERTIES:
+:ID:       proj-autonomous-boundary
+:END:
+Slim down the opencortex microharness by moving non-essential cognitive functions to hot-reloadable user-space skills.
+
+** DONE Extract LLM Provider Routing to a Skill (neuro.lisp)
+** DONE Extract Vector Embedding Algorithms to a Skill (embedding.lisp)
+   CLOSED: [2026-04-12 Sun 14:10]
+   :PROPERTIES:
+   :ID: extract-embedding-skill
+   :END:
+   - Created `org-skill-embedding.org`.
+   - Moved logic to `src/embedding-logic.lisp` via tangling.
+   - Updated `system-definition.org`.
+** DONE Extract Sparse Tree Context Pruning Strategies to a Skill (context.lisp)
+   CLOSED: [2026-04-12 Sun 14:25]
+   :PROPERTIES:
+   :ID: extract-context-skill
+   :END:
+   - Created `org-skill-peripheral-vision.org`.
+   - Moved logic to `src/context-logic.lisp` via tangling.
+   - Updated `system-definition.org`.
+** DONE Implement `org-skill-peripheral-vision` (Moving embedding logic out of core)
+   CLOSED: [2026-04-12 Sun 14:25]
+   :PROPERTIES:
+   :ID: impl-peripheral-vision
+   :END:
+** DONE Implement communication protocol Schema Validation (Prevent reader macro injection in communication.lisp)
+   CLOSED: [2026-04-12 Sun 14:45]
+   :PROPERTIES:
+   :ID: communication-protocol-schema-validation
+   :END:
+   - Created `org-skill-protocol-validator.org`.
+   - Integrated `validate-communication-protocol-schema` into `communication.org`.
+   - Added `protocol-validator.lisp` to system definition.
+** DONE Implement Pluggable communication protocol Integrity Hashing (Core interface, Skill-based algorithms)
+   CLOSED: [2026-04-12 Sun 15:15]
+   :PROPERTIES:
+   :ID: communication-protocol-integrity-hashing
+   :END:
+   - Integrated HMAC-SHA256 (`ironclad:make-mac`) in `literate/communication.org`.
+** DONE Implement Native Lisp Merkle-Tree Versioning (Short-term undo buffer in memory.lisp)
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Performance: Implement Copy-on-Write (CoW) or Persistent Data Structures for Memory
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Feature: Implement Latent Reflection (Proactive Gardening) using heartbeat idle cycles
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Simplification: Refactor Cognitive Cycle into a Unified Reactive Signal Pipeline
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Resilience: Implement Micro-Rollbacks for the Immune System
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Implement `org-skill-memory-archivist` (Long-term IPFS checkpointing and P2P sync)
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Implement True Lisp Sandboxing (eval-safe mechanism in core and policy in skills)
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Decouple Vendor Logic from Probabilistic Engine (Move Google/Anthropic/OpenAI to Skills)
+   CLOSED: [2026-04-12 Sun 19:15]
+** DONE Component IV: Comprehensive Core Skill Audit (Review all 39 skills)
+   CLOSED: [2026-04-12 Sun 19:45]
+   :PROPERTIES:
+   :ID: core-skill-audit-task
+   :END:
+
+** DONE Consolidation I: Unified LLM Gateway (Anthropic, Gemini, Groq, OpenAI, etc.)
+** DONE Consolidation II: Credentials Vault (Secure Enclave & Masked Logging)
+** DONE Consolidation III: Homoiconic Memory (Unified Grammar, Bridge, & ID Generation)
+** DONE Consolidation IV: State Persistence Layer (Unified Local & IPFS Checkpointing)
+** DONE Consolidation V: Event Orchestrator (Unified Cron, Hooks, & Cognitive Routing)
+** DONE Consolidation VI: Task Orchestrator (Task Integrity, Delegation, & Consensus)
+   CLOSED: [2026-04-11 Sat 13:45]
+   :PROPERTIES:
+   :ID: task-orchestrator-consolidation
+   :END:
+   - Implemented Parallel Multi-Backend Consensus in neuro.lisp.
+   - Implemented Task Integrity (GTD semantics) in symbolic.lisp.
+   - Integrated Consensus Gate and Delegation hooks in core.lisp.
+   - Verified with new task-orchestrator-tests.lisp.
+** DONE Implement Unified Envelope Architecture & Channel-Awareness
+   CLOSED: [2026-04-20 Mon 13:20]
+   - Removed specialized :CHAT type; reverted to semantic :REQUEST/:EVENT protocol.
+   - Decoupled routing metadata into a :META envelope (SOURCE, SESSION-ID).
+   - Updated TUI, Emacs, and CLI gateways to use the unified protocol.
+   - Verified end-to-end loop with TUI; kernel correctly routes responses back to origin interface.
+   - Achieved "Equality of Clients" mandate.
+** DONE Full review of opencortex's harness
+   CLOSED: [2026-05-01 Fri 12:46]
+   :PROPERTIES:
+   :CREATED: [2026-04-13 Mon 13:30]
+   :ASSIGNED: Agent
+   :END:
+   - [X] Audit terminology: Replaced OACP with "communication protocol" workspace-wide.
+   - [X] Audit boot sequence: Synchronized loader with `org-skill-policy.org`.
+   - [X] Implement Unified Envelope (Channel-Aware Routing).
+   - [X] Audit core Perceive-Think-Act loop.
+     - [X] Verified protocol framing and reader jailing (`*read-eval* nil`).
+     - [X] Refactored `loop.org` for literate granularity and configuration externalization.
+     - [X] Improved error handling (restricted rollback) and added graceful shutdown.
+     - [X] **FIXED:** Implemented symbolic guard check in `act-gate` via Dispatcher skill refactoring.
+     - [X] **FIXED:** Harness `deterministic-verify` now correctly respects skill triggers.
+     - [X] **FIXED:** Resolved TUI crash by removing `--non-interactive` from `opencortex.sh` and adding defensive coordinate handling.
+     - [X] **VERIFIED:** Confirmed bidirectional TUI communication and signed off v0.2.0.
+   - [X] Ensure alignment with System Policy and Engineering Standards.
+   - [X] Restored structural integrity by fixing `manifest.org` loading sequence.
+
+** TODO Wake up the Scribe (Implement autonomous weekly Journal-to-Ledger distillation in org-skill-scribe.org)
+** TODO Implement `org-skill-lisp-repair` (Self-correcting syntax gate for Deterministic Engine)
+   CLOSED: [2026-04-11 Sat 15:10]
+   :PROPERTIES:
+   :ID: lisp-repair-gate
+   :END:
+   - Implemented asynchronous, event-driven repair logic.
+   - Decoupled core from repair logic (emits `:syntax-error` event).
+   - Proven via lisp-repair-tests.lisp (Asynchronous flow verified).
+** DONE Implement `org-skill-formal-verification` (Prove safety of high-impact actions)
+   CLOSED: [2026-04-11 Sat 18:15]
+   :PROPERTIES:
+   :ID: formal-verification-task
+   :END:
+   - Implemented `org-skill-formal-verification.org`.
+   - Created Lisp-Native Symbolic Prover for security invariants.
+   - Implemented `path-confinement` invariant (restricted to memex root).
+   - Implemented `no-network-exfil` invariant (blocking nc, ssh, etc).
+   - Verified with `formal-verification-tests.lisp`.
+
+* PHASE: DETERMINISTIC ENGINE REFINEMENT
+** DONE Verify Autonomous Self-Fix Loop
+   CLOSED: [2026-04-11 Sat 14:20]
+   :PROPERTIES:
+   :CREATED: [2026-03-23 Mon 16:30]
+   :END:
+   - Proven repair capability via self-fix-tests.lisp.
+   - Verified surgical code patching and hot-reloading.
+   - Documentation and RCA complete.
+** DONE Implement "Planning Mode" (Deterministic Engine Dispatcher) for Complex Actions
+   CLOSED: [2026-04-11 Sat 15:30]
+   :PROPERTIES:
+   :CREATED: [2026-04-01 Wed 17:00]
+   :END:
+   - Implemented `dispatcher-check` interceptor in `symbolic.lisp`.
+   - Created `org-skill-dispatcher.org` for flight plan serialization.
+   - Verified asynchronous Org-native approval loop via `dispatcher-tests.lisp`.
+** DONE Implement Authorization Gate (communication protocol) for "Planning Mode"
+   CLOSED: [2026-04-11 Sat 15:30]
+   :PROPERTIES:
+   :CREATED: [2026-04-01 Wed 17:00]
+   :END:
+   - Integrated with Org-mode state transitions (`PLAN` -> `APPROVED`).
+   - Leveraged Memory event bus for asynchronous re-injection.
+
+** DONE Refactor Architecture Terminology (Associative -> Probabilistic, Deliberate -> Deterministic)
+    CLOSED: [2026-04-12 Sun 21:00]
+    :PROPERTIES:
+    :ID: terminology-refactor-task
+    :END:
+    - Updated codebase-wide terminology to use Probabilistic/Deterministic Engines.
+    - Replaced System 1/2 with Probabilistic/Deterministic Engines respectively.
+
+** DONE Refactor org-skill-policy.org: Concrete Invariants, Conflict Hierarchy, and Auditable Gate
+    CLOSED: [2026-04-22 Wed 11:50]
+    :PROPERTIES:
+    :ID: policy-refactor-concrete-invariants
+    :END:
+    - Added explicit Override Hierarchy (Transparency > Autonomy > Bloat > Mentorship > Sustainability).
+    - Implemented `policy-check-transparency`: blocks user-facing actions without :explanation.
+    - Implemented `policy-check-autonomy`: flags proprietary domain references as autonomy debt.
+    - Implemented `policy-check-bloat`: warns on :create-skill actions exceeding size threshold.
+    - Implemented `policy-check-mentorship`: blocks high-impact actions missing :mentorship-note.
+    - Implemented `policy-check-sustainability`: logs cloud-provider usage as sustainability debt.
+    - Implemented `policy-explain`: formats auditable rationale for every policy decision.
+    - Implemented `policy-find-engineering-standards-gate`: robust cross-package search for standards skill.
+    - Hardened `policy-deterministic-gate`: never returns NIL silently; always returns action or auditable log.
+    - Raised skill priority from 100 to 500 to ensure it runs before other deterministic gates.
+
+** DONE Add Invariant 6 (Modularity) and Harness Boundary Contract to Policy/Manifest
+    CLOSED: [2026-04-22 Wed 12:10]
+    :PROPERTIES:
+    :ID: policy-modularity-invariant
+    :END:
+    - Added Modularity as Invariant 6 in `org-skill-policy.org`: general life principle that complexity must live at the edges.
+    - Implemented `policy-check-modularity`: blocks modifications to protected core paths unless `:modularity-justification` is provided.
+    - Defined `*modularity-protected-paths*` as project-configurable variable (defaults: harness/, opencortex.asd).
+    - Updated Override Hierarchy to include Modularity between Bloat and Mentorship.
+    - Added Harness Boundary Contract section to `harness/manifest.org` documenting primary boundary files and generated artifacts.
+    - Converted checkbox sub-tasks to hierarchical TODO headlines per GTD standard.
+
+** DONE Implement `org-skill-lisp-validator` (3-phase deterministic validation gate)
+    CLOSED: [2026-04-22 Wed 12:30]
+    :PROPERTIES:
+    :ID: lisp-validator-implementation
+    :END:
+    - Created 3-phase validation pipeline: Structural (O(n) paren scanner), Syntactic (reader with *read-eval* nil), Semantic (whitelist AST walk).
+    - Implemented `lisp-validator-validate` returning structured plists for machine parsing.
+    - Exposed `:validate-lisp` cognitive tool for Probabilistic Engine self-correction.
+    - Replaced `validate-lisp-syntax` in `harness/skills.org` with delegation to the validator.
+    - Added mandatory validation rule to Probabilistic Engine system prompt in `harness/reason.org`.
+    - Fixed paren balance and `return-from` compilation errors in org source; tangled and validated in SBCL.
+
+** DONE Fix Skill Loader to Respect `:tangle` Blocks and Eliminate Circular Dependency
+    CLOSED: [2026-04-22 Wed 12:45]
+    :PROPERTIES:
+    :ID: skill-loader-tangle-fix
+    :END:
+    - Updated `load-skill-from-org` in `harness/skills.org` to only collect blocks with `:tangle` directives pointing to runtime `.lisp` files, excluding `tests/` and `test/` paths.
+    - Added fallback to `validate-lisp-syntax` so it uses a basic reader check when `lisp-validator-validate` is not yet loaded (breaks circular harness->skill dependency).
+    - Verified full boot: 13/13 skills loaded successfully into SBCL, including `skill-lisp-validator` at priority 900 and `skill-policy` at priority 500.
+
+* TRACK: SECURITY & CONTAINMENT (The 5-Vector Dispatcher Matrix)
+** DONE Implement Path-Based Scoping for File Writes (DNA/State vs Work)
+   CLOSED: [2026-04-12 Sun 15:15]
+   :PROPERTIES:
+   :ID: path-based-scoping
+   :END:
+   - Implemented as `path-confinement` invariant in `org-skill-formal-verification.org`.
+** DONE Implement Network Exfiltration Gate (Intercept generic HTTP requests)
+   CLOSED: [2026-04-12 Sun 15:15]
+   :PROPERTIES:
+   :ID: network-exfiltration-gate
+   :END:
+   - Implemented as `no-network-exfil` invariant in `org-skill-formal-verification.org`.
+** TODO Implement Secret Exposure Gate (Intercept reads to .env, keys)
+
+* TRACK: INTELLIGENCE & ACTUATION (The Engines)
+** DONE Verify individual provider track (Anthropic, Gemini, Groq, OpenAI, OpenRouter, Ollama)
+   CLOSED: [2026-04-11 Sat 15:45]
+   :PROPERTIES:
+   :ID: provider-verification-track
+   :END:
+   - Added unit tests for each provider in `llm-gateway-tests.lisp`.
+   - Mocked `dex:post` to verify JSON payload formatting and response parsing.
+   - Implemented robust `get-nested` helper to handle various provider structures.
+   - Integrated `llm-gateway` and `credentials-vault` into `opencortex.asd`.
+** TODO Verify org-skill-shell-actuator formal safety harnesses
+** DONE Build Playwright-Python Bridge for high-fidelity browsing
+   CLOSED: [2026-04-11 Sat 18:30]
+   :PROPERTIES:
+   :ID: playwright-bridge-task
+   :END:
+   - Created `scripts/browser-bridge.py` (Playwright wrapper).
+   - Implemented `org-skill-playwright.org`.
+   - Registered `:browser` cognitive tool (JS-rendering, text extraction, screenshots).
+   - Updated `Dockerfile` with Python/Playwright dependencies.
+   - Verified with `playwright-tests.lisp`.
+
+
+* TRACK: COMMUNICATION & INTERFACES
+** DONE Implement org-skill-gateway-telegram
+   CLOSED: [2026-04-11 Sat 16:15]
+   :PROPERTIES:
+   :ID: gateway-telegram-task
+   :END:
+   - Implemented `org-skill-gateway-telegram.org`.
+   - Added automated background polling for Telegram GetUpdates.
+   - Implemented `:telegram` actuator for outbound responses.
+   - Refactored `org-skill-chat` to be channel-aware.
+   - Verified with `gateway-telegram-tests.lisp`.
+** DONE Implement org-skill-gateway-signal
+   CLOSED: [2026-04-11 Sat 16:50]
+   :PROPERTIES:
+   :ID: gateway-signal-task
+   :END:
+   - Implemented `org-skill-gateway-signal.org` (signal-cli wrapper).
+   - Added background polling for `signal-cli receive --json`.
+   - Implemented `:signal` actuator for outbound responses.
+   - Updated `org-skill-chat` to support Signal channel.
+   - Verified with `gateway-signal-tests.lisp`.
+** DONE Implement org-skill-gateway-matrix
+   CLOSED: [2026-04-11 Sat 17:15]
+   :PROPERTIES:
+   :ID: gateway-matrix-task
+   :END:
+   - Implemented `org-skill-gateway-matrix.org` (Client-Server API).
+   - Added background polling for `/sync` with token persistence.
+   - Implemented `:matrix` actuator for `m.room.message` delivery.
+   - Updated `org-skill-chat` to support Matrix channel and room IDs.
+   - Verified with `gateway-matrix-tests.lisp`.
+
+* TRACK: DEPLOYMENT & INFRASTRUCTURE
+** DONE Create Dockerfile and docker-compose.yml for containerized setup
+   CLOSED: [2026-04-11 Sat 17:30]
+   :PROPERTIES:
+   :ID: docker-infra-task
+   :END:
+   - Created `Dockerfile` (Debian-based, SBCL + Quicklisp + signal-cli).
+   - Created `docker-compose.yml` with host-volume mapping for memex.
+   - Created `docs/deployment.org` guide.
+** TODO Create Bare Metal installation scripts/playbooks
+** TODO Create LXC (Linux Containers) template/guide
+** TODO Create VM Vagrantfiles/Cloud-init configs
+
+* TRACK: MAINTENANCE & HYGIENE
+** TODO [RECURRING: Monthly] Review and test Infrastructure Dependency Upgrades
+   :PROPERTIES:
+   :ID: monthly-infra-audit
+   :REPEAT_TO_STATE: TODO
+   :END:
+*** TODO Check for new Debian security patches (`apt-get update` check)
+*** TODO Check for new `signal-cli` releases (compare vs v0.14.0)
+*** TODO Check for new Quicklisp distribution (monthly snapshot)
+*** TODO Verification: Update `Dockerfile`, run `docker-compose build --no-cache`, and execute full test suite
+*** TODO If all tests pass, commit updated `Dockerfile` and `.asd` dependencies
+
+* TRACK: COMMUNITY & DOCS
+** TODO Write Quickstart Guide
+** TODO Write Skill Creation Guide
+** TODO Write Architecture Deep-Dive
+** TODO Clean up GitHub repository structure and add CI/CD
+** TODO Create Marketing Material (Landing page copy, diagrams)
+** TODO Draft Release Plan checklist
+
+* SUB-PROJECT: THE BOOT SEQUENCE (skills.lisp)
+:PROPERTIES:
+:ID:       proj-skill-boot-sequence
+:END:
+** DONE Refactor `skills.lisp` into a Micro-Loader (Harness)
+   CLOSED: [2026-04-12 Sun 19:10]
+** DONE Implement Topological Sort based on `#+DEPENDS_ON:` tags
+   CLOSED: [2026-04-12 Sun 15:15]
+   :PROPERTIES:
+   :ID: topological-sort-skills
+   :END:
+   - Implemented in `literate/skills.org`.
+** DONE Enforce `org-skill-system-invariants` as the mandatory Gateway Skill (Loaded first)
+   CLOSED: [2026-04-12 Sun 15:15>
+   :PROPERTIES:
+   :ID: enforce-mandatory-skill
+   :END:
+   - Enforced in `initialize-all-skills` in `literate/skills.org`.
+** DONE Formalize the "Minimal Boot Set" (Router, Vision, Steward, Actuator)
+   CLOSED: [2026-04-12 Sun 19:10>

USER_MANUAL.md

@@ -1,55 +0,0 @@
-# OpenCortex v0.1.0 User Manual
-
-OpenCortex is a neurosymbolic AI agent designed for autonomous Memex maintenance. It combines the probabilistic power of Large Language Models with the deterministic safety of Common Lisp and the structured clarity of Org-mode.
-
-## 1. Quick Start
-
-Install and boot OpenCortex with a single command:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/gharbeia/opencortex/main/opencortex.sh | bash
-```
-
-Once installed, simply run `opencortex` to start the interactive CLI.
-
-## 2. The Core MVP Skills
-
-The v0.1.0 release includes the following essential skills:
-
-### Safety & Integrity
-*   **System Policy:** Enforces core invariants (Sovereignty, Transparency).
-*   **The Bouncer:** Inspects all proposed actions and blocks high-risk operations.
-*   **Protocol Validator:** Ensures communication integrity.
-
-### Cognitive Kernel
-*   **LLM Gateway:** Routes requests to your preferred provider (Gemini, Anthropic, etc.).
-*   **Peripheral Vision:** Manages context and retrieves relevant notes via Sparse Trees.
-*   **Memory Steward:** Maintains the live graph of your Org-mode Memex.
-*   **Credentials Vault:** Securely stores your API keys.
-
-### Interaction & Actuation
-*   **CLI Gateway:** The primary interface for chatting with your agent.
-*   **Shell Actuator:** Allows the agent to perform safe system side-effects.
-
-### Autonomous Services
-*   **The Scribe:** Automatically distills your daily chronological logs into structured notes.
-*   **The Gardener:** Proactively repairs broken links and flags orphaned nodes.
-
-## 3. Basic Usage
-
-### Chatting
-Type natural language messages into the CLI. The agent will perceive your intent, consult its Memory, and propose actions.
-
-### Memex Maintenance
-OpenCortex monitors your `daily/` directory. Use the Scribe to distill your thoughts:
-`User: Distill my notes from yesterday.`
-
-### Safety Approvals
-When the Bouncer intercepts a high-impact action, it will create a "Flight Plan" in your Memex. You must mark it as `APPROVED` before the agent proceeds.
-
-## 4. Configuration
-
-All configuration is stored in the `.env` file in your installation directory. You can update your API keys, change your Assistant's name, or modify the mandatory skill list there.
-
----
-*OpenCortex: The Conductor of your Life Stack.*

USER_MANUAL.org

@@ -0,0 +1,61 @@
+#+TITLE: OpenCortex User Manual
+#+AUTHOR: Agent
+#+STARTUP: content
+#+FILETAGS: :docs:manual:
+
+* Introduction
+Welcome to the OpenCortex User Manual. This guide provides the operational knowledge required to manage your sovereign Lisp Machine and its neural skills.
+
+* System Architecture
+OpenCortex follows a "Purified Kernel" model. The core harness handles essential I/O, while all high-level logic resides in sovereign skills.
+
+** XDG Directory Standard
+To ensure POSIX compliance, OpenCortex stores its files in standard Linux locations:
+
+| Type | Path | Purpose |
+| :--- | :--- | :--- |
+| **Config** | `~/.config/opencortex/` | User settings, `.env` secrets, and provider registry. |
+| **Data** | `~/.local/share/opencortex/` | Tangled Lisp artifacts and the compiled engine. |
+| **State** | `~/.local/state/opencortex/` | Brain snapshots, logs, and Merkle-memory. |
+| **Bin** | `~/.local/bin/opencortex` | The global CLI shim. |
+
+* Command Reference
+
+** `opencortex setup`
+The interactive configuration wizard. Use this to:
+- Define your identity and the Agent's name.
+- Register LLM providers (Ollama, Groq, Anthropic, etc.).
+- The wizard automatically splits sensitive tokens into `~/.config/opencortex/.env`.
+
+** `opencortex gateway link <platform> <token>`
+Connects OpenCortex to external communication gateways.
+- **Example:** `opencortex gateway link telegram <my_bot_token>`
+- **Example:** `opencortex gateway unlink telegram` to disable
+- **Example:** `opencortex gateway list` to see status
+
+** `opencortex doctor`
+Your primary diagnostic tool. Run this if the system feels sluggish or fails to boot. It verifies:
+- External dependencies (sbcl, git, socat).
+- XDG directory existence and permissions.
+- LLM connectivity.
+
+** `opencortex tui`
+Launches the native Lisp Terminal User Interface.
+- **Highlighting:** Semantic color-coding for Lisp and Org syntax.
+- **Scrolling:** Use `PgUp`/`PgDn` to navigate history.
+- **Exit:** Type `/exit` or `Ctrl+C` to close.
+
+* Configuration Strategy
+OpenCortex uses a **Hybrid Storage** model for maximum security and flexibility.
+
+** 1. Secrets (`.env`)
+Found in `~/.config/opencortex/.env`. This file stores raw API tokens. It is never automatically read by the Lisp structural parser to prevent accidental leakage into logs.
+
+** 2. Metadata (`providers.lisp`)
+Found in `~/.config/opencortex/providers.lisp`. This stores non-sensitive configuration like model names, base URLs, and user preferences as native Lisp S-expressions.
+
+* Troubleshooting
+If `opencortex doctor` reports a `FAIL`:
+1. Check that your `PATH` includes `/usr/bin` and `/usr/local/bin`.
+2. Ensure `sbcl` is installed.
+3. If LLM connectivity fails, verify your API key in `~/.config/opencortex/.env`.

deploy/bare-metal/install.sh

@@ -1,46 +0,0 @@
-#!/bin/bash
-# opencortex: Bare Metal Installation Script
-# This script sets up the opencortex daemon on a Linux host (Debian/Fedora).
-
-set -e
-
-echo "--- opencortex: Bare Metal Installation ---"
-
-# 1. Check Dependencies
-echo "[1/4] Checking dependencies..."
-for cmd in sbcl curl git ripgrep; do
-    if ! command -v $cmd &> /dev/null; then
-        echo "Error: $cmd is not installed. Please install it first."
-        exit 1
-    fi
-done
-
-# 2. Setup Quicklisp
-if [ ! -d "$HOME/quicklisp" ]; then
-    echo "[2/4] Quicklisp not found. Installing..."
-    curl -O https://beta.quicklisp.org/quicklisp.lisp
-    sbcl --non-interactive --load quicklisp.lisp --eval '(quicklisp-quickstart:install)'
-    rm quicklisp.lisp
-    echo "Quicklisp installed."
-else
-    echo "[2/4] Quicklisp already installed."
-fi
-
-# 3. Build standalone binary
-echo "[3/4] Building standalone binary..."
-PROJECT_ROOT=$(pwd)/../..
-sbcl --non-interactive \
-     --eval "(push \"$PROJECT_ROOT/\" asdf:*central-registry*)" \
-     --eval "(ql:quickload :opencortex)" \
-     --eval "(asdf:make :opencortex)"
-
-echo "Binary built: $PROJECT_ROOT/opencortex-server"
-
-# 4. Instructions for Systemd
-echo "[4/4] Installation complete."
-echo ""
-echo "To run as a systemd service:"
-echo "1. Edit opencortex.service to set correct paths."
-echo "2. sudo cp opencortex.service /etc/systemd/system/"
-echo "3. sudo systemctl daemon-reload"
-echo "4. sudo systemctl enable --now opencortex"

deploy/bare-metal/org-agent.service

@@ -1,18 +0,0 @@
-[Unit]
-Description=opencortex: Probabilistic-Deterministic Lisp Machine Kernel
-After=network.target
-
-[Service]
-Type=simple
-# Update User and WorkingDirectory to match your local setup
-User=amr
-WorkingDirectory=/home/amr/.openclaw/workspace/memex/5_projects/opencortex
-ExecStart=/home/amr/.openclaw/workspace/memex/5_projects/opencortex/opencortex-server
-Restart=always
-RestartSec=10
-
-# Environment variables can be loaded from the .env file
-EnvironmentFile=/home/amr/.openclaw/workspace/memex/5_projects/opencortex/.env
-
-[Install]
-WantedBy=multi-user.target

deploy/docker/Dockerfile

@@ -1,44 +0,0 @@
-FROM debian:bookworm-slim
-
-# Install SBCL, ripgrep, and build dependencies
-RUN apt-get update && \
-    apt-get install -y sbcl build-essential curl git ripgrep libsqlite3-dev lynx python3 python3-pip && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-# Install Quicklisp globally
-RUN curl -O https://beta.quicklisp.org/quicklisp.lisp && \
-    sbcl --non-interactive \
-         --load quicklisp.lisp \
-         --eval '(quicklisp-quickstart:install :path "/opt/quicklisp")' \
-         --eval '(ql-util:without-prompting (ql:add-to-init-file))' && \
-    rm quicklisp.lisp
-
-# Set up the working directory
-WORKDIR /app
-
-# Copy source code and system definition
-COPY opencortex.asd /app/
-COPY src/ /app/src/
-
-# Ensure we aren't using a stale binary from the host
-RUN rm -f /app/opencortex-server
-
-# Build the standalone binary natively inside the container
-# This ensures GLIBC compatibility with the runtime environment.
-RUN sbcl --non-interactive \
-         --eval '(push "/app/" asdf:*central-registry*)' \
-         --eval '(ql:quickload :opencortex)' \
-         --eval '(asdf:make :opencortex)'
-
-# Ensure the binary is executable
-RUN chmod +x /app/opencortex-server
-
-# Expose the communication protocol and Web Dashboard ports
-EXPOSE 9105 8080
-
-# The app expects the memex to be mounted here
-VOLUME /memex
-
-# Run the natively compiled standalone daemon
-CMD ["./opencortex-server"]

deploy/docker/docker-compose.yml

@@ -1,18 +0,0 @@
-version: '3.8'
-
-services:
-  opencortex:
-    build:
-      context: ../..
-      dockerfile: deploy/docker/Dockerfile
-    container_name: opencortex
-    restart: unless-stopped
-    ports:
-      - "${ORG_AGENT_DAEMON_PORT:-9105}:${ORG_AGENT_DAEMON_PORT:-9105}"
-      - "${ORG_AGENT_WEB_PORT:-8080}:${ORG_AGENT_WEB_PORT:-8080}"
-    volumes:
-      - /memex:/memex
-
-networks:
-  sandbox-net:
-    driver: bridge

deploy/guix/manifest.scm

@@ -1,14 +0,0 @@
-;; opencortex: Guix Environment Manifest
-;; Usage: guix shell -m manifest.scm -- sbcl --eval ...
-
-(specifications->manifest
- '("sbcl"
-   "sbcl-cl-json"
-   "sbcl-bordeaux-threads"
-   "sbcl-usocket"
-   "sbcl-dexador"
-   "sbcl-cl-ppcre"
-   "ripgrep"
-   "git"
-   "curl"
-   "sqlite"))

deploy/lxc/setup.org

@@ -1,33 +0,0 @@
-#+TITLE: LXC / Systemd-nspawn Deployment Guide
-#+AUTHOR: opencortex
-
-* Overview
-For users who prefer containerization without the overhead or dependency on the Docker daemon, `opencortex` can be run within a standard Linux Container (LXC) or a systemd-nspawn container.
-
-* Systemd-nspawn Setup (Fastest for Linux users)
-
-1. **Create the container root:**
-   #+begin_src bash
-   sudo debootstrap --arch=amd64 bookworm /var/lib/machines/opencortex
-   #+end_src
-
-2. **Start and enter the container:**
-   #+begin_src bash
-   sudo systemd-nspawn -D /var/lib/machines/opencortex
-   #+end_src
-
-3. **Install dependencies (inside container):**
-   #+begin_src bash
-   apt-get update && apt-get install -y sbcl curl git ripgrep libsqlite3-dev build-essential
-   #+end_src
-
-4. **Bind mount the Memex directory:**
-   Add this to your container startup or use the `--bind` flag:
-   #+begin_src bash
-   sudo systemd-nspawn -D /var/lib/machines/opencortex --bind /home/amr/.openclaw/workspace/memex
-   #+end_src
-
-* Proxmox LXC Setup
-1. Create a new LXC container using the Debian 12 template.
-2. Ensure the network is bridged so Emacs can reach it.
-3. Run the `deploy/bare-metal/install.sh` script inside the container.

deploy/vms/debian/Vagrantfile

@@ -1,22 +0,0 @@
-Vagrant.configure("2") do |config|
-  config.vm.box = "debian/bookworm64"
-  config.vm.network "forwarded_port", guest: 9105, host: 9105
-
-  config.vm.provider "virtualbox" do |vb|
-    vb.memory = "1024"
-    vb.cpus = 2
-  end
-
-  config.vm.provision "shell", inline: <<-SHELL
-    apt-get update
-    apt-get install -y sbcl curl git ripgrep libsqlite3-dev build-essential
-    
-    # Setup for opencortex
-    mkdir -p /home/vagrant/opencortex
-    cp -r /vagrant/* /home/vagrant/opencortex/
-    chown -R vagrant:vagrant /home/vagrant/opencortex
-    
-    # Build binary natively
-    sudo -u vagrant bash -c "cd /home/vagrant/opencortex && ./deploy/bare-metal/install.sh"
-  SHELL
-end

deploy/vms/fedora/Vagrantfile

@@ -1,21 +0,0 @@
-Vagrant.configure("2") do |config|
-  config.vm.box = "fedora/39-cloud-base"
-  config.vm.network "forwarded_port", guest: 9105, host: 9105
-
-  config.vm.provider "virtualbox" do |vb|
-    vb.memory = "1024"
-    vb.cpus = 2
-  end
-
-  config.vm.provision "shell", inline: <<-SHELL
-    dnf install -y sbcl curl git ripgrep sqlite-devel make gcc
-    
-    # Setup for opencortex
-    mkdir -p /home/vagrant/opencortex
-    cp -r /vagrant/* /home/vagrant/opencortex/
-    chown -R vagrant:vagrant /home/vagrant/opencortex
-    
-    # Build binary natively
-    sudo -u vagrant bash -c "cd /home/vagrant/opencortex && ./deploy/bare-metal/install.sh"
-  SHELL
-end

docker-compose.yml

@@ -1,19 +0,0 @@
-services:
-  opencortex:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: opencortex
-    env_file: .env
-    volumes:
-      # Mount the entire memex directory (2 levels up from projects/opencortex)
-      - ../..:/memex
-      # Ensure signal-cli state is preserved
-      - signal-state:/root/.local/share/signal-cli
-    ports:
-      - "${ORG_AGENT_DAEMON_PORT:-9105}:9105"
-      - "${ORG_AGENT_WEB_PORT:-8080}:8080"
-    restart: unless-stopped
-
-volumes:
-  signal-state:

docs/CHANGELOG.org

@@ -0,0 +1,36 @@
+#+TITLE: Changelog
+#+STARTUP: content
+
+* v0.2.0 - Interactive Refinement (2026-04-29)
+This release focuses on professionalizing the environment and enhancing the agent's structural capabilities.
+
+** Features
+- **Enhanced Lisp/Org Utilities:** Structural editing, REPL evaluation, and automated formatting to ensure code integrity.
+- **Namespace Standardization:** Refactored utilities into =utils-org= and =utils-lisp= for predictable discovery.
+- **Autonomous Mandates:** Implemented =GEMINI.md= for local agentic enforcement of engineering standards.
+- **Onboarding Wizard:** Modular Lisp setup for multiple LLM providers.
+- **Professional TUI:** Styled, scrollable interface with improved diagnostics.
+
+* v0.1.0 - The Autonomous Foundation (2026-04-20)
+This is the initial MVP release of the ~opencortex~. It establishes a secure, auditable Lisp kernel for a personal operating system.
+
+** Features
+- **Unified Envelope Architecture:** Actuator-agnostic protocol that decouples routing metadata from cognitive payloads, ensuring all clients (TUI, Emacs, CLI, Matrix) are treated as equal citizens.
+- **Metabolic Pipeline:** Robust Perceive-Reason-Act loop with selective memory rollbacks and graceful shutdown handling.
+- **Verification Lock:** Mandatory skill enforcement via environment configuration. System halts if security policies or bouncers fail to load.
+- **Foveal-Peripheral Context:** High-resolution focus on active tasks with low-resolution skeletal awareness of the rest of the Memex.
+- **The Bouncer:** Last-mile deterministic security gate with Deep Packet Inspection for secrets and network exfiltration.
+- **Autonomous Scribe:** Background distillation worker that turns daily journal entries into evergreen Zettelkasten notes. Verified to distill atomic concepts autonomously.
+- **Autonomous Gardener:** Heartbeat-driven worker that repairs broken links and identifies orphaned nodes in the Memex graph.
+- **Unified Onboarding:** Single-command installation (~opencortex.sh~) with Docker support, OS detection, and automated dependency resolution.
+- **Channel-Aware TUI:** Interactive Croatoan-based terminal client with clean, human-readable formatting for tool results and system logs.
+- **CLI Gateway:** Local TCP socket server for pipe-friendly interaction and frictionless first contact.
+
+** Licensing & Community
+- **AGPLv3 License:** OpenCortex is now officially licensed under the GNU Affero General Public License v3.0.
+- **Contributor License Agreement:** Implemented a broad CLA (~CLA.org~) for long-term project sustainability.
+
+** Architectural Shift
+- Transitioned to **Literate Granularity**: Every function and invariant is now formally documented in its own Org block.
+- **Provider Agnosticism:** Implemented a dynamic LLM cascade (OpenRouter, Ollama, etc.) removing all hardcoded backend dependencies.
+- **Thin Harness Philosophy:** Decoupled the kernel from specific editors or third-party gateways.

docs/CLA.org

@@ -0,0 +1,24 @@
+#+TITLE: OpenCortex Contributor License Agreement (CLA)
+#+STARTUP: content
+
+* Overview
+This Contributor License Agreement ("Agreement") clarifies the intellectual property license granted with Contributions from any person or entity to the OpenCortex project. 
+
+* 1. Definitions
+- *"You"* (or *"Your"*) means the copyright owner or legal entity authorized by the copyright owner that is making this Agreement with the Project Lead (Amr Gharbeia).
+- *"Contribution"* means any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to the Project Lead for inclusion in the Work.
+
+* 2. Grant of Copyright License
+Subject to the terms and conditions of this Agreement, You hereby grant to the Project Lead and to recipients of software distributed by the Project Lead a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute Your Contributions and such derivative works.
+
+* 3. Grant of Patent License
+Subject to the terms and conditions of this Agreement, You hereby grant to the Project Lead and to recipients of software distributed by the Project Lead a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work.
+
+* 4. You Represent That You Are Legally Entitled to Grant the Above License
+You represent that each of Your Contributions is Your original creation. You represent that Your Contribution submissions include complete details of any third-party license or other restriction of which You are personally aware and which are associated with any part of Your Contributions.
+
+* 5. Your Rights
+You retain all right, title, and interest in and to Your Contributions. This agreement simply grants the Project Lead the necessary rights to distribute the project (including under the AGPLv3 or any future commercial licenses).
+
+* 6. Agreement
+By submitting a Pull Request or patch to the OpenCortex repository, You explicitly agree to the terms of this Contributor License Agreement.

docs/CONTRIBUTING.org

@@ -0,0 +1,44 @@
+#+TITLE: Contributing to OpenCortex
+#+AUTHOR: OpenCortex Contributors
+#+STARTUP: content
+#+FILETAGS: :docs:contributing:
+
+* Philosophy
+OpenCortex is built on a "Zero-Bloat" mandate. The core kernel is mathematically pure, pushing all peripheral logic, API integrations, and routing to hot-reloadable "Skills".
+
+* Literate Granularity
+We strictly adhere to Literate Programming using Org-mode.
+- *Never* edit `.lisp` files in `src/` directly.
+- Modify the corresponding `.org` files in the `literate/` or `skills/` directories.
+- Run `org-babel-tangle` to generate the source code.
+- Every architectural decision, constraint, and implementation detail must be documented alongside the code in the `.org` file.
+
+* Skill Creation Standard
+Skills are the building blocks of OpenCortex. They reside in the `skills/` directory.
+
+A skill must define:
+1. *Trigger*: A lambda determining if the skill should activate based on the context.
+2. *Probabilistic Gate*: Optional. Generates a prompt for the LLM.
+3. *Deterministic Gate*: A hardcoded Lisp function that guarantees safety or executes side-effects (the "Bouncer" pattern).
+
+Example Registration:
+#+begin_src lisp
+(defskill :skill-example
+  :priority 100
+  :trigger (lambda (ctx) ...)
+  :probabilistic nil
+  :deterministic (lambda (action ctx) ...))
+#+end_src
+
+* The Unified Envelope (Communication Protocol)
+All inter-process communication occurs via the Unified Envelope. Do not use legacy specific types like `:CHAT`.
+- Always use semantic types: `:REQUEST`, `:EVENT`, `:RESPONSE`, `:STATUS`, `:LOG`.
+- Include routing metadata in the `:META` block (e.g., `(:SOURCE :TUI)`).
+- Ensure generated `:REQUEST` messages include a mandatory `:TARGET` field.
+
+* Pull Request Process
+1. Ensure your working tree is clean.
+2. Write tests for your skill in `tests/`.
+3. Tangle all files.
+4. Run the test suite: `sbcl --eval "(asdf:test-system :opencortex)"`.
+5. Submit a PR outlining the architectural intent and the specific Literate changes.

docs/DESIGN_DECISIONS.org

@@ -0,0 +1,339 @@
+# OpenCortex Design Decisions
+
+This document captures the rationale behind key architectural choices. It is not a specification - it is a thinking medium for future architects and contributors who need to understand why the system is built this way, not just how.
+
+* Multi-Agent by Default is a Smell
+:PROPERTIES:
+:ID:       design-multi-agent-default
+:END:
+
+The AI industry has developed an intuition toward multi-agent systems as the default solution to hard problems. Multiple agents spawn, delegate, coordinate, debate, and consensus their way toward solutions. This pattern is compelling in demos and genuinely useful in specific contexts - but it has become a default assumption that warrants scrutiny.
+
+When context windows grew expensive and task complexity increased, the response was natural: split the problem across agents, each handling a slice. But this architectural choice carries hidden costs that are rarely acknowledged in the enthusiasm of implementation.
+
+**The synchronization tax** is the most immediate burden. Each agent operates with partial information, and maintaining coherence requires continuous state reconciliation. Tokens and processing cycles are spent not on the task itself, but on protocol overhead - who holds what, who decided what, who is correct when they disagree.
+
+**Fragmented context** is the deeper problem. When Agent A writes a function and Agent B modifies a type it depends on, neither has the full picture. Integration failures emerge not from individual incompetence but from systemic communication gaps. Single-agent systems avoid this entirely: one brain holds the complete model, every decision is made with full visibility.
+
+**Audit trails become complex** in multi-agent systems. A decision traced through a single-agent system has a clean, linear history. A decision traced through a multi-agent system branches and forks, with each agent's reasoning partially overlapping and partially conflicting.
+
+None of this is to say multi-agent systems are never appropriate. Embarrassingly parallel workloads - scanning ten thousand files, processing batch jobs - benefit from parallelism regardless of context. When distinct expertises are required and cannot coexist in one model, delegation makes sense. In adversarial scenarios where conflicting goals are features, multi-agent architectures shine.
+
+But the default assumption that complex reasoning tasks are best solved by multiple agents is unproven and likely wrong for the engineering domain. Claude Code is a single-agent system. It handles 50-file refactors, debugs complex stack traces, writes tests, and navigates large codebases. The assumption that you need five agents to do what one well-designed agent can do is an industry habit, not a technical necessity.
+
+OpenCortex is single-agent by default not from limitation but from conviction: for reasoning-heavy work where coherence matters, a unified memory space and single decision-making locus are architectural assets, not constraints.
+
+* The Unified Memory Argument
+:PROPERTIES:
+:ID:       design-unified-memory
+:END:
+
+If single-agent architecture is the decision, unified memory becomes the mechanism that makes it viable. The critical question is not "how many agents" but "how does the agent manage context without saturating."
+
+Context window limits are largely a symptom of lazy architecture. The default approach - stuff everything in, hope the model figures it out - works poorly at scale. A more principled approach inverts the problem: the system should hold effectively infinite context, with the active window kept lean through intelligent management.
+
+**Lazy loading** is the core technique. When an agent needs information about a function, it does not load the entire codebase. It loads precisely what the function does. Context stays lean - 2,000 to 4,000 tokens - while the full context remains accessible through retrieval.
+
+**Compaction events** are scheduled during idle cycles. The system extracts new facts from active context and writes them to permanent storage. Active context is wiped clean, not because space ran out, but because the information has been preserved in a form that can be retrieved when relevant.
+
+**Org-mode as externalized memory** solves the persistence problem elegantly. Every decision, every note, every task lives in plain text files the user already owns. The agent does not maintain a separate database. It queries files it can already access, modifies files it already owns.
+
+**Retrieval is the key primitive.** Semantic search across Org files finds relevant nodes. The agent does not hold the full context - it holds pointers to context, loaded on demand. This is how a single agent handles tasks that would saturate a naive multi-megabyte context window.
+
+The unified memory argument is not that infinite context is free. It is that with proper architecture, effective infinite context is achievable without the synchronization and fragmentation costs of multi-agent systems.
+
+* The Probabilistic-Deterministic Split
+:PROPERTIES:
+:ID:       design-probabilistic-deterministic
+:END:
+
+The architecture divides cognition into two fundamentally different reasoning systems. This is not arbitrary engineering but a structural response to a fundamental truth: probabilistic systems will hallucinate, and you cannot build reliable autonomy on an unreliable foundation.
+
+An LLM is a statistical engine. It generates outputs based on patterns in training data. It is remarkable at translation, generation, pattern matching, and fuzzy reasoning. It can take messy human intent and produce structured queries. It can take structured results and produce natural language. It is, in the terminology of the system, the creative brain.
+
+But it cannot be trusted. Not because it is poorly designed or insufficiently trained, but because hallucination is a fundamental property of probabilistic inference. The model generates the most likely continuation, not the correct one. Given sufficient context, the most likely continuation is correct. Given novel context, it is often wrong in confident-sounding ways.
+
+The deterministic engine addresses this by being what the probabilistic engine is not: mathematically rigorous, formally verifiable, and incapable of hallucination by design. It operates on explicit symbolic representations - lists, property lists, knowledge graphs - not on floating-point activations. When it evaluates a path confinement check, it returns true or false, not a probability distribution.
+
+The division of labor is architectural. The LLM handles the fuzzy interface between human language and structured representation. It translates what the user wants into what the system can reason about. The deterministic engine receives those structured representations and evaluates them against formal invariants. It decides whether to execute, not whether the translation was semantically plausible.
+
+This separation is the source of OpenCortex's safety guarantee. Other agents add "guardrails" as an afterthought - a layer of filtering around a dangerous core. OpenCortex makes the division explicit: the LLM never touches the file system, never executes a command, never modifies memory. It generates proposals. The deterministic engine evaluates and executes. The dangerous operations are never in the probabilistic path.
+
+The split also explains why the system gets safer over time without the LLM improving. The deterministic engine accumulates rules. The LLM proposes actions, the engine evaluates them against a growing rule set. Early versions block obvious dangers. Later versions block sophisticated attacks that were previously unknown. The safety grows logarithmically with the number of interactions, not linearly with model capability.
+
+* Homoiconicity as Foundation
+:PROPERTIES:
+:ID:       design-homoiconicity
+:END:
+
+Common Lisp is homoiconic: code and data share the same representation. A Lisp program is a list, and a list is a Lisp program. This is usually presented as a curiosity, an interesting property that enables macros. In OpenCortex, it is the foundational enabling property of the entire self-modification architecture.
+
+When code is data, the agent can read its own source the same way it reads a text file or an Org buffer. There is no AST parser required, no external tool to extract the function object from the running image. The agent evaluates (read-from-string source) and the result is executable Lisp. The representation it manipulates is the same representation that the runtime executes.
+
+This is not true of most languages. In Python, the agent can inspect an AST through the ast module, but that AST is a foreign object - a data structure that represents code but is not code itself. The agent can see that a function takes certain arguments and returns a certain type, but it cannot treat the AST as a live object it can modify and re-evaluate. In C, the agent cannot inspect its own compiled machine code at all.
+
+In Lisp, the distinction between code and data is a convention, not a barrier. The agent's skills are lists. The agent can take a skill, extract a function definition, modify the body, wrap it in a new list, and evaluate it. The modification is surgical: it changes exactly what it intends to change, with no risk of corrupting adjacent state, because the representation is a tree that the runtime understands natively.
+
+Runtime introspection is therefore native. The agent does not need a debugger API or a reflection protocol. It operates on its own code as data because its own code is data. (describe 'function-name) returns the function's documentation. (function-lambda-list 'function-name) returns its parameters. (macroexpand-1 '(defskill ...)) shows what the macro produces. There is no impedance mismatch between the agent's reasoning and the system's representation.
+
+Self-modification is the practical consequence. The agent can detect an error, locate the erroneous function, generate a corrected version, and hot-reload it into the running image. The correction is not applied to a file that requires a restart - it is applied to the live object that the system is currently executing. This is what makes the self-editing skill viable: the agent can fix itself without stopping.
+
+In v3.0.0, when the symbolic engine takes over the reasoning core, homoiconicity becomes the bridge between the neural and symbolic layers. The neural engine generates proposals as s-expressions. The symbolic engine evaluates them against formal constraints. The result is a modification that is simultaneously a data structure the symbolic engine can analyze and code the runtime can execute. The two representations are identical by construction.
+
+This is the technical meaning of "Lisp as Governor": not just that Lisp orchestrates the other components, but that the representation of the system is uniform and inspectable at every level. There is no hidden state, no opaque machine code, no representation that the agent cannot reach into and modify. The system is legible to itself by design.
+
+**Self-Modification Without Boundaries**
+
+Other systems that support self-editing draw a line between the core and the skills. Hermes can modify its skills at runtime, but the core harness is protected - editing it requires a restart because the core is treated as privileged code that cannot be safely modified while running.
+
+OpenCortex has no such boundary. The "thin harness, fat skills" distinction describes where complexity lives, not where authority flows. The harness is small by design, but it is not privileged. The agent can read and write any part of the system - including the very code that is currently executing - without restarting.
+
+This is only possible because Lisp code is mutable data at runtime. In a compiled language, the machine code for a running function is locked in memory, protected by the call stack, impossible to modify safely. In Lisp, the function object is a list you can modify with =setf=. When the agent changes a harness function, the running image immediately reflects the change. The next invocation uses the new code. There is no restart, no special boot mode, no distinction between development and production.
+
+The implications extend beyond convenience. A system that cannot modify its own core is a system that has limits on its own adaptability. It can learn skills but not improve its own structure. It can grow but not evolve. OpenCortex's lack of a core boundary means the system can improve its own reasoning engine, fix bugs in its own cognition, and evolve its own architecture - all while continuing to operate.
+
+This is the final expression of homoiconicity: not just that code is readable as data, or that skills are modifiable, but that the entire system - including the parts that other systems protect - is open to modification. There is no ceiling on self-improvement. The agent can rewrite the very code that rewrites itself.
+
+**Lisp and the AI Dream**
+
+Lisp was invented in 1958 by John McCarthy with artificial intelligence explicitly in mind. Its design - code as data, runtime mutation, symbols and lists as first-class constructs - was shaped by the belief that a truly intelligent machine would need to reason about and modify its own reasoning. For decades, Lisp machines were the closest thing to thinking machines that existed.
+
+Then the AI winter came. Symbolic AI fell out of favor. Statistical learning and neural networks dominated. Lisp was relegated to niche applications and academic curiosity. The machine that was designed for AI was never used for the task it was designed for.
+
+Six decades later, neural networks have arrived at the problem from a different direction. They can learn and generalize, but they hallucinate, cannot explain their reasoning, and cannot safely modify themselves. The neuro-symbolic synthesis - combining neural pattern recognition with symbolic reasoning - is recognized as the path toward AI that is both powerful and trustworthy.
+
+Lisp's time may finally have come. Not as a replacement for neural networks, but as the governor that makes them safe - the symbolic engine that verifies what the neural engine proposes, the homoiconic substrate that allows the system to inspect, modify, and improve its own reasoning. The machine that was designed for AI in 1958 may be the exact machine needed for AI in 2026 and beyond.
+
+* Org-Mode as Unified AST
+:PROPERTIES:
+:ID:       design-org-unified-ast
+:END:
+
+OpenCortex makes a bet that most systems consider too expensive to place: that humans and machines should share the same file format. That bet is Org-mode.
+
+Most systems separate human-readable notes from machine-readable data. The user writes Markdown. The system stores it, indexes it, searches it. But internally, the system maintains its own model - a database, an object store, a knowledge graph - that is disconnected from the Markdown. When the user dies or leaves, the Markdown survives but the model must be reconstructed.
+
+OpenCortex refuses this separation. The Org file is not a representation of the data. The Org file IS the data. The same text that the user reads and edits is what the system parses and operates on. org-element reads an Org buffer and returns a tree structure that is the direct Lisp representation of the file's content.
+
+This has several profound implications.
+
+First, there is no translation layer between human and machine. When the agent writes a skill, it writes Org text that is immediately readable by the human who owns the file. When the human writes a note, it is immediately accessible to the agent as a native data structure. The communication is not mediated by a schema or an import/export process.
+
+Second, the format is genuinely readable by both parties, not just technically accessible. Org-mode's syntax is human-friendly: headlines begin with asterisks, properties live in drawers, tags are labels after colons. The human does not have to understand the full Org specification to read what the agent wrote. The agent does not have to handle edge cases in human notation.
+
+Third, the format is stable across decades. Org-mode has been in active development since 2003. The files written today will be readable by Org-mode in 2040. There is no schema migration, no database upgrade, no vendor lock-in. The human's notes survive the system.
+
+Fourth, the format is universally available. Org-mode is free software. The files are plain text. There is no proprietary format to decode, no application to purchase, no cloud service to access.
+
+Fifth, the format is header-aware and sparse-tree capable. Org-mode's headline hierarchy is not just formatting - it is a semantic structure the system can query. The agent can retrieve only the relevant subtree under a heading, ignoring the rest of the file. This is fundamentally different from Markdown, where the entire file must be loaded or the retrieval logic must parse and filter at the string level.
+
+Sparse tree retrieval is the key to efficient context management. When the agent needs information about the =openctl-db= function, it queries for the =openctl-db= subtree specifically. It receives exactly the code, documentation, and metadata under that heading - nothing more. The context stays lean not because the file was pre-split but because the retrieval is structural. In a Markdown system, the agent either loads the entire file (expensive, noisy) or relies on imprecise grep-like search (fragile, loses hierarchy). In Org-mode, retrieval is precise, hierarchical, and cheap. The heading boundary is the access boundary.
+
+Sixth, Org-mode unifies what every other format fragments. A single Org file contains the headline hierarchy, prose documentation, source code blocks with live evaluation, tags for categorization, metadata in property drawers, TODO state for task management, timestamps and deadlines, and links to other nodes. Markdown cannot express TODO state without external tools. JSON cannot contain prose. YAML cannot embed runnable code. Each format serves one purpose; Org-mode serves all of them. When the agent reads a skill file, it reads documentation, code, dependencies, metadata, and task state in one parseable structure. When the human reads the same file, they see the same information rendered in a human-friendly form. No other format achieves this unification without maintaining parallel files or external databases.
+
+Seventh, a skill lives in one Org file, not a directory. The standard pattern for a software project is a directory containing =README.md=, =package.json=, =src/main.py=, =src/utils.py=, =tests/test_main.py=, =scripts/deploy.sh=, and =config.yaml=. Each file type is isolated by convention: prose lives in README, code lives in src, tests in tests, configuration in config. This fragmentation means the skill is not a single object the system can reason about - it is a collection of files the system must assemble. OpenCortex's skills violate this convention deliberately. Each skill is one Org file. The file contains the skill's documentation, the skill's code, the skill's metadata, the skill's TODO state, and the skill's dependencies on other skills. There is no directory to navigate, no external files to locate, no risk that the README describes behavior that the code does not implement. The skill is a single atomic unit: readable by human and machine, editable by both, versionable as one entity.
+
+The unified format is what makes the memory architecture work. The agent's memory is not a database that the user cannot inspect. It is a folder of Org files that the user can read, edit, and understand. The agent manipulates these files directly, using the same tools the user would use. There is no hidden state, no shadow database, no model that differs from the source.
+
+This is what "sovereignty" means in technical terms: the user owns the data in a format they can access, and the agent operates on the data in the same format they own.
+
+* Literate Programming as Discipline
+:PROPERTIES:
+:ID:       design-literate-programming
+:END:
+
+The decision to use Org-mode as the source of truth for code, not just documentation, is not a ceremonial preference. It is a constraint mechanism that enforces better engineering habits at the cost of convenience.
+
+The traditional development workflow is: write code, write comments, commit. The literate programming workflow is: write prose, write code, commit the Org. The order matters. The prose must come first not because of style guidelines but because the act of explaining what a function does before writing it forces clarity of thought that editing code directly does not.
+
+When you must write a paragraph describing what a function does before you write the function, you discover the cases you have not considered. You find the edge conditions that are ambiguous. You realize that the function's name does not match its behavior, or that its behavior does not match your intent. The friction is not a bug - it is the mechanism by which thinking is enforced.
+
+The one-function-per-block rule enforces granularity. A function that cannot be explained in a paragraph is a function that is doing too much. The block boundary is not aesthetic - it is architectural. It prevents the drift toward monolithic functions that accumulate responsibilities over time and become untestable, unmaintainable, and incomprehensible.
+
+The tangle step enforces source-of-truth discipline. The .lisp file is generated from the Org file. This means the Org file cannot drift from the implementation. If the implementation changes, the Org must be updated to match. If the Org describes behavior that the implementation does not perform, the tangle produces code that does not match the Org description. Either way, inconsistency is visible and recoverable.
+
+The evaluation gate enforces correctness. Every block can be evaluated independently in a running Lisp image. This means syntax errors are caught at authorship time, not at integration time. The function that compiles in isolation but fails in context is the function whose context dependencies were never made explicit. The evaluation gate forces those dependencies to surface.
+
+Together, these constraints create a development experience that is slower in the small and faster in the large. Writing a new function takes longer because you must explain it. But debugging, maintaining, and extending the codebase is faster because every function has a human-readable explanation of its intent, every function is testable in isolation, and every function's source is always synchronized with its documentation.
+
+The literate programming discipline is not about producing documentation. It is about producing code whose correctness has been verified by the act of explaining it.
+
+* The Bouncer as Learning System
+:PROPERTIES:
+:ID:       design-bouncer-learning
+:END:
+
+The Bouncer begins as a static guard - a set of rules that block obviously dangerous actions. But defining "obviously" is the hard problem. The agent encounters situations the rules do not anticipate. The Bouncer must grow.
+
+The human-in-the-loop exception is the seed. When the LLM proposes an action the Bouncer does not recognize, the system does not default to blocking or allowing. It suspends. It writes the proposed action to an Org buffer in a format the human can read and understand. The human reviews and approves or denies. The Bouncer observes the decision.
+
+From this single observation, the Bouncer extracts a rule. Not merely "allow this specific action" but "allow this class of actions parameterized by these dimensions." The human approved a write to ~/projects/myapp/src/core.clj. The Bouncer generalizes: writes to ~/projects/*/src/*.lisp are approved for this session, or for this project, or indefinitely depending on the context and the user's pattern of decisions.
+
+Shadow mode is where rules are tested before deployment. When the Bouncer encounters a novel situation and is uncertain, it can run the proposed action in a simulated environment. It observes the side effects - what files would be modified, what processes would be spawned, what network calls would be made. If the simulation produces dangerous side effects, the rule is discarded. If it appears safe, the rule is added to the active set with a confidence rating.
+
+Formal verification is where the learned rules are checked against invariants. The Bouncer's rules are not merely patterns observed from human behavior. They are formulas in a logic that the system can reason about. A rule that would enable path traversal is not discarded because it was observed to be safe in prior instances - it is discarded because it violates the path-confinement invariant by construction.
+
+The Bouncer becomes, over time, not a guard that blocks bad actions but a reasoning system that understands why actions are good or bad. Early versions learn from human decisions. Later versions learn from their own logical analysis. The human's role transitions from approver to auditor to, eventually, unnecessary oversight.
+
+This is the bootstrap. The system begins dependent on human judgment because it has no basis for judgment of its own. Through accumulated decisions, it constructs a model of what is permitted and why. That model is the foundation for the deterministic symbolic engine that in v3.0.0 takes over the reasoning that the Bouncer learned to perform.
+
+* OpenCortex as a Function in Time
+:PROPERTIES:
+:ID:       design-trajectory
+:END:
+
+The system is not static. OpenCortex is defined not just by its current state but by its trajectory - how its cognitive architecture evolves over versions, with each phase reducing probabilistic surface area while increasing deterministic control.
+
+**v0.1.0: The Probabilistic Foundation**
+
+The agent begins by relying heavily on the neural engine. The LLM translates messy human intent into structured queries, generates code, proposes solutions. The Bouncer is present but thin - it blocks obviously dangerous actions, verifies path confinement, enforces basic invariants. Most reasoning is probabilistic because the symbolic infrastructure does not yet exist to do otherwise.
+
+At this stage, OpenCortex is similar to other LLM-based agents. The key difference is the gate is already there - the architecture assumes the LLM will hallucinate and structures safety accordingly.
+
+**v0.2.0 through v0.5.0: The Bouncer Learns**
+
+Each version expands the deterministic layer. The Bouncer writes rules from approved exceptions. Shadow mode runs trial executions. Tool permission tiers mature from simple allow/deny to nuanced context-aware policies. The agent becomes less likely to attempt dangerous actions not because it is smarter but because the guard has more complete information.
+
+This is the bootstrapping phase. The system learns by watching itself and its user. Every blocked action becomes a rule. Every approved exception becomes a pattern. The symbolic layer grows at the probabilistic layer's expense.
+
+**v0.6.0 through v0.7.0: The Architecture Crystallizes**
+
+Skills become more deterministic. The agent learns to write its own skills - first drafts generated by the LLM, but verified and refined by the symbolic engine. Self-editing improves. The REPL becomes a first-class cognitive substrate - code is not just written but verified, iterated, tested before committing.
+
+The balance shifts. The neural engine still translates and generates, but the symbolic engine checks, constrains, and corrects. The system is becoming what Gemini called "the strict guard" - a mathematically rigorous layer intercepting probabilistic output.
+
+**v1.0.0: SOTA Parity - The Probabilistic Ceiling**
+
+Achieving feature parity with commercial agents requires the full v0.x series complete. At this point, OpenCortex is a reliable autonomous agent - it can handle multi-step engineering tasks, maintain context across sessions, recover from errors, pass benchmarks. It is safer than alternatives because the Bouncer is mature and the memory architecture is sound.
+
+But it is still fundamentally probabilistic at its core. The symbolic engine verifies and constrains, but the generative engine is still the primary reasoning source.
+
+**v2.0.0: The Agent Becomes the Interface**
+
+This version is not about the symbolic engine - it is about tools. The agent stops running inside Emacs and starts replacing it. Lish (Lisp shell) emerges: a shell that speaks plists, not POSIX. Org-mode buffers become the file system. Org-babel becomes the REPL. The agent is no longer a passenger in Emacs - it is the operating system.
+
+The key insight is that the agent's interface and the agent's brain become the same thing. In earlier versions, there is a clear separation: the agent produces output, the TUI displays it. In v2.0.0, the distinction blurs. The agent's thoughts are displayed in Org buffers that are also the interface that the agent manipulates.
+
+This is the Emacs cannibalization phase. Not hostile replacement but evolution - Emacs was always a Lisp machine, and v2.0.0 completes the metamorphosis.
+
+**v3.0.0: The Symbolic Breakthrough**
+
+This is the architectural leap. The system transitions from "probabilistic engine with symbolic verification" to "symbolic engine with probabilistic input and output."
+
+The 10-80-10 architecture becomes fully realized: ten percent neural for input translation, eighty percent symbolic for reasoning against a knowledge graph, ten percent neural for output formatting. The symbolic engine maintains facts, relationships, rules, and formal proofs. When the neural engine generates something, the symbolic engine verifies it - not by checking against a blocklist, but by running the proposal through a Prolog/Datalog reasoner that understands the domain constraints.
+
+The deterministic planner takes the wheel. The LLM is no longer consulted for planning decisions - it translates human language to structured queries and structured results back to human language. The planning itself is pure Lisp: task graphs generated by a symbolic reasoner that has access to the full knowledge graph.
+
+Self-correcting gates replace the learned Bouncer rules. The system learns not just from approved exceptions but from the full history of outcomes - did the plan succeed? Where did it fail? The symbolic engine updates its own rules based on the results.
+
+The implications are significant. Hallucination becomes structurally impossible because the symbolic engine will not accept a fact that contradicts its knowledge graph. Safety becomes provable because the formal verification layer can prove properties about the system's behavior. Self-improvement becomes stable because the agent modifies skills that are then verified before execution.
+
+**v4.0.0 and Beyond: Hardware as the Final Constraint**
+
+The Lisp machine becomes physical. RISC-V with tagged architecture, hardware-enforced type checking, FPGA prototype for the symbolic core. The agent runs not in emulation but on silicon purpose-built for the architecture.
+
+This is the long horizon. The symbolic engine runs on logic ASICs optimized for symbolic computation. The neural engine runs on GPU or purpose-built matrix math hardware. Lisp orchestrates both, enforcing at the hardware level what it enforced at the software level in earlier versions.
+
+**The Trajectory as Design Principle**
+
+Understanding OpenCortex as a function in time is not nostalgia. It is architectural guidance. Every decision in v0.x should be made with awareness of where the system is going. Code written today becomes the substrate for v3.0. Skills designed today become the vocabulary the symbolic engine speaks tomorrow.
+
+The probabilistic beginning is not a weakness to overcome. It is the bootstrap. The system learns the domain through probabilistic inference, and that learned knowledge becomes the seed for the symbolic engine. By the time the symbolic engine takes over, it has a rich knowledge graph to reason about, grown from thousands of probabilistic interactions.
+
+This is how you build a reasoning machine: start with a learner, make it learn to verify, let verification become the core, remove the learner once it has learned enough.
+
+* The REPL as Cognitive Substrate
+:PROPERTIES:
+:ID:       design-repl-cognition
+:END:
+
+A REPL - Read, Eval, Print, Loop - is an interactive programming environment that reads an expression, evaluates it, prints the result, and loops back to read the next expression. It is the opposite of batch processing: where batch compiles and runs a program in one shot, a REPL works one expression at a time, with each evaluation building on all previous ones. The programmer defines a function, calls it, inspects the result, modifies it, and calls it again. The state accumulates. The session is the program.
+
+In Lisp, the REPL is not a debugging tool bolted onto the language - it is the natural mode of interaction. The running image is the environment. When you evaluate =(+ 2 2)=, the result =4= is printed, and you remain in the same image where =+= is defined, where previous definitions persist, where the next expression can reference anything that came before. There is no separation between development and execution. The REPL is not a simulation of the program - it is the program running.
+
+OpenCortex uses the REPL in this spirit, but elevated: it is not merely a tool for writing code, it is the mechanism by which the agent interacts with its own cognition - a loop that mirrors the perceive-reason-act metabolic cycle at the implementation level.
+
+In the agent's cognitive architecture, the REPL serves three functions that are difficult or impossible to achieve through batch processing or stateless API calls.
+
+First, the REPL enables verification before commitment. When the agent generates code, it does not write and forget - it evaluates in a running image, observes the result, iterates if incorrect. The feedback loop is tight: the time between writing and seeing the error is measured in milliseconds, not in the round-trip to a language server or a batch compiler. This is the "verification over hallucination" principle from the RLM paper made concrete: the agent tests what it writes before claiming it works.
+
+Second, the REPL enables stateful exploration. The agent can define a variable, inspect it, modify it, redefine it. The exploration accumulates state across interactions. This is not a debugging session - it is the agent thinking with its hands, working through a problem by trying variations and observing outcomes, keeping the successful ones and discarding the failures.
+
+Third, the REPL is a shared substrate. When the agent evaluates code, that code runs in the same image as the agent's own cognition. There is no process boundary between the agent and its tools. The REPL is not a subprocess the agent controls - it is a direct interface to the agent's own nervous system.
+
+This is why the REPL becomes more important as the system matures. In early versions, it is a development tool. In v0.6.0 and beyond, it becomes a cognitive tool: the agent explores hypotheses by evaluating them, verifies the output of sub-agents by inspecting live state, and tests modifications before committing them to the knowledge graph.
+
+* The Evaluation Harness
+:PROPERTIES:
+:ID:       design-evaluation-harness
+:END:
+
+SOTA parity is meaningless without measurement. A system that claims to match commercial agents must demonstrate it through reproducible benchmarks, not through feature checklists. The evaluation harness is the apparatus by which OpenCortex proves its capabilities.
+
+The industry standard for coding agents is SWE-bench: a corpus of GitHub issues paired with pull requests. The agent is given an issue, must understand the codebase, write a fix, and submit. Success is measured by whether the submitted PR passes the existing test suite. This tests the full chain: understanding, planning, code generation, verification, and multi-step reasoning.
+
+OpenCortex implements a native Lisp harness for this. A background thread clones repositories, feeds issues into the cognitive loop, tracks the resolution trajectory as an Org-mode headline tree, and scores success by test outcomes. The trajectory is persisted: when a resolution fails, the system can inspect where in the chain the reasoning broke down. The headline tree records the agent's thoughts at each step, making the failure auditable and the debugging human-assisted.
+
+Beyond SWE-bench, the harness includes chaos testing. The system is subjected to resource starvation, concurrent load, and adversarial input. The deterministic engine must maintain safety invariants under pressure. The symbolic verifier must not deadlock or livelock. The probabilistic engine must degrade gracefully - if tokens are limited, it must still produce valid proposals that the deterministic engine can evaluate. Failure under chaos is a design flaw, not a benchmark anomaly.
+
+The harness also supports regression testing on the skill set. Every skill is tested against a suite of known inputs and expected outputs. When a modification is proposed to any skill - whether through manual editing or the agent's own self-modification - the test suite runs first. A skill that fails its tests is rejected before it can propagate to the running image. This is not a convenience - it is the mechanism by which self-modification remains safe. The agent can propose changes, but the harness verifies them before the changes take effect.
+
+* Observability and the Thought Trace
+:PROPERTIES:
+:ID:       design-observability
+:END:
+
+When a human asks why the system made a decision, the answer must be findable. In most AI systems, the reasoning is ephemeral - it exists in the model's activations and disappears when the session ends. In OpenCortex, every significant cognitive event is written to an Org buffer as it happens.
+
+The thought trace is the agent's journal, written in parallel with its reasoning. When the probabilistic engine generates a proposal, the trace records the input, the prompt, and the raw output. When the deterministic engine evaluates it, the trace records which rules were checked, which passed, which failed, and why. When an action is executed, the trace records the timestamp, the user who approved it (if human-in-the-loop), and the outcome.
+
+This is not logging in the traditional sense. Logs are forensically useful but are written in a machine format optimized for storage, not for human reading. The thought trace is written in Org-mode: headlines for major events, property drawers for structured data, tags for categorization. The human can open the trace in Emacs and navigate it like any other Org file. They can search for a specific decision, filter by time range, find all actions blocked by a specific rule, or see the complete trajectory of a multi-step task.
+
+The trace becomes the foundation for the Bouncer's learning. Every blocked action is in the trace. Every approved exception is in the trace. The human-in-the-loop decisions are in the trace. The system does not need to reconstruct what happened - it reads what happened from the trace it wrote.
+
+Without observability, the system is a black box that happens to produce correct outputs sometimes. With observability, the system is auditable. The human can see why a decision was made, identify where the reasoning failed, and course-correct the system or its own behavior accordingly.
+
+* The MCP Strategy
+:PROPERTIES:
+:ID:       design-mcp-strategy
+:END:
+
+The Model Context Protocol (MCP) is a standard for connecting AI systems to external tools and data sources. It defines how a client requests tools from a server, how the server exposes its capabilities, and how the client invokes them. The ecosystem is growing: MCP servers exist for GitHub, Slack, Postgres, filesystem access, and much more.
+
+OpenCortex connects to this ecosystem, but not by becoming a Node.js runtime. The architecture is: external MCP servers communicate via stdio or SSE to a Lisp-native MCP client that runs in the same image as the agent. The client is pure Common Lisp - it parses the JSON-RPC messages, invokes the tools, and presents results to the agent as Lisp data structures. There is no serialization overhead between the agent and the MCP layer, no process boundary, no impedance mismatch.
+
+When the agent calls a tool via MCP, it receives a plist with the tool name, arguments, and result. The result is immediately usable by the agent's symbolic engine. When the agent generates a file, it can be written to the filesystem through an MCP filesystem server. When the agent needs to send a message, it can use an MCP Slack server. The agent does not need to know that these are MCP interactions - it sees only the plists that flow through its cognitive architecture.
+
+The alternative is to build MCP wrappers in Python or TypeScript and bridge to Lisp via subprocess. This is what OpenClaw does: a Node.js runtime that manages MCP servers, with a bridge to the Lisp process. The bridge introduces latency, serialization costs, and a maintenance burden. The Node.js process must be kept running. The bridge must be maintained across Lisp and JavaScript runtimes. The cognitive architecture must handle errors that cross the process boundary.
+
+OpenCortex's native client is smaller, faster, and more maintainable. The MCP client is a skill, not a core component. It can be reloaded, replaced, or removed without restarting the agent. The agent can add new MCP tool integrations by loading new skills, not by deploying new infrastructure.
+
+* Local-First Architecture
+:PROPERTIES:
+:ID:       design-local-first
+:END:
+
+OpenCortex is designed to run on the user's machine, on their hardware, with their data, without requiring an internet connection. This is not a deployment option - it is an architectural commitment. The system must be able to reason, plan, and act using only the resources available locally.
+
+The motivation is not merely philosophical. Cloud-based AI agents are economically incentivized to collect data, to train on user interactions, and to build lock-in through proprietary formats and network effects. When the agent runs locally, the user owns the hardware, owns the data, and can terminate the process without asking permission. There is no vendor that can change terms, no service that can go offline, no model that can be updated without consent.
+
+Technically, local-first means several things. The LLM must be able to run on local hardware. OpenCortex supports Ollama as a provider, which runs quantized models on CPU and GPU without requiring an external API. The vector database must be local. OpenCortex uses its own org-object store, which is a folder of Org files that the agent already owns. There is no ChromaDB or Qdrant to install, no cloud vector service to authenticate with.
+
+The symbolic engine does not require a network connection. The Prolog/Datalog reasoner that in v3.0.0 verifies neural proposals runs entirely in the Lisp image. The Bouncer's rule synthesis does not call an external service. The agent can operate in a disconnected environment indefinitely, resuming full capability when connectivity is restored.
+
+This does not mean OpenCortex refuses to use cloud services when available and appropriate. It means cloud services are optional enhancements, not architectural requirements. The core is local. The user can choose to add cloud LLM providers for more capable inference, but the system functions without them.
+
+* Zero-Dependency Deployment
+:PROPERTIES:
+:ID:       design-zero-dependency
+:END:
+
+The simplest deployment is one that requires no installation steps. The user downloads one file, runs it, and the system works. OpenCortex approximates this through SBCL's ability to produce standalone executables via save-lisp-and-die. The executable contains the Lisp runtime, the compiled system, and Quicklisp libraries - everything bundled into one binary.
+
+The practical reality is more nuanced. Building a truly standalone executable requires resolving all library dependencies at build time and embedding them in the binary. SBCL supports this, but the resulting binary is large (tens of megabytes), and updating any component requires a full rebuild. The current deployment model uses a Docker container that maps the user's memex directory as a volume. The container starts, loads the system, and is ready. No compilation on the user's machine, no dependency installation, no platform-specific quirks.
+
+The long-term goal is a single =opencortex= binary that the user runs. It starts a local web server on a Unix domain socket. The TUI connects through the socket. The user's Org files are in =~/memex/=. The binary is the only thing that needs to be installed.
+
+This stands in stark contrast to most AI agent systems, which require managing Python environments, npm packages, API keys, environment variables, and configuration files. OpenAI's agents SDK requires pip install, a Python environment, and external API access. OpenClaw requires Node.js, npm, and a plugin ecosystem that must be individually installed. LangChain requires a Python environment with dozens of dependencies that must be kept compatible.
+
+OpenCortex's dependency model is SBCL plus Quicklisp. Quicklisp loads libraries on demand from the internet, but caches them locally. A system with internet access can fetch any library it needs. A system without internet access uses only the libraries it has already loaded - and those are preserved in the cache. The agent does not require internet access to function after initial setup.

docs/ROADMAP.org

@@ -0,0 +1,171 @@
+#+TITLE: OpenCortex Evolutionary Roadmap
+#+STARTUP: content
+
+* The Evolutionary Roadmap
+
+The roadmap is designed working backwards from SOTA parity (V 1.0.0), guiding each version toward a fully autonomous, self-editing agent. Each version builds on the previous, with features designed to be implemented in pure Common Lisp + Org-mode.
+
+Per-version task tracking: [[file:../TODO.org][TODO.org]]
+
+** Non-Negotiable Identity
+- Pure Common Lisp + Org-mode. No JSON. No YAML. No external databases.
+- Single-address-space memory (Lisp hash tables in RAM — the agent IS the memory).
+- "Thin harness, fat skills" — complexity lives at the edges, not the kernel.
+- One agent composed of many skills. Concurrency via bordeaux-threads (shared memory).
+- Plists everywhere — homoiconic communication between all components.
+
+** Version Roadmap
+
+*** v0.1.0: The Autonomous Foundation — CURRENT RELEASE ✅
+
+The secure, auditable Lisp kernel. All core infrastructure in place.
+
+| Component                         | Status | Notes                                                                 |
+|-----------------------------------+--------+-----------------------------------------------------------------------|
+| Perceive-Reason-Act pipeline      | ✅     | 3-stage metabolic loop                                                |
+| Skills engine with jailed loading | ✅     | defskill, topological sort, hot-reload                                |
+| Policy skill (6 invariants)       | ✅     | Transparency, Autonomy, Bloat, Modularity, Mentorship, Sustainability |
+| Bouncer skill                     | ✅     | Command whitelist guard functions                                     |
+| Memory (org-object + Merkle)      | ✅     | Hash tables, snapshots, rollback                                      |
+| Lisp validator skill              | ✅     | Syntax validation before eval                                         |
+| Scribe + Gardener skills          | ✅     | Heartbeat-driven distillation + audit                                 |
+| LLM gateway (OpenRouter + Ollama) | ✅     | Provider cascade                                                      |
+| Shell actuator                    | ✅     | Safe command execution                                                |
+| Emacs bridge via Swank            | ✅     | Point/buffer updates                                                  |
+| FiveAM test suite                 | ✅     | Memory, boot, pipeline, act, communication                            |
+| Credentials vault                 | ✅     | Encrypted storage                                                     |
+
+*** v0.2.0: Interactive Refinement ✅
+
+The "Brain" meets the "Machine." Standardization and professionalization of the user interface and environment.
+
+| Feature              | Status | Notes                                                   |
+| :---                 | :---:  | :---                                                    |
+| Minimalist Kernel    | ✅     | Purified harness targeting I/O & Memory only.           |
+| Sovereign Skills     | ✅     | Diagnostics and Configuration extracted to Userland.    |
+| POSIX/XDG Compliance | ✅     | Standardized paths (~/.config, ~/.local).               |
+| Professional TUI     | ✅     | Styled, scrollable, and verified Lisp interface.        |
+| Onboarding Wizard    | ✅     | Modular Lisp setup for multiple LLM providers.          |
+| Linkage Command      | ✅     | Real-time verification of external gateways (Telegram). |
+| Self-Editing         | ✅     | Detects errors, applies fixes, learns from outcomes.    |
+| Enhanced Utilities   | ✅     | Structural Lisp/Org manipulation + REPL evaluation.     |
+| Memory Rollback      | ✅     | Snap back to known-good state on critical errors.       |
+
+*** v0.3.0: Event Orchestration + HITL
+
+Unified control plane and Human-in-the-Loop (HITL) state management.
+
+| Feature                        | Description                                                                                                                                               |
+|--------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| org-skill-event-orchestrator   | Unified hooks + cron + routing. Three tiers: =:REFLEX= (no LLM), =:COGNITION= (light LLM), =:REASONING= (full LLM).                                       |
+| Human-in-the-Loop (HITL)       | Continuation-based interaction. The agent can "suspend" its cognitive loop to ask for permission or clarification and resume precisely where it left off. |
+| org-skill-context-manager      | Stack-based project scoping. =push-context= / =pop-context=. Path resolution relative to context.                                                         |
+| Memory scope segmentation      | =:scope= property on org-objects: memex/session/project. Scope-aware retrieval.                                                                           |
+| Model-tier routing             | Complexity-based model selection: heartbeat → tiny, user → medium, reasoning → large.                                                                     |
+| Slash commands                 | =M-x= style command palette in TUI. Commands defined in Org-mode.                                                                                         |
+| Asynchronous Embedding Gateway | Provider-agnostic vector generation (Ollama, local llama.cpp) via background worker.                                                                      |
+| Telegram Gateway Skill         | Full implementation of the message receiver for linked Telegram bots.                                                                                     |
+
+*** v0.4.0: Long-Horizon Planning + Git Workflows
+
+Structured tracking, failure handling, and course correction for multi-step engineering work.
+
+| Feature                | Description                                                                                                                                 |
+|------------------------+---------------------------------------------------------------------------------------------------------------------------------------------|
+| org-skill-long-horizon | Decompose tasks into Org-mode headline trees. Terminal states: =:done= / =:blocked= / =:stuck=. Parent summarises children. Branch pruning. |
+| org-skill-git-steward  | Status, diff, commit, push, branch. Policy enforces commit-before-modify.                                                                   |
+| TDD runner             | FiveAM on file save. =:test-failure= events. Hook into self-fix for auto-repair.                                                            |
+| Deep Emacs integration | Full org-agenda awareness. Navigate, clock time, refile, archive.                                                                           |
+
+*** v0.5.0: Interactive Actuation & Environment Stewardship
+
+Interactive terminal sessions and autonomous dependency management.
+
+| Feature                  | Description                                                                                                                         |
+|--------------------------+-------------------------------------------------------------------------------------------------------------------------------------|
+| Interactive PTY Actuator | Stream long-running process output to the context window (e.g., `npm run dev`, REPLs) with async interrupt control.                 |
+| The Environment Steward  | Autonomously detect missing dependencies (e.g., "Command not found"), propose an installation command, and retry the failed action. |
+
+*** v0.6.0: Concurrency + Creator + GTD
+
+The agent bootstraps itself and manages parallel workstreams.
+
+| Feature                     | Description                                                                                                                           |
+|-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------|
+| org-skill-sub-agent-manager | Lightweight Lisp-native sub-agents (via bordeaux-threads) that share memory but have isolated execution contexts for background work. |
+| org-skill-creator           | LLM drafts complete skill org-file from natural language. Mandatory: syntax validation → jail-load → test → register.                 |
+| org-skill-architect         | Scan =:STATUS: FROZEN= PRDs. Generate Phase B PROTOCOL.                                                                               |
+| org-skill-gtd               | Full GTD cycle: capture, clarify, organize, reflect, engage. org-gtd v4.0 DAG (=:TRIGGER:=, =:BLOCKER:=).                             |
+| Consensus loop              | Run multiple providers for critical decisions. Compare results, detect disagreements.                                                 |
+| Web research                | Headless Chromium via Python bridge. Text extraction, screenshots, Gemini Web UI automation.                                          |
+
+*** v0.7.0: Visual Grounding & MCP Bridge
+
+Multimodal visual interaction and ecosystem-wide tool compatibility.
+
+| Feature               | Description                                                                                                                                                |
+|-----------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Computer Use / Vision | Allow the agent to request host OS or browser screenshots, analyze the UI, and issue precise X/Y coordinate click/type commands via an X11/Wayland bridge. |
+| MCP Gateway Bridge    | Lisp-native client for the Model Context Protocol, allowing OpenCortex to connect to the entire ecosystem of external tools and data sources.              |
+
+*** v0.8.0: The Evaluation Harness
+
+Automated benchmarking to mathematically prove the agent's reasoning capabilities.
+
+| Feature           | Description                                                                                                                                    |
+|-------------------+------------------------------------------------------------------------------------------------------------------------------------------------|
+| SWE-Bench Harness | Automated pipeline that clones repositories, feeds GitHub issues, tracks the multi-step resolution trajectory, runs tests, and scores success. |
+
+*** v1.0.0: SOTA Parity
+
+Feature-complete agent competitive with commercial agents. All features reimplemented in pure Lisp.
+
+| Area              | Status    | Notes                                     |
+|-------------------+-----------+-------------------------------------------|
+| Self-improvement  | ✅ v0.2.0 | Self-edit + lisp-repair                   |
+| Planning          | ✅ v0.4.0 | Task tree DAGs with terminal states       |
+| Tool ecosystem    | 🟡 v0.4.0 | 10+ cognitive tools                       |
+| Context window    | ✅ v0.3.0 | Semantic search + scope segmentation      |
+| Safety            | ✅ v0.1.0 | 6 Policy invariants + formal verification |
+| Multi-step tasks  | ✅ v0.4.0 | Task trees with failure handling          |
+| Code editing      | ✅ v0.2.0 | Full org-mode file read/write             |
+| Memory            | ✅ v0.2.0 | Vector recall in org-object               |
+| Emacs integration | ✅ v0.2.0 | Full org-mode control                     |
+| Autonomy          | ✅ v0.1.0 | 100% local capable (Ollama)               |
+
+*** v2.0.0: Lisp Machine Emergence
+
+From Lisp-using agent to true Lisp machine. Agent IS the Emacs process.
+
+| Feature | Description |
+|---------|-------------|
+| Lish: Lisp editor | Org-mode as IDE. Org-babel for interactive evaluation. Full REPL in TUI. No bridge needed. |
+| Lish: Shell replacement | Lisp-based shell that speaks plists. Org-mode buffers as file system. |
+
+*** v3.0.0: Neurosymbolic Maturity
+
+Deterministic planner takes the wheel. LLM relegated to semantic translation.
+
+| Feature | Description |
+|---------|-------------|
+| Deterministic planner | Pure Lisp task scheduler. No LLM needed for planning. |
+| Self-correcting gates | Gates learn from false positives (user override patterns). |
+
+*** v4.0.0: AI Stack Internalized
+
+The agent understands its own weights. No external inference.
+
+| Feature | Description |
+|---------|-------------|
+| Llama.cpp in Lisp | FFI binding. No Python subprocess. Pure Common Lisp inference. |
+| Weights as sexps | Neural weights as Lisp data structures. Homoiconic model introspection. |
+
+*** v5.0.0: True Agency
+
+World models, temporal reasoning, goal persistence across restarts.
+
+| Feature | Description |
+|---------|-------------|
+| World models | Predictive models of user behavior, project dynamics, system state. |
+| Temporal reasoning | Scheduling, deadlines, elapsed duration awareness. |
+| Goal persistence | Goals survive restarts. Long-term projects in org-objects. |

docs/USER_MANUAL.org

@@ -0,0 +1,124 @@
+#+TITLE: OpenCortex User Manual
+#+AUTHOR: OpenCortex Contributors
+#+STARTUP: content
+#+FILETAGS: :docs:manual:
+
+* Introduction
+Welcome to OpenCortex v0.1.0 (The Autonomous Foundation). OpenCortex is a neurosymbolic AI agent and a Lisp Machine operating system designed to autonomously maintain your Memex (knowledge base) and interact with you via multiple, equal-citizen interfaces.
+
+* Installation
+OpenCortex is bootstrapped via a single shell script.
+
+** Quick start (curl)
+
+#+begin_src bash
+curl -fsSL https://raw.githubusercontent.com/amrgharbeia/opencortex/main/opencortex.sh | bash -s configure
+#+end_src
+
+** From a clone
+
+#+begin_src bash
+git clone https://github.com/amrgharbeia/opencortex.git ~/projects/opencortex
+~/projects/opencortex/opencortex.sh configure
+#+end_src
+
+Both methods will:
+1. Install system dependencies (SBCL, Emacs, git, curl, socat — detected for Debian or Fedora)
+2. Install Quicklisp (Common Lisp package manager)
+3. Tangle literate Org sources into runnable Lisp
+4. Launch the interactive setup wizard (LLM providers, gateways)
+
+If you already have Emacs installed, the installer skips it and uses your existing installation.
+
+* Configuration
+The system is configured via a `.env` file in the project root. Essential variables include:
+
+- `OPENROUTER_API_KEY`: Your LLM provider key.
+- `PROVIDER_CASCADE`: The fallback order for LLM providers (e.g., `openrouter,ollama,anthropic`).
+- `MEMEX_DIR`: The absolute path to your knowledge base (defaults to `~/memex`).
+
+* Interacting with OpenCortex
+Because of the Unified Envelope Architecture, the kernel treats all clients as interchangeable. You must first boot the background daemon:
+
+#+begin_src bash
+./opencortex.sh --boot &
+#+end_src
+
+** Terminal User Interface (TUI)
+For a rich, split-pane terminal experience:
+#+begin_src bash
+./opencortex.sh tui
+#+end_src
+
+** Command Line Interface (CLI)
+For raw, pipe-friendly interaction:
+#+begin_src bash
+./opencortex.sh cli
+#+end_src
+
+** Emacs Integration
+OpenCortex functions as your "foveal vision" inside Emacs.
+1. Ensure `org-agent.el` is loaded.
+2. Run `M-x opencortex-connect`.
+3. Interact via the `*opencortex-chat*` buffer.
+
+* The Memex Structure
+OpenCortex assumes a local folder structure representing your "Memex".
+- Core memories and identities are mapped to Org-mode files.
+- The `Scribe` background worker distills chronological logs into structured Zettelkasten notes.
+- The `Gardener` continuously repairs broken links and flags orphaned nodes.
+
+* Deployment
+
+** Bare metal (Debian / Fedora)
+
+The ~configure~ command supports both Debian-based (Ubuntu, Pop, Mint) and Fedora-based (RHEL, Rocky) distributions. It detects your distro automatically and installs the correct packages.
+
+#+begin_src bash
+./opencortex.sh configure              # interactive
+./opencortex.sh configure --non-interactive  # headless
+./opencortex.sh configure --with-firewall    # also open port 9105
+#+end_src
+
+After configuration, you can re-run ~configure~ any time to add providers or link gateways.
+
+** systemd service (auto-start on boot)
+
+#+begin_src bash
+./opencortex.sh install service
+#+end_src
+
+Installs a user-level systemd unit that starts the daemon on login. Logs are available via ~journalctl --user -u opencortex.service -f~.
+
+To remove:
+
+#+begin_src bash
+./opencortex.sh uninstall service
+#+end_src
+
+** Docker
+
+A Debian-based Docker image is provided for containerized deployment.
+
+#+begin_src bash
+cd infrastructure/docker
+docker-compose up -d
+#+end_src
+
+This builds an image from ~debian:trixie-slim~ with all dependencies pre-installed. The memex directory is mounted from the host.
+
+** Backup
+
+#+begin_src bash
+./opencortex.sh backup ~/my-backup.tar.gz
+#+end_src
+
+Backs up the config, data, and memex directories.
+
+** Restore
+
+#+begin_src bash
+./opencortex.sh restore ~/my-backup.tar.gz
+#+end_src
+
+Restores from a backup file. Run ~opencortex doctor~ afterward to verify integrity.

docs/deployment.org

@@ -1,36 +0,0 @@
-#+TITLE: Deployment Guide: Containerized OpenCortex
-#+AUTHOR: Amr
-#+DATE: [2026-04-11 Sat]
-#+FILETAGS: :deployment:docker:infrastructure:
-
-* Overview
-The ~opencortex~ is designed to run within a Docker container to ensure system dependencies (SBCL, Quicklisp, signal-cli) are perfectly matched across different host environments.
-
-* Prerequisites
-- Docker Engine
-- Docker Compose
-- A valid ~.env~ file in the ~projects/opencortex/~ directory (refer to ~.env.example~).
-
-* Quick Start
-** 1. Build and Start
-From the ~projects/opencortex/~ directory:
-#+begin_src bash
-docker-compose up --build -d
-#+end_src
-
-** 2. Check Logs
-#+begin_src bash
-docker-compose logs -f
-#+end_src
-
-* Volume Mapping
-The ~docker-compose.yml~ file automatically mounts your host's ~memex~ directory to ~/memex~ inside the container. This allows the agent to:
-1. Read/Write to your Zettelkasten and GTD files.
-2. Maintain its local state (Memory, snapshots).
-
-* Troubleshooting
-** signal-cli Identity
-If using the Signal gateway, ensure you have registered your number via the host's ~signal-cli~ or within the container. The state is preserved in the ~signal-state~ Docker volume.
-
-** Re-loading Skills
-The container pre-caches dependencies during the build. If you modify core Lisp logic, you must rebuild the image (~--build~). If you only modify ~.org~ skills in your memex, the agent can reload them dynamically if they are part of the startup scan.

docs/marketing-v0.1.0.org

@@ -1,46 +0,0 @@
-#+TITLE: v0.1.0 Launch & Marketing Plan
-#+AUTHOR: Amr
-#+FILETAGS: :marketing:release:autonomy:
-#+STARTUP: content
-
-* Overview
-With the v0.1.0 "Autonomous MVP" released, the goal is to leverage GitHub's social graph to build a community of early adopters, contributors, and power users who resonate with the "Thin Harness, Fat Skills" and "Local-First" philosophy.
-
-* 1. Licensing Strategy
-Before wide promotion, the project's license must align with its goals.
-- **MIT License (Current):** Maximum adoption, frictionless for developers to embed in their own tools. Good for rapid growth.
-- **GPLv3 / AGPLv3:** Enforces copyleft. Ensures any modifications or integrations by corporations must remain open-source. Protects the "Autonomous" ethos from proprietary enclosure.
-- **Dual Licensing:** Open-source for individuals, commercial license for enterprise usage (if monetization is a future goal).
-
-*Decision Needed:* Do we stick with MIT, or switch to a copyleft license (AGPL) to protect the autonomous nature of the project?
-
-* 2. The GitHub Migration & Setup
-To maximize visibility, the repository must be optimized for GitHub's ecosystem.
-- [ ] **Mirror/Migrate to GitHub:** Move the primary remote from the self-hosted Gitea to GitHub.
-- [ ] **README Optimization:** Add badges (License, Build Status, Version). Ensure the "Zero-to-One" curl command is prominent. Add an architecture diagram (mermaid).
-- [ ] **Repository Topics:** Add tags like `common-lisp`, `autonomous-agents`, `org-mode`, `pkm`, `zettelkasten`, `llm`, `local-first`.
-- [ ] **Contributing Guide:** Add `CONTRIBUTING.md` to explain the Literate Programming standard and how to add new "Skills".
-- [ ] **Issue Templates:** Create templates for "Bug Report" and "Skill Proposal".
-
-* 3. The PR & Social Media Campaign
-The narrative: "An autonomous AI agent that doesn't just chat, but lives natively in your Org-mode Memex. No Python glue code, no cloud lock-in—just pure, homoiconic Common Lisp."
-
-** Target Audiences & Channels
-1. **The Emacs / Org-mode Community:**
-   - *Channels:* `r/emacs`, `r/orgmode`, Hacker News (`/r/lisp`), Emacs News.
-   - *Hook:* "A background daemon that autonomously distills your daily logs into a Zettelkasten using LLMs."
-2. **The Local-First / PKM Community:**
-   - *Channels:* `r/Zettelkasten`, `r/PKM`, Obsidian/Logseq diaspora looking for more power.
-   - *Hook:* "Own your brain. An AI agent that runs locally on your Markdown/Org files with mathematical security gates."
-3. **The AI / Autonomous Agent Hackers:**
-   - *Channels:* Hacker News (Show HN), Twitter/X (AI tech Twitter).
-   - *Hook:* "Tired of fragile Python/Playwright agent wrappers? opencortex uses a deterministic Lisp microkernel to formally verify LLM actions before execution."
-
-** Launch Materials
-- **Demo Video (2 minutes):** Show the one-liner install, the agent running the `Scribe` skill in the background, and the user querying it via `opencortex chat`.
-- **Blog Post / Essay:** "Why we built an Autonomous Agent in Common Lisp." Discuss the fragility of current SOTA (Devin/SWE-agent) and the necessity of the Bouncer/Policy gates.
-
-* 4. Post-Launch Community Engagement
-- Encourage "Show and Tell" in GitHub Discussions.
-- Create a "Skill Directory" where users can share their custom `.org` skills.
-- Actively solicit feedback for the v0.2.0 (Lisp TUI) roadmap.

docs/quickstart.org

@@ -1,55 +0,0 @@
-#+TITLE: Quickstart Guide: The Road to Autonomousty
-#+AUTHOR: Amr
-#+DATE: [2026-04-11 Sat]
-#+FILETAGS: :quickstart:onboarding:guide:
-
-* 1. Introduction
-Welcome to ~opencortex~, the "Executive Soul" of your personal OS. This guide will help you set up and interact with your first probabilistic-deterministic agent.
-
-* 2. Prerequisites
-Before launching the harness, ensure your host environment has:
-- **Docker & Docker Compose**: The primary enclosure for the Lisp Machine.
-- **LLM API Keys**: At least one key for Gemini, Anthropic, or OpenAI.
-- **Emacs (Optional)**: For the full literate experience via ~opencortex.el~.
-
-* 3. Installation & Enclosure
-** Step 1: Clone the Autonomousty
-#+begin_src bash
-git clone https://github.com/amr/opencortex.git
-cd opencortex
-#+end_src
-
-** Step 2: Secret Configuration
-Copy the example environment file and add your keys.
-#+begin_src bash
-cp .env.example .env
-# Edit .env with your favorite editor
-#+end_src
-
-** Step 3: Launch the Image
-This will build the SBCL environment and start the Micro-Loader.
-#+begin_src bash
-docker-compose up --build -d
-#+end_src
-
-* 4. Interaction Gateways
-Once the harness is "Ready", you can interact with it via multiple sensors.
-
-** Gateway A: Emacs (communication protocol)
-If you have configured the ~opencortex~ package in Emacs:
-1. Open a chat buffer: ~M-x opencortex-chat-open~.
-2. Send: "Are you online, agent?"
-
-** Gateway B: External Sensors
-If you enabled Signal or Telegram in ~.env~, send a message directly to your bot.
-
-* 5. Verification (The Chaos Check)
-To ensure the harness is fully healthy, check the logs for the Micro-Loader summary:
-#+begin_src bash
-docker-compose logs -f opencortex
-#+end_src
-Look for: ~LOADER: Boot Complete. [Ready: 34] [Failed: 0]~
-
-* 6. Next Steps
-- **Extend the Brain**: Read the [[file:skill-creation.org][Skill Creation Guide]] to add custom Lisp skills.
-- **Deep Dive**: Explore the [[file:../literate/][literate/]] directory to understand the harness's architecture.

docs/rca/rca-boot-sequence.org

@@ -1,42 +0,0 @@
-#+TITLE: Root Cause Analysis: Micro-Loader & Deterministic Boot Sequence
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:boot:loader:topological-sort:autonomy:
-
-* Executive Summary
-Refactored the arbitrary skill loading mechanism into a robust **Micro-Loader**. The system now calculates a deterministic boot sequence based on `#+DEPENDS_ON:` tags and protects the harness from malformed or hanging skills via package-based jailing and execution timeouts.
-
-* 1. Issue: Fragile Load Order
-** Symptoms
-Skills that depended on functions or variables from other skills would randomly fail to load depending on the filesystem's directory traversal order.
-** Root Cause
-`initialize-all-skills` used a simple `dolist` over `uiop:directory-files`, which has no semantic awareness of inter-skill dependencies.
-** Resolution
-1. **Metadata Scanning:** Implemented `parse-skill-metadata` to extract `:ID:` and `#+DEPENDS_ON:` without executing code.
-2. **Topological Sort:** Implemented a DFS-based `topological-sort-skills` to guarantee that prerequisites are loaded before their dependents.
-3. **Circular Detection:** Added explicit detection and error reporting for circular dependency loops.
-
-* 2. Issue: Shared State Corruption (Brain Rot)
-** Symptoms
-Variables or functions with the same name in different skills would silently overwrite each other, causing unpredictable behavior.
-** Root Cause
-All skills were being evaluated directly into the `opencortex` package.
-** Resolution
-**Package-Based Jailing:** Each skill is now evaluated within its own dedicated, shadowed package (e.g., `OPENCORTEX.SKILLS.ORG-SKILL-CHAT`). This ensures logical isolation while still allowing access to kernel exports.
-
-* 3. Issue: Boot Stall (The Hanging Skill)
-** Symptoms
-A single skill with an infinite loop or heavy synchronous initialization could hang the entire agent during startup.
-** Root Cause
-Skill loading was strictly synchronous and blocking on the main thread.
-** Resolution
-**Execution Timeouts:** Implemented `load-skill-with-timeout`, which wraps the loader in a monitored thread. If a skill takes longer than 5 seconds to initialize, the loader terminates the thread, jails the failure, and continues with the rest of the boot sequence.
-
-* 4. opencortex Mandate Alignment
-** Evolutionary Kernel
-The boot sequence is now a verifiable, mathematical process rather than a side-effect of filesystem organization.
-** Literate Granularity
-The `org-skill-skills.org` source was refactored into a strictly granular "one definition per block" format.
-
-* 5. Permanent Learnings
-- **Reverse Topological Order:** Remember that a DFS-based sort with `push` needs an `nreverse` to place dependencies at the front of the list.
-- **Path Portability:** Use `uiop:getcwd` instead of `pwd` for more reliable path resolution across different Lisp implementations and OSes.

docs/rca/rca-bouncer.org

@@ -1,33 +0,0 @@
-#+TITLE: Root Cause Analysis: Deterministic Engine Bouncer & Authorization Gate
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:bouncer:authorization:autonomy:security:
-
-* Executive Summary
-Implemented the "Planning Mode" Bouncer to intercept high-risk Probabilistic Engine proposals (e.g., shell commands, Lisp evaluation). The system now forces these actions into an asynchronous "Flight Plan" Org node for manual Autonomous approval, fulfilling the "everything is a node" and high-integrity mandates.
-
-* 1. Issue: Automated High-Risk Execution
-** Symptoms
-Probabilistic Engine proposals involving `shell` or `eval` were executed immediately upon passing the `decide` gate's safety harness. This lacked human-in-the-loop oversight for irreversible or complex operations.
-** Root Cause
-Architecture gap. The system lacked an authorization state between "Safe" and "Executed".
-** Resolution
-1. **Interceptor:** Added `bouncer-check` to `deterministic.lisp`. It flags high-risk actions that lack the `:approved t` property.
-2. **Asynchronous Event:** If flagged, the harness emits an `:approval-required` event.
-3. **Flight Plan Skill:** Created `org-skill-bouncer.org` to:
-   - Catch the event and create a serialized Org node with state `PLAN`.
-   - Monitor the Memory for `APPROVED` states.
-   - Re-inject approved actions with the `:approved t` bypass flag.
-
-* 2. Design Decision: Org-native Approval
-** Requirement
-Align with "Homoiconic Memory" and "Lisp Machine Autonomousty".
-** Selected Path
-State-Based Approval (Org-native).
-- *Pros:* Auditable, asynchronous, utilizes existing Org-mode workflows.
-- *Cons:* Slightly more latency than an interactive prompt.
-** Alignment
-Ensures that the agent's "Flight Plans" are first-class citizens in the Memex, allowing the Autonomous to review and approve them using standard GTD tools.
-
-* 3. Permanent Learnings
-- **Serial Bypass:** Always include a specific bypass flag (e.g., `:approved t`) when re-injecting intercepted actions to prevent infinite interception loops.
-- **Heartbeat Listeners:** Periodic scanning of the Memory for state transitions is an effective way to implement asynchronous authorization gates without blocking the harness.

docs/rca/rca-formal-verification.org

@@ -1,36 +0,0 @@
-#+TITLE: Root Cause Analysis: Lisp-Native Formal Verification Gate
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:security:formal-verification:autonomy:
-
-* Executive Summary
-Implemented a Lisp-Native Deterministic Prover to replace heuristic whitelisting with formal security invariants. This ensures that every high-impact action (shell, file I/O) is mathematically proven safe against the Autonomous's core mandates.
-
-* 1. Architectural Shift: Native vs. External
-** Issue
-The initial draft suggested using `Z3`, an external SMT solver. However, `Z3` was not available in the environment and would add significant complexity/bloat to the Docker image.
-** Resolution
-Leveraged Common Lisp's inherent strength in symbol manipulation to build a **Lisp-Native Prover**. Invariants are defined as high-order predicates that operate on the structure of proposed actions. This provides a self-contained, high-performance verification layer.
-
-* 2. Issue: Dependency Fragility
-** Symptoms
-System failed to load with `Package STR does not exist`.
-** Root Cause
-Incorrect assumption about the Quicklisp system name vs. the package name. The library is `cl-str` but the Quicklisp system is `str` and the package is `str`.
-** Resolution
-1. Updated `opencortex.asd` to depend on `:str`.
-2. Updated all source code and literate notes to use the `str:` prefix.
-3. Verified via explicit `ql:quickload` in the test runner.
-
-* 3. Formal Invariants Implemented
-- **Path Confinement:** Deterministically proves that any file operation or absolute path in a shell command is strictly within the `/home/user/memex` root.
-- **No Network Exfiltration:** Prevents the shell from invoking common exfiltration tools (`nc`, `ssh`, etc.) by inspecting the parsed command structure.
-
-* 4. opencortex Mandate Alignment
-** Soundness over Heuristics
-By moving to formal invariants, we have moved from "blacklisting bad things" to "proving safety." Any action that cannot be proven to satisfy all invariants is denied by default.
-** Literate Granularity
-The `org-skill-formal-verification.org` file follows the "one definition per block" mandate, ensuring that the logic of each invariant is individually documented and verifiable.
-
-* 5. Permanent Learnings
-- **Tooling Independence:** Whenever possible, prefer native Lisp logic over external binaries for core security gates to reduce the attack surface and deployment complexity.
-- **Environment Consistency:** Always use `(setf (uiop:getenv ...) ...)` for portable environment manipulation in tests.

docs/rca/rca-gateway-matrix.org

@@ -1,40 +0,0 @@
-#+TITLE: Root Cause Analysis: Matrix Gateway & Communication Track Completion
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:gateway:matrix:chat:autonomy:
-
-* Executive Summary
-Successfully implemented the third and final external communication channel (Matrix) for OpenCortex v1.0. Resolved integration issues related to case-sensitivity in JSON keys and strict header requirements in `dexador`.
-
-* 1. Issue: Symbol Casing in JSON Keys
-** Symptoms
-The `TEST-MATRIX-INBOUND-NORMALIZATION` test failed because `room-id` was being extracted as `"!ROOM:HS.ORG"` (uppercase) instead of `"!room:hs.org"`.
-** Root Cause
-Common Lisp's default reader converts symbol names to uppercase. When `(string car-of-alist)` was called on a symbol generated by `cl-json`, it produced an uppercase string.
-** Resolution
-Updated the implementation to use `(string-downcase (string ...))` for room IDs and other case-sensitive Matrix identifiers.
-
-* 2. Issue: Since Token Extraction Failure
-** Symptoms
-The sync loop failed to update the `*matrix-since-token*`, causing duplicate message processing risk.
-** Root Cause
-Anticipating `:next-batch` but receiving `:next--batch` (or vice versa) due to inconsistent `cl-json` behavior across different environments or structures.
-** Resolution
-Implemented a robust `(or (cdr (assoc :next-batch json)) (cdr (assoc :next--batch json)))` lookup to handle both hyphenation styles.
-
-* 3. Issue: Type Error in Authorization Headers
-** Symptoms
-`dex:put` crashed with a `TYPE-ERROR`.
-** Root Cause
-I was passing a single string or an incorrectly nested list where `dexador` expected a strict alist of header pairs `(("Key" . "Value") ...)`.
-** Resolution
-Standardized all gateway HTTP calls to use proper alist nesting for headers.
-
-* 4. Completion: Communication Track
-With Telegram, Signal, and Matrix gateways now verified and passing tests, the OpenCortex has achieved full multi-channel parity.
-- **Telegram:** Polling via Bot API.
-- **Signal:** Wrapping `signal-cli`.
-- **Matrix:** Polling via `/sync` Client API.
-
-* 5. Permanent Learnings
-- **Case Sensitivity:** Matrix IDs (rooms, users) are case-sensitive; Lisp symbols are not. Always force downcasing or use strings for storage.
-- **Header Alists:** Always use dotted pairs `("Key" . "Value")` for `dexador` headers.

docs/rca/rca-gateway-signal.org

@@ -1,33 +0,0 @@
-#+TITLE: Root Cause Analysis: Signal Gateway & Multi-Channel Chat
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:gateway:signal:chat:autonomy:
-
-* Executive Summary
-Successfully implemented the second external communication channel (Signal) using `signal-cli`. Further hardened the multi-channel chat logic and resolved JSON mapping discrepancies between Common Lisp and external CLI outputs.
-
-* 1. Issue: JSON Key Mapping Mismatch
-** Symptoms
-The `TEST-SIGNAL-INBOUND-NORMALIZATION` test failed despite the mock JSON appearing correct.
-** Root Cause
-`cl-json` default behavior for decoding. It converts camelCase keys from JSON (e.g., `dataMessage`) into kebab-case keywords in Lisp (e.g., `:DATA-MESSAGE`). I had incorrectly anticipated `:DATA--MESSAGE` or `:DATA_MESSAGE`.
-** Resolution
-1. **Diagnostic:** Added debug output to the test suite to inspect the exact plist structure returned by `cl-json`.
-2. **Correction:** Updated both the implementation and the literate note to use the correct `:DATA-MESSAGE` and `:SOURCE` keywords.
-
-* 2. Implementation: Signal-CLI Wrapper
-** Strategy
-Unlike Telegram's HTTP API, Signal requires a local binary (`signal-cli`). 
-- **Sensor:** Uses `uiop:run-program` with `receive --json` in a polling loop (5s interval).
-- **Actuator:** Uses `uiop:run-program` with `send -m <text> <recipient>`.
-** Security
-The system uses the pre-configured Signal account `+13322690326` discovered in the user's memex.
-
-* 3. Alignment with opencortex Mandates
-** Literate Granularity
-Strictly adhered to the "one definition per block" mandate throughout the new `org-skill-gateway-signal.org` file.
-** Verification
-The `gateway-signal-suite` (10 checks) provides full coverage for inbound parsing and outbound command generation.
-
-* 4. Permanent Learnings
-- **JSON Semantics:** Always verify the specific keyword transformation rules of the JSON library when dealing with external CLI outputs.
-- **Process Robustness:** `uiop:run-program` is the reliable standard for CLI-based gateways in SBCL.

docs/rca/rca-gateway-telegram.org

@@ -1,43 +0,0 @@
-#+TITLE: Root Cause Analysis: Telegram Gateway & Channel-Aware Chat
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:gateway:telegram:chat:autonomy:
-
-* Executive Summary
-Successfully implemented the first external communication channel (Telegram) and decoupled the Chat Agent from its Emacs-centric roots. Resolved significant load-order and dependency issues identified during integration.
-
-* 1. Issue: Undefined Foundational Functions
-** Symptoms
-During compilation, `gateway-telegram.lisp` failed with `UNDEFINED-FUNCTION` for `register-actuator` and `harness-log`.
-** Root Cause
-Poorly scoped foundational functions. These were defined in `core.lisp` (the loop orchestrator), which was loaded *after* the gateways in `opencortex.asd`. This created a "Circular Intention" where the gateways needed the harness to exist before the harness could load the gateways.
-** Resolution
-1. **Relocation:** Moved `*actuator-registry*` and `register-actuator` to `communication.lisp` (the foundation).
-2. **Reordering:** Adjusted `opencortex.asd` to load `core.lisp` (containing the stimulus loop) immediately after the deterministic gates but before the physical sensors (gateways).
-
-* 2. Issue: Hardcoded Chat UI
-** Symptoms
-The `Chat Agent` could only respond via Emacs buffer insertion, rendering it useless for external channels like Telegram.
-** Root Cause
-Architectural myopia. The original chat skill assumed the user was always in front of Emacs.
-** Resolution
-Refactored `org-skill-chat` to be **Channel-Aware**:
-- It now extracts `:channel` and `:chat-id` from the inbound stimulus.
-- It dynamically generates the Probabilistic Engine mandate, instructing the LLM to use the appropriate `:target` (e.g., `:telegram`) based on the conversation context.
-
-* 3. Side-Issue: UIOP Portability
-** Symptoms
-Tests failed with `Symbol "SETENV" not found in the UIOP/DRIVER package`.
-** Root Cause
-Misinterpretation of the `UIOP` API. `setenv` is not a standard export; the portable way is using `(setf (uiop:getenv ...) ...)`.
-** Resolution
-Updated all test environment setup to use the `setf` accessor.
-
-* 4. opencortex Mandate Alignment
-** Autonomous Boundary
-By moving the Telegram API logic to a user-space skill and communicating with the core via standard stimuli, we have respected the microkernel boundary.
-** Homoiconic Memory
-All Telegram interactions are now logged as `:chat-message` events, ensuring the agent's history is unified regardless of the platform.
-
-* 5. Permanent Learnings
-- **Foundation First:** Registries and logging macros must reside in the most foundational layers (`protocol` or `package`) to avoid load-order fragility.
-- **Instruct the Actuator:** When adding new channels, always update the Chat Agent's neural prompt so it knows how to "speak" back through the new interface.

docs/rca/rca-infrastructure-docker.org

@@ -1,30 +0,0 @@
-#+TITLE: Root Cause Analysis: Containerized Infrastructure (Docker)
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:docker:deployment:infrastructure:autonomy:
-
-* Executive Summary
-Standardized the `opencortex` execution environment by creating a production-grade Docker infrastructure. This ensures that all system dependencies, including the Lisp runtime and external binaries like `signal-cli`, are locked down and portable.
-
-* 1. Architectural Intent: The "Clean Room" Model
-** Problem
-The `opencortex` was relying on host-local binaries (`sbcl`, `signal-cli`) and manually configured Quicklisp dists. This made deployment to other environments (e.g., a VPS or a Autonomous Home Server) fragile and prone to version drift.
-** Solution
-1. **Dockerfile:** Created a multi-step build process that installs Debian Bookworm, SBCL, Java, and `signal-cli 0.14.0`.
-2. **Pre-Caching:** The build process triggers a `ql:quickload` of the `:opencortex` system, ensuring all Lisp dependencies are pre-downloaded and stored in the image layer, drastically reducing startup time.
-3. **Compose Orchestration:** Standardized the runtime via `docker-compose.yml`, which handles volume mounting of the user's `memex` directory and injection of `.env` secrets.
-
-* 2. Volume Mapping & Persistence
-** Strategy
-To maintain the "Autonomous" mandate, the agent's code is isolated, but its memory (the `memex`) remains on the host. 
-- **Mapping:** `../..` (host) -> `/memex` (container).
-- **State:** Created a named Docker volume `signal-state` to ensure that `signal-cli` identities and cryptographic keys survive container restarts and image updates.
-
-* 3. Alignment with opencortex Mandates
-** Evolutionary Completion
-By moving to Docker, we have achieved "Evolutionary Completion" for the deployment track. The system is no longer a collection of scripts; it is a deployable appliance.
-** Documentation
-A new `Deployment Guide` was added to `docs/deployment.org` to ensure standard operating procedures are preserved.
-
-* 4. Permanent Learnings
-- **Lisp Build Layers:** Always push the system to the ASDF registry and quickload during Docker build to bake dependencies into the image.
-- **Compose Locality:** Placing the `docker-compose.yml` inside the `projects/opencortex/` folder keeps infrastructure code close to the implementation logic.

docs/rca/rca-lisp-repair-async.org

@@ -1,33 +0,0 @@
-#+TITLE: Root Cause Analysis: Asynchronous Lisp Repair Syntax Gate
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:lisp:repair:decoupling:architecture:autonomy:
-
-* Executive Summary
-Reimplemented the `org-skill-lisp-repair` to align with the "Autonomous Boundary" mandate. The previously synchronous, core-blocking repair logic has been replaced with an asynchronous, event-driven architecture using the Reactive Signal Pipeline.
-
-* 1. Issue: Core Bloat & Synchronous Coupling
-** Symptoms
-The initial implementation of the Lisp Repair gate placed a `handler-case` and a dynamic function call (`repair-lisp-syntax`) directly inside the core `think` function (`probabilistic.lisp`). This forced the core to wait for repairs and made it "aware" of specific repair logic.
-** Root Cause
-Architectural shortcutting. By placing repair logic in the core execution path, we violated the microkernel principle which mandates that the core should be a "dumb" signal processor.
-** Resolution
-1. **Refactored Core:** `think` now only emits a `:syntax-error` stimulus if parsing fails. It no longer attempts to repair.
-2. **Asynchronous Skill:** `skill-lisp-repair` now triggers on the `:syntax-error` event. It performs the repair and returns the corrected action, which is then dispatched by the pipeline.
-
-* 2. Side-Issue: Nested Signal Payloads
-** Symptoms
-`TYPE-ERROR` during testing when extracting the broken code from the stimulus.
-** Root Cause
-Mismatched expectations of signal nesting. The skill expected the code at `(getf context :payload)`, but in the `decide-gate`, `context` is the full signal, and the error details were nested inside the `:candidate` field of that signal.
-** Resolution
-Updated the deterministic logic to correctly traverse the nested signal structure: `(getf (getf context :candidate) :payload)`.
-
-* 3. opencortex Mandate Alignment
-** Autonomous Boundary
-The core is now strictly a parser. Repair is an optional, user-space service.
-** Reactive Signal Pipeline
-Leveraged the pipeline's ability to re-inject `EVENT` signals to flatten the recursion of the repair loop.
-
-* 4. Permanent Learnings
-- **Emit, Don't Call:** In a microkernel, if a non-fatal error occurs, always emit a signal rather than calling a recovery function. This allows the system to remain asynchronous and modular.
-- **Signal Inspection:** When writing deterministic gates, always verify the exact shape of the `context` signal being passed by the harness to avoid nesting errors.

docs/rca/rca-playwright-bridge.org

@@ -1,39 +0,0 @@
-#+TITLE: Root Cause Analysis: Playwright-Python Bridge (High-Fidelity Browsing)
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:intelligence:browsing:automation:autonomy:
-
-* Executive Summary
-Successfully implemented a high-fidelity browsing bridge using Playwright and Python. This allows the `opencortex` to interact with modern, JavaScript-rendered web applications that were previously inaccessible via simple HTTP clients.
-
-* 1. Architectural Strategy: The I/O Bridge
-** Problem
-Common Lisp lacks a mature, native Playwright implementation. Direct bindings are complex and fragile.
-** Resolution
-Implemented a **JSON-over-STDIO Bridge**. 
-- A standalone Python script (`browser-bridge.py`) manages the Playwright lifecycle and Chromium instance.
-- The Lisp kernel communicates with this script using `uiop:run-program`, passing parameters via `stdin` and receiving structured results via `stdout`. This provides a stable, decoupled interface.
-
-* 2. Environment & Dependency Management
-** Issue
-Playwright requires a specific version of Chromium and several system-level libraries not present in the base Debian image.
-** Resolution
-Updated the `Dockerfile` to:
-1. Install Python3, pip, and venv.
-2. Create a virtual environment for isolated dependency management.
-3. Install the `playwright` package and execute `playwright install --with-deps chromium` during the image build. This ensures the production container is ready for high-fidelity browsing immediately upon startup.
-
-* 3. Cognitive Tooling
-Created the `:browser` cognitive tool, which exposes three primary capabilities to Probabilistic Engine:
-- **Navigation:** Full JS rendering and waiting for network idle.
-- **Extraction:** Targeted text retrieval via CSS selectors.
-- **Vision:** Base64-encoded screenshot capture for future multimodal processing.
-
-* 4. opencortex Mandate Alignment
-** Zero-Bloat (Managed)
-While adding Playwright increases the image size, it is a "Complexity Earned" trade-off that dramatically expands the agent's capability frontier.
-** Literate Granularity
-The `org-skill-playwright.org` file strictly follows the "one definition per block" mandate.
-
-* 5. Permanent Learnings
-- **Inter-Process JSON:** JSON is the ideal lingua franca for Lisp-Python bridges.
-- **Path Portability:** Always use `uiop:native-namestring` when passing Lisp paths to external shell commands to ensure OS compatibility.

docs/rca/rca-provider-verification.org

@@ -1,40 +0,0 @@
-#+TITLE: Root Cause Analysis: Individual Provider Track Verification
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:providers:llm:testing:autonomy:
-
-* Executive Summary
-Verified the unified LLM gateway implementation for all 6 individual provider tracks (Anthropic, Gemini, Groq, OpenAI, OpenRouter, Ollama). Identified and resolved critical parsing failures in the Gemini track and integration gaps in the system build definition.
-
-* 1. Issue: Fragile Response Parsing (Gemini)
-** Symptoms
-Gemini API responses were returning `NIL` content during mocked unit tests, despite the JSON structure being seemingly correct.
-** Root Cause
-Recursive `assoc` / `car` / `cdr` chains were hardcoded and brittle. Specifically, the Gemini extraction logic was incorrectly attempting to treat a single alist pair as a list of pairs, causing `assoc` to fail on the `:TEXT` key.
-** Resolution
-Implemented a robust `get-nested` helper function that safely traverses both nested objects (alists) and arrays (lists of alists). This normalized the extraction logic across all providers.
-
-* 2. Issue: Decoupled Build Configuration
-** Symptoms
-Provider logic was present in the codebase but inaccessible during tests and runtime.
-** Root Cause
-The `credentials-vault.lisp` and `llm-gateway.lisp` files (consolidated in a previous session) were never added to the `opencortex.asd` system definition. Furthermore, an incorrect loading order caused `UNDEFINED-FUNCTION` errors for `register-probabilistic-backend`.
-** Resolution
-1. Added both files to `opencortex.asd`.
-2. Enforced strict loading order: `probabilistic` (defines registry) -> `credentials-vault` -> `llm-gateway` (uses registry).
-
-* 3. Issue: Credential Key Mismatch
-** Symptoms
-Gemini requests failed with "API Key missing" even when environment variables were set.
-** Root Cause
-`llm-gateway` requested secrets for the `:gemini-api` provider, but the `credentials-vault` fallback logic only recognized the `:gemini` keyword.
-** Resolution
-Updated `vault-get-secret` to map both `:gemini` and `:gemini-api` to the same `GEMINI_API_KEY` environment variable.
-
-* 4. opencortex Mandate Alignment
-** Invariant Check
-- *High-Integrity Memory:* All individual provider tracks are now backed by automated unit tests (`llm-gateway-tests.lisp`).
-- *Literate Programming:* Updated `org-skill-llm-gateway.org` to reflect the improved `get-nested` utility.
-
-* 5. Permanent Learnings
-- **Tooling vs Source:** Tangled `.lisp` files are not enough; always ensure new modules are registered in the `.asd` file to be part of the official kernel build.
-- **Robustness over Brevity:** Use abstraction helpers like `get-nested` instead of deep `car/cdr` chains when dealing with external JSON structures that may have varying array/object nesting.

docs/rca/rca-self-fix-loop.org

@@ -1,40 +0,0 @@
-#+TITLE: Root Cause Analysis: Autonomous Self-Fix Loop Verification
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:self-fix:autonomy:testing:
-
-* Executive Summary
-Verified the autonomous repair capability of the `Self-Fix Agent`. The system successfully detected a deterministic type error in a secondary skill, initiated a repair request, and programmatically patched the source code via the `:repair-file` tool.
-
-* 1. Issue: Self-Fix Mechanism Verification
-** Symptoms
-Manual verification was required to prove that `org-skill-self-fix` could transition from "Thinking" about a bug to "Acting" on the file system.
-** Root Cause
-N/A (Deterministic test injection).
-** Resolution
-Created `self-fix-tests.lisp` which:
-1. Generates `org-skill-broken-math.org` with a `(+ 1 "two")` bug.
-2. Triggers the bug to produce a `PIPELINE CRASH`.
-3. Injects a `:repair-request` stimulus.
-4. Executes `self-fix-apply` to replace the bug with `(+ 1 2)`.
-5. Verifies the file content and successful hot-reload.
-
-* 2. Side-Issue: ASDF Configuration Fragility
-** Symptoms
-Repeated `LOAD-SYSTEM-DEFINITION-ERROR` and "unmatched close parenthesis" errors during test integration.
-** Root Cause
-Complexity in the `:components` nesting of `opencortex.asd` led to repeated syntax errors when using automated editing tools. The deep nesting made manual paren counting prone to "off-by-one" errors.
-** Resolution
-Refactored `opencortex.asd` to use a **Flat Component Structure**. 
-- *Before:* `:components ((:module "src" :components (...)))`
-- *After:* `:components ((:file "src/package") ...)`
-This eliminates unnecessary nesting levels and drastically reduces the surface area for syntax errors.
-
-* 3. opencortex Mandate Alignment
-** Invariant Check
-- *Lisp Machine Autonomousty:* Verification utilized hot-reloading (`load-skill-from-org`) without restarting the SBCL image.
-- *Literate Programming:* Updated `org-skill-self-fix.org` to match the finalized `self-fix.lisp` logic.
-- *Institutional Memory:* This RCA documents the decision to flatten the `.asd` structure to prevent future "Parenthesis Hell" incidents.
-
-* 4. Permanent Learnings
-- **Flatten Configuration:** Keep `defsystem` definitions as flat as possible. The overhead of `:module` blocks often outweighs their organizational benefit in a probabilistic-deterministic environment where agents frequently edit these files.
-- **Mocking Probabilistic Engine:** For verifying *loop mechanics*, mocking LLM responses is essential to ensure test determinism, while integration tests can use live LLM calls.

docs/rca/rca-shell-hardening.org

@@ -1,33 +0,0 @@
-#+TITLE: Root Cause Analysis: Shell Actuator Security Hardening
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:security:shell:injection:autonomy:
-
-* Executive Summary
-During the formal verification of the `org-skill-shell-actuator`, a critical command injection vulnerability was identified and patched. The previous implementation relied on a naive whitelist check that could be bypassed using shell metacharacters.
-
-* 1. Issue: Command Injection Vulnerability
-** Symptoms
-Commands like `ls ; rm -rf /` were potentially executable if the first word (`ls`) was in the whitelist. 
-** Root Cause
-The `execute-shell-safely` function only checked the first space-delimited word of the command string against the `*allowed-commands*` whitelist. Since `uiop:run-program` executes string-based commands via `/bin/sh -c`, the shell would process the entire string, including injected commands following metacharacters like `;`, `&`, or `|`.
-** Resolution
-1. **Metacharacter Blacklist:** Introduced `*shell-metacharacters*` containing dangerous shell symbols (`; & | > < $ \` \ !`).
-2. **Strict Validation:** Updated `execute-shell-safely` to scan the *entire* command string for these characters before performing the whitelist check.
-3. **Defense-in-Depth:** Any command containing a metacharacter is now rejected with a "Security Violation" error, even if the primary command is whitelisted.
-
-* 2. Side-Issue: Missing Package Context
-** Symptoms
-`UNDEFINED-FUNCTION EXECUTE-SHELL-SAFELY` during unit tests.
-** Root Cause
-`src/shell-logic.lisp` was missing an `(in-package :opencortex)` declaration, causing symbols to be defined in the default `COMMON-LISP-USER` package instead of the harness package.
-** Resolution
-Added the `in-package` header to `shell-logic.lisp`.
-
-* 3. opencortex Mandate Alignment
-** Invariant Check
-- *High-Integrity Memory:* The shell actuator is now formally verified with 4 new unit tests covering whitelist enforcement and injection blocking.
-- *Literate Programming:* Updated `org-skill-shell-actuator.org` Phase A and Build sections to reflect the hardened logic.
-
-* 4. Permanent Learnings
-- **Whole-String Validation:** Never assume that whitelisting the "head" of a command string is sufficient when passing that string to a shell. 
-- **Subshell Avoidance:** While the current fix blacklists metacharacters, future iterations should move toward passing command arguments as a Lisp list to `uiop:run-program`, bypassing the shell entirely.

docs/rca/rca-task-orchestrator.org

@@ -1,48 +0,0 @@
-#+TITLE: Root Cause Analysis: Consolidation VI - Task Orchestrator Implementation
-#+DATE: 2026-04-11
-#+FILETAGS: :rca:orchestrator:consensus:integrity:
-
-* Executive Summary
-The implementation of Consolidation VI (Task Orchestrator) aimed to introduce parallel multi-backend consensus, GTD task integrity, and delegation. During the build, a critical dependency failure was identified in the `lisp-validator` module.
-
-* 1. Issue: Undefined `SAFETY-HARNESS-VALIDATE`
-** Symptoms
-Existing `SAFETY-SUITE` tests failed with `#<UNDEFINED-FUNCTION SAFETY-HARNESS-VALIDATE>`.
-** Root Cause
-The function `lisp-validator-validate` was exported in `package.lisp` but never actually defined in `lisp-validator.lisp`. Only the internal recursive walker `lisp-validator-ast-walk` existed. This represents a "Hollow Export" bug where the interface was designed but the implementation was truncated or skipped in a previous session.
-** Resolution
-Defined `lisp-validator-validate` as a wrapper around `read-from-string` and `lisp-validator-ast-walk`.
-
-* 2. Design Decision: Deterministic Consensus
-** Requirement
-Multi-backend support to reduce hallucinations and increase reliability.
-** Solution
-Implemented `bt:make-thread` parallel queries in `ask-probabilistic`.
-** Trade-off
-Selected "Majority Rules" over "First-to-Finish".
-- *Pros:* Higher accuracy, mathematically consistent.
-- *Cons:* Slower (latency limited by the slowest provider).
-** Invariant Alignment
-Aligns with opencortex Mandate 4 (Radical Transparency) and Invariant 2 (Technical Mastery) by ensuring decisions are auditable and consistent across multiple brains.
-
-* 3. Design Decision: Task Integrity Gate
-** Requirement
-Prevent illegal GTD state transitions.
-** Solution
-Added `task-integrity-check` in `deterministic.lisp`.
-** Invariant Alignment
-Enforces the "High-Integrity Memory" mandate by ensuring the Org-mode AST remains semantically valid according to GTD rules (e.g., no orphaned active tasks).
-
-* 4. opencortex Mandate Violations during Session (Corrected)
-** Violations
-1. Editing without prior commit.
-2. Direct `.lisp` edits vs Literate Org tangling.
-3. Multi-function edits per block.
-** Correction
-1. Performed a retrospective commit.
-2. Synchronized `probabilistic-deterministic.org` and `core.org` with source code.
-3. Refactored the Markdown flight plan into an Org-mode flight plan.
-
-* 5. Permanent Learnings
-- *Check Exports:* Always verify that symbols exported in `package.lisp` have a corresponding definition in the literate source.
-- *Strict opencortex Mode:* Enable a pre-save hook or agent check to ensure all edits are performed within `#+begin_src` blocks in Literate Org files to avoid synchronization debt.

docs/ux.org

@@ -1,66 +0,0 @@
-#+TITLE: User Experience (UX) Journey
-#+AUTHOR: Amr
-#+FILETAGS: :ux:design:autonomy:
-#+STARTUP: content
-
-* Overview
-This document traces the intended User Experience (UX) journey for the ~opencortex~. It serves as a living design document to ensure that architectural decisions align with a frictionless, autonomous, and intuitive user interaction model.
-
-* 1. The Zero-to-One Experience (Onboarding)
-** Goal
-A user should be able to go from discovering the project to having a running, calibrated agent in under 3 minutes, with zero prerequisite knowledge of Lisp.
-
-** The Appliance Paradigm (Primary Path)
-The user runs a single command in their terminal:
-#+begin_src bash
-curl -fsSL https://raw.githubusercontent.com/gharbeia/opencortex/main/scripts/install.sh | bash
-#+end_src
-
-** The Interactive Wizard
-The script verifies Docker presence and then launches an interactive prompt before booting the container:
-1. *Identity:* "What is your name?" -> Configures ~$MEMEX_USER~
-2. *Assistant:* "What shall we name your Assistant?" -> Configures ~$MEMEX_ASSISTANT~
-3. *Neural Provider:* "Select your primary neural provider [Gemini/OpenRouter/Anthropic/OpenAI]" -> Configures API Keys.
-4. *Data Gravity:* "Where is your Memex located?" -> Maps the host directory to the Docker container.
-
-*Outcome:* The `.env` is generated, core skills are seeded into the user's Memex, and `docker-compose up -d` launches the daemon in the background. The user sees: /"Booting your autonomous brain in the background..."/
-
-* 2. The First Contact (The CLI Gateway)
-** Goal
-Immediately after boot, the user needs a way to verify the agent is alive and capable of answering questions about their Memex without configuring complex third-party integrations (like Telegram bots).
-
-** The Interaction
-The user types a local client command to connect to the background daemon:
-#+begin_src bash
-opencortex chat
-#+end_src
-
-This opens a slick, colorful interactive terminal session:
-#+begin_example
-> User: Hello, what are my active projects?
-> Agent: [Thinking...]
-> Agent: You currently have 3 active projects:
->        1. OpenCortex v1.0
->        2. Home Renovation
->        3. Read 'The Autonomous Individual'
-#+end_example
-
-** Behind the Scenes
-1. The ~opencortex chat~ client connects to the daemon's local port (e.g., 9105).
-2. It sends a ~:chat-message~ signal.
-3. The core harness routes this to the Probabilistic Engine.
-4. The Context Manager retrieves active projects from the Memex AST.
-5. The Deterministic Engine (Bouncer) verifies it is a safe read-only action.
-6. The ~:cli~ Actuator formats the Lisp response into Markdown and sends it back over the socket.
-
-* 3. The Interactive Refinement (v0.2.0)
-** Goal
-Transition from a "Verified Wrapper" around netcat to a high-fidelity, native Common Lisp TUI that rivals the experience of ~gemini-cli~.
-
-** Features
-- *Homoiconic UI:* The TUI is rendered directly by the Lisp kernel, allowing for live introspection of the agent's thoughts.
-- *Rich Formatting:* ANSI colors, bold headers, and syntax-highlighted code blocks.
-- *Command Palette:* Slash commands for system control without leaving the chat.
-
-* 4. The Continuous Loop (Daily Usage)
-(To be defined as the agent's capabilities expand into Scribe, Gardener, and Emacs-native interactions).

harness/act.lisp

@@ -0,0 +1,133 @@
+(in-package :opencortex)
+
+(defvar *default-actuator* :cli
+  "The actuator used when no explicit target is specified.")
+
+(defvar *silent-actuators* '(:cli :system-message :emacs)
+  "List of actuators that don't generate tool-output feedback.")
+
+(defun initialize-actuators ()
+  "Register core actuators and load configuration."
+  (let ((def (uiop:getenv "DEFAULT_ACTUATOR"))
+        (silent (uiop:getenv "SILENT_ACTUATORS")))
+    (when def
+      (setf *default-actuator* (intern (string-upcase def) :keyword)))
+    (when silent
+      (setf *silent-actuators*
+            (mapcar (lambda (s) (intern (string-upcase (string-trim '(#\Space) s)) :keyword))
+                    (uiop:split-string silent :separator '(#\,))))))
+
+  (register-actuator :system #'execute-system-action)
+  (register-actuator :tool #'execute-tool-action)
+
+  (register-actuator :tui (lambda (action context)
+                            (declare (ignore context))
+                            (let* ((meta (getf action :meta))
+                                   (stream (getf meta :reply-stream)))
+                              (when (and stream (open-stream-p stream))
+                                (format stream "~a" (frame-message action))
+                                (finish-output stream))))))
+
+(defun dispatch-action (action context)
+  "Route an approved action to its registered actuator."
+  (let ((payload (proto-get action :payload)))
+    (when (eq (proto-get payload :sensor) :heartbeat)
+      (return-from dispatch-action nil))
+
+    (when (and action (listp action))
+      (let* ((meta (proto-get context :meta))
+             (source (proto-get meta :source))
+             (raw-target (or (proto-get action :target) source *default-actuator*))
+             (target (intern (string-upcase (string raw-target)) :keyword))
+             (actuator-fn (gethash target *actuator-registry*)))
+        (when (and meta (null (getf action :meta)))
+          (setf (getf action :meta) meta))
+        (if actuator-fn
+            (funcall actuator-fn action context)
+            (harness-log "ACT ERROR: No actuator registered for '~s'" target))))))
+
+(defun execute-system-action (action context)
+  "Execute internal harness commands."
+  (declare (ignore context))
+  (let* ((payload (getf action :payload))
+         (cmd (getf payload :action)))
+    (case cmd
+      (:eval
+       (eval (read-from-string (getf payload :code))))
+      (:message
+       (harness-log "ACT [System]: ~a" (getf payload :text)))
+      (t
+       (harness-log "ACT ERROR [System]: Unknown command '~s'" cmd)))))
+
+(defun execute-tool-action (action context)
+  "Execute a registered cognitive tool."
+  (let* ((payload (getf action :payload))
+         (tool-name (getf payload :tool))
+         (tool-args (getf payload :args))
+         (depth (getf context :depth 0))
+         (meta (getf context :meta))
+         (source (getf meta :source))
+         (tool (gethash (string-downcase (string tool-name)) *cognitive-tools*)))
+    (if tool
+        (handler-case
+            (let* ((clean-args (if (and (listp tool-args) (listp (car tool-args))) (car tool-args) tool-args))
+                   (result (funcall (cognitive-tool-body tool) clean-args)))
+              (when source
+                (dispatch-action (list :TYPE :REQUEST :TARGET source 
+                                       :PAYLOAD (list :ACTION :MESSAGE :TEXT (format-tool-result tool-name result)))
+                                context))
+              (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+                    :PAYLOAD (list :SENSOR :tool-output :RESULT result :TOOL tool-name)))
+          (error (c)
+            (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+                  :PAYLOAD (list :SENSOR :tool-error :TOOL tool-name :MESSAGE (format nil "~a" c)))))
+        (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+              :PAYLOAD (list :SENSOR :tool-error :MESSAGE (format nil "Tool '~a' not found" tool-name))))))
+
+(defun format-tool-result (tool-name result)
+  "Format a tool result for display."
+  (if (listp result)
+      (let ((status (getf result :status))
+            (content (getf result :content))
+            (msg (getf result :message)))
+        (cond
+          ((and (eq status :success) content) (format nil "~a" content))
+          ((and (eq status :error) msg) (format nil "ERROR [~a]: ~a" tool-name msg))
+          (t (format nil "TOOL [~a] RESULT: ~s" tool-name result))))
+      (format nil "TOOL [~a] RESULT: ~a" tool-name result)))
+
+(defun act-gate (signal)
+  "Final stage of the metabolic pipeline: Actuation."
+  (let* ((approved (getf signal :approved-action))
+         (type (getf signal :type))
+         (meta (getf signal :meta))
+         (source (getf meta :source))
+         (feedback nil))
+    (when approved
+      (let* ((original-type (getf approved :type))
+             (verified (deterministic-verify approved signal)))
+        (if (and (listp verified) (member (getf verified :type) '(:LOG :EVENT)) (not (member original-type '(:LOG :EVENT))))
+            (progn
+              (harness-log "ACT BLOCKED: Action failed last-mile deterministic check.")
+              (setf (getf signal :approved-action) nil)
+              (setf feedback verified))
+            (progn
+              (setf (getf signal :approved-action) verified)
+              (setf approved verified)))))
+
+    (case type
+      (:REQUEST (dispatch-action signal signal))
+      (:LOG (dispatch-action signal signal))
+      (:EVENT
+       (if approved
+           (let* ((target (getf approved :target))
+                  (result (dispatch-action approved signal)))
+             (cond
+               ((and (listp result) (member (getf result :type) '(:EVENT :LOG)))
+                (setf feedback result))
+               ((and result (not (member target *silent-actuators*)))
+                (setf feedback (list :type :EVENT :depth (1+ (getf signal :depth 0)) :meta meta
+                                    :payload (list :sensor :tool-output :result result :tool approved))))))
+           (when source (dispatch-action signal signal)))))
+    (setf (getf signal :status) :acted)
+    feedback))

harness/act.org

@@ -0,0 +1,187 @@
+#+TITLE: Stage 3: Act (act.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:act:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle act.lisp
+
+* Overview
+The Act stage dispatches approved actions to registered actuators. After the Probabilistic engine proposes and the Deterministic engine verifies, Act executes the approved action via the appropriate actuator (:cli, :tool, :system, :telegram, :signal, etc.). The actuator registry is extensible — skills can register new actuators at runtime.
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Actuator Configuration
+#+begin_src lisp
+(defvar *default-actuator* :cli
+  "The actuator used when no explicit target is specified.")
+
+(defvar *silent-actuators* '(:cli :system-message :emacs)
+  "List of actuators that don't generate tool-output feedback.")
+
+(defun initialize-actuators ()
+  "Register core actuators and load configuration."
+  (let ((def (uiop:getenv "DEFAULT_ACTUATOR"))
+        (silent (uiop:getenv "SILENT_ACTUATORS")))
+    (when def
+      (setf *default-actuator* (intern (string-upcase def) :keyword)))
+    (when silent
+      (setf *silent-actuators*
+            (mapcar (lambda (s) (intern (string-upcase (string-trim '(#\Space) s)) :keyword))
+                    (uiop:split-string silent :separator '(#\,))))))
+
+  (register-actuator :system #'execute-system-action)
+  (register-actuator :tool #'execute-tool-action)
+
+  (register-actuator :tui (lambda (action context)
+                            (declare (ignore context))
+                            (let* ((meta (getf action :meta))
+                                   (stream (getf meta :reply-stream)))
+                              (when (and stream (open-stream-p stream))
+                                (format stream "~a" (frame-message action))
+                                (finish-output stream))))))
+#+end_src
+
+** Action Dispatch (dispatch-action)
+#+begin_src lisp
+(defun dispatch-action (action context)
+  "Route an approved action to its registered actuator."
+  (let ((payload (proto-get action :payload)))
+    (when (eq (proto-get payload :sensor) :heartbeat)
+      (return-from dispatch-action nil))
+
+    (when (and action (listp action))
+      (let* ((meta (proto-get context :meta))
+             (source (proto-get meta :source))
+             (raw-target (or (proto-get action :target) source *default-actuator*))
+             (target (intern (string-upcase (string raw-target)) :keyword))
+             (actuator-fn (gethash target *actuator-registry*)))
+        (when (and meta (null (getf action :meta)))
+          (setf (getf action :meta) meta))
+        (if actuator-fn
+            (funcall actuator-fn action context)
+            (harness-log "ACT ERROR: No actuator registered for '~s'" target))))))
+#+end_src
+
+** System Actuator (execute-system-action)
+#+begin_src lisp
+(defun execute-system-action (action context)
+  "Execute internal harness commands."
+  (declare (ignore context))
+  (let* ((payload (getf action :payload))
+         (cmd (getf payload :action)))
+    (case cmd
+      (:eval
+       (eval (read-from-string (getf payload :code))))
+      (:message
+       (harness-log "ACT [System]: ~a" (getf payload :text)))
+      (t
+       (harness-log "ACT ERROR [System]: Unknown command '~s'" cmd)))))
+#+end_src
+
+** Tool Actuator (execute-tool-action)
+#+begin_src lisp
+(defun execute-tool-action (action context)
+  "Execute a registered cognitive tool."
+  (let* ((payload (getf action :payload))
+         (tool-name (getf payload :tool))
+         (tool-args (getf payload :args))
+         (depth (getf context :depth 0))
+         (meta (getf context :meta))
+         (source (getf meta :source))
+         (tool (gethash (string-downcase (string tool-name)) *cognitive-tools*)))
+    (if tool
+        (handler-case
+            (let* ((clean-args (if (and (listp tool-args) (listp (car tool-args))) (car tool-args) tool-args))
+                   (result (funcall (cognitive-tool-body tool) clean-args)))
+              (when source
+                (dispatch-action (list :TYPE :REQUEST :TARGET source 
+                                       :PAYLOAD (list :ACTION :MESSAGE :TEXT (format-tool-result tool-name result)))
+                                context))
+              (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+                    :PAYLOAD (list :SENSOR :tool-output :RESULT result :TOOL tool-name)))
+          (error (c)
+            (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+                  :PAYLOAD (list :SENSOR :tool-error :TOOL tool-name :MESSAGE (format nil "~a" c)))))
+        (list :TYPE :EVENT :DEPTH (1+ depth) :META meta
+              :PAYLOAD (list :SENSOR :tool-error :MESSAGE (format nil "Tool '~a' not found" tool-name))))))
+#+end_src
+
+** Tool Result Formatting (format-tool-result)
+#+begin_src lisp
+(defun format-tool-result (tool-name result)
+  "Format a tool result for display."
+  (if (listp result)
+      (let ((status (getf result :status))
+            (content (getf result :content))
+            (msg (getf result :message)))
+        (cond
+          ((and (eq status :success) content) (format nil "~a" content))
+          ((and (eq status :error) msg) (format nil "ERROR [~a]: ~a" tool-name msg))
+          (t (format nil "TOOL [~a] RESULT: ~s" tool-name result))))
+      (format nil "TOOL [~a] RESULT: ~a" tool-name result)))
+#+end_src
+
+** Act Gate (Stage 3)
+#+begin_src lisp
+(defun act-gate (signal)
+  "Final stage of the metabolic pipeline: Actuation."
+  (let* ((approved (getf signal :approved-action))
+         (type (getf signal :type))
+         (meta (getf signal :meta))
+         (source (getf meta :source))
+         (feedback nil))
+    (when approved
+      (let* ((original-type (getf approved :type))
+             (verified (deterministic-verify approved signal)))
+        (if (and (listp verified) (member (getf verified :type) '(:LOG :EVENT)) (not (member original-type '(:LOG :EVENT))))
+            (progn
+              (harness-log "ACT BLOCKED: Action failed last-mile deterministic check.")
+              (setf (getf signal :approved-action) nil)
+              (setf feedback verified))
+            (progn
+              (setf (getf signal :approved-action) verified)
+              (setf approved verified)))))
+
+    (case type
+      (:REQUEST (dispatch-action signal signal))
+      (:LOG (dispatch-action signal signal))
+      (:EVENT
+       (if approved
+           (let* ((target (getf approved :target))
+                  (result (dispatch-action approved signal)))
+             (cond
+               ((and (listp result) (member (getf result :type) '(:EVENT :LOG)))
+                (setf feedback result))
+               ((and result (not (member target *silent-actuators*)))
+                (setf feedback (list :type :EVENT :depth (1+ (getf signal :depth 0)) :meta meta
+                                    :payload (list :sensor :tool-output :result result :tool approved))))))
+           (when source (dispatch-action signal signal)))))
+    (setf (getf signal :status) :acted)
+    feedback))
+#+end_src
+
+* Test Suite
+#+begin_src lisp :tangle ../tests/pipeline-act-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(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-basic
+  (clrhash opencortex::*skills-registry*)
+  (let* ((signal (list :type :EVENT :status nil :depth 0 :approved-action '(:target :cli :payload (:text "Hello"))))
+         (result (act-gate signal)))
+    (is (eq :acted (getf signal :status)))
+    (is (null result))))
+#+end_src

harness/communication-validator.lisp

@@ -0,0 +1,9 @@
+(in-package :opencortex)
+
+(defun validate-communication-protocol-schema (msg)
+  "Strict structural validation for incoming protocol messages."
+  (unless (listp msg) (error "Message must be a plist"))
+  (let ((type (proto-get msg :type)))
+    (unless (member type '(:REQUEST :EVENT :RESPONSE :LOG :STATUS))
+      (error "Invalid message type '~a'" type))
+    t))

harness/communication.lisp

@@ -0,0 +1,97 @@
+(in-package :opencortex)
+
+(defvar *actuator-registry* (make-hash-table :test 'equalp)
+  "Global registry mapping target keywords to their physical actuator functions.")
+
+(defun register-actuator (name fn) 
+  "Registers an actuator function. Actuators receive: (ACTION CONTEXT)."
+  (let ((key (if (keywordp name) name (intern (string-upcase (string name)) :keyword))))
+    (setf (gethash key *actuator-registry*) fn)))
+
+(defun sanitize-protocol-message (msg)
+  "Recursively strips non-serializable objects from a protocol plist."
+  (if (and msg (listp msg))
+      (let ((clean nil))
+        (loop for (k v) on msg by #'cddr
+              do (unless (member k '(:reply-stream :socket :stream))
+                   (push k clean)
+                   (push (if (listp v) (sanitize-protocol-message v) v) clean)))
+        (nreverse clean))
+      msg))
+
+(defun frame-message (msg)
+  "Serializes a message plist and prefixes it with a 6-character hex length."
+  (let* ((sanitized (sanitize-protocol-message msg))
+         (payload (let ((*print-pretty* nil) (*read-eval* nil)) (format nil "~s" sanitized)))
+         (len (length payload)))
+    (format nil "~6,'0x~a" len payload)))
+
+(defun read-framed-message (stream)
+  "Reads a hex-length prefixed S-expression from the stream securely."
+  (let ((length-buffer (make-string 6)))
+    (handler-case
+        (progn
+          (loop for char = (peek-char nil stream nil :eof)
+                while (and (not (eq char :eof)) (member char '(#\Space #\Newline #\Tab #\Return)))
+                do (read-char stream))
+          (let ((count (read-sequence length-buffer stream)))
+            (if (< count 6)
+                :eof
+                (let ((len (ignore-errors (parse-integer length-buffer :radix 16))))
+                  (if (not len)
+                      :error
+                      (let ((msg-buffer (make-string len)))
+                        (read-sequence msg-buffer stream)
+                        (let ((*read-eval* nil))
+                          (handler-case (read-from-string msg-buffer)
+                            (error () :error)))))))))
+      (error () :error))))
+
+(defvar *server-socket* nil)
+
+(defun handle-client-connection (socket)
+  "Handles a single TUI/CLI client connection in a dedicated thread."
+  (let ((stream (usocket:socket-stream socket)))
+    (handler-case
+        (progn
+          (format stream "~a" (frame-message (make-hello-message "0.2.0")))
+          (finish-output stream)
+          (loop
+            (let ((msg (read-framed-message stream)))
+              (cond
+                ((eq msg :eof) (return))
+                ((eq msg :error) (return))
+                ((eq (getf msg :type) :health-check)
+                 ;; Handle health check request
+                 (let ((health-msg (list :type :health-response 
+                                          :status (or (and (boundp 'opencortex::*system-health*) 
+                                                          (symbol-value 'opencortex::*system-health*))
+                                                      :unknown)
+                                          :checked-p (or (and (boundp 'opencortex::*health-check-ran*)
+                                                              (symbol-value 'opencortex::*health-check-ran*))
+                                                      nil))))
+                   (format stream "~a" (frame-message health-msg))
+                   (finish-output stream)))
+                (t (inject-stimulus msg :stream stream))))))
+      (error (c) (harness-log "CLIENT ERROR: ~a" c)))
+    (ignore-errors (usocket:socket-close socket))))
+
+(defun start-daemon (&key (port 9105))
+  "Starts the network listener for TUI/CLI clients."
+  (setf *server-socket* (usocket:socket-listen "127.0.0.1" port :reuse-address t))
+  (harness-log "DAEMON: Listening on localhost:~a" port)
+  (bt:make-thread
+   (lambda ()
+     (loop
+       (let ((client-socket (usocket:socket-accept *server-socket*)))
+         (when client-socket
+           (bt:make-thread (lambda () (handle-client-connection client-socket))
+                          :name "opencortex-client-handler")))))
+   :name "opencortex-server-listener"))
+
+(defun make-hello-message (version)
+  "Constructs the standard HELLO handshake message."
+  (list :TYPE :EVENT 
+        :PAYLOAD (list :ACTION :handshake 
+                       :VERSION version 
+                       :CAPABILITIES '(:AUTH :ORG-AST))))

harness/communication.org

@@ -0,0 +1,186 @@
+#+TITLE: Communication Protocol (communication.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:protocol:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle communication.lisp
+
+* Overview
+The ~communication.lisp~ module defines the low-level transport and framing logic for OpenCortex stimuli.
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Actuator Registry
+#+begin_src lisp
+(defvar *actuator-registry* (make-hash-table :test 'equalp)
+  "Global registry mapping target keywords to their physical actuator functions.")
+
+(defun register-actuator (name fn) 
+  "Registers an actuator function. Actuators receive: (ACTION CONTEXT)."
+  (let ((key (if (keywordp name) name (intern (string-upcase (string name)) :keyword))))
+    (setf (gethash key *actuator-registry*) fn)))
+#+end_src
+
+** Message Framing
+#+begin_src lisp
+(defun sanitize-protocol-message (msg)
+  "Recursively strips non-serializable objects from a protocol plist."
+  (if (and msg (listp msg))
+      (let ((clean nil))
+        (loop for (k v) on msg by #'cddr
+              do (unless (member k '(:reply-stream :socket :stream))
+                   (push k clean)
+                   (push (if (listp v) (sanitize-protocol-message v) v) clean)))
+        (nreverse clean))
+      msg))
+
+(defun frame-message (msg)
+  "Serializes a message plist and prefixes it with a 6-character hex length."
+  (let* ((sanitized (sanitize-protocol-message msg))
+         (payload (let ((*print-pretty* nil) (*read-eval* nil)) (format nil "~s" sanitized)))
+         (len (length payload)))
+    (format nil "~6,'0x~a" len payload)))
+
+(defun read-framed-message (stream)
+  "Reads a hex-length prefixed S-expression from the stream securely."
+  (let ((length-buffer (make-string 6)))
+    (handler-case
+        (progn
+          (loop for char = (peek-char nil stream nil :eof)
+                while (and (not (eq char :eof)) (member char '(#\Space #\Newline #\Tab #\Return)))
+                do (read-char stream))
+          (let ((count (read-sequence length-buffer stream)))
+            (if (< count 6)
+                :eof
+                (let ((len (ignore-errors (parse-integer length-buffer :radix 16))))
+                  (if (not len)
+                      :error
+                      (let ((msg-buffer (make-string len)))
+                        (read-sequence msg-buffer stream)
+                        (let ((*read-eval* nil))
+                          (handler-case (read-from-string msg-buffer)
+                            (error () :error)))))))))
+      (error () :error))))
+#+end_src
+
+** Server Listener (start-daemon)
+#+begin_src lisp
+(defvar *server-socket* nil)
+
+(defun handle-client-connection (socket)
+  "Handles a single TUI/CLI client connection in a dedicated thread."
+  (let ((stream (usocket:socket-stream socket)))
+    (handler-case
+        (progn
+          (format stream "~a" (frame-message (make-hello-message "0.2.0")))
+          (finish-output stream)
+          (loop
+            (let ((msg (read-framed-message stream)))
+              (cond
+                ((eq msg :eof) (return))
+                ((eq msg :error) (return))
+                ((eq (getf msg :type) :health-check)
+                 ;; Handle health check request
+                 (let ((health-msg (list :type :health-response 
+                                          :status (or (and (boundp 'opencortex::*system-health*) 
+                                                          (symbol-value 'opencortex::*system-health*))
+                                                      :unknown)
+                                          :checked-p (or (and (boundp 'opencortex::*health-check-ran*)
+                                                              (symbol-value 'opencortex::*health-check-ran*))
+                                                      nil))))
+                   (format stream "~a" (frame-message health-msg))
+                   (finish-output stream)))
+                (t (inject-stimulus msg :stream stream))))))
+      (error (c) (harness-log "CLIENT ERROR: ~a" c)))
+    (ignore-errors (usocket:socket-close socket))))
+
+(defun start-daemon (&key (port 9105))
+  "Starts the network listener for TUI/CLI clients."
+  (setf *server-socket* (usocket:socket-listen "127.0.0.1" port :reuse-address t))
+  (harness-log "DAEMON: Listening on localhost:~a" port)
+  (bt:make-thread
+   (lambda ()
+     (loop
+       (let ((client-socket (usocket:socket-accept *server-socket*)))
+         (when client-socket
+           (bt:make-thread (lambda () (handle-client-connection client-socket))
+                          :name "opencortex-client-handler")))))
+   :name "opencortex-server-listener"))
+#+end_src
+
+** Handshake Logic
+#+begin_src lisp
+(defun make-hello-message (version)
+  "Constructs the standard HELLO handshake message."
+  (list :TYPE :EVENT 
+        :PAYLOAD (list :ACTION :handshake 
+                       :VERSION version 
+                       :CAPABILITIES '(:AUTH :ORG-AST))))
+#+end_src
+
+** Structural Validation
+#+begin_src lisp :tangle communication-validator.lisp
+(in-package :opencortex)
+
+(defun validate-communication-protocol-schema (msg)
+  "Strict structural validation for incoming protocol messages."
+  (unless (listp msg) (error "Message must be a plist"))
+  (let ((type (proto-get msg :type)))
+    (unless (member type '(:REQUEST :EVENT :RESPONSE :LOG :STATUS))
+      (error "Invalid message type '~a'" type))
+    t))
+#+end_src
+
+** Protocol Smoke Test (manual for REPL evaluation)
+The following script connects to a running daemon, sends "hi", and reads the response. Useful for verifying the daemon is alive and the framing protocol works end-to-end.
+
+#+begin_src lisp :tangle no
+(defun test-daemon-protocol ()
+  (handler-case
+      (let* ((socket (usocket:socket-connect "127.0.0.1" 9105))
+             (stream (usocket:socket-stream socket)))
+        (format t "Connected.~%")
+        (let* ((len-buf (make-string 6))
+               (count (read-sequence len-buf stream)))
+          (when (= count 6)
+            (let* ((len (parse-integer len-buf :radix 16))
+                   (msg-buf (make-string len)))
+              (read-sequence msg-buf stream)
+              (format t "HELLO: ~a~%" msg-buf))))
+        (let* ((msg '(:TYPE :EVENT :META (:SOURCE :tui) :PAYLOAD (:SENSOR :user-input :TEXT "hi")))
+               (framed (frame-message msg)))
+          (format stream "~a" framed)
+          (finish-output stream)
+          (let* ((len-buf (make-string 6))
+                 (count (read-sequence len-buf stream)))
+            (when (= count 6)
+              (let* ((len (parse-integer len-buf :radix 16))
+                     (msg-buf (make-string len)))
+                (read-sequence msg-buf stream)
+                (format t "Response: ~a~%" msg-buf)))))
+        (usocket:socket-close socket))
+    (error (c) (format t "Error: ~a~%" c))))
+#+end_src
+
+* Test Suite
+#+begin_src lisp :tangle ../tests/communication-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(defpackage :opencortex-communication-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:communication-protocol-suite))
+(in-package :opencortex-communication-tests)
+
+(def-suite communication-protocol-suite :description "Communication Protocol Suite")
+(in-suite communication-protocol-suite)
+
+(test test-framing
+  (let* ((msg '(:type :EVENT :payload (:action :handshake)))
+         (framed (frame-message msg)))
+    (is (string= "00002C" (string-upcase (subseq framed 0 6))))))
+#+end_src

harness/context.lisp

@@ -34,8 +34,8 @@
 (defun context-get-skill-source (skill-name)
   "Reads the raw literate source of a specific skill for inspection."
   (let* ((filename (format nil "~a.org" skill-name))
-         (skills-dir-str (or (uiop:getenv "SKILLS_DIR") (namestring (merge-pathnames "notes/" (user-homedir-pathname)))))
-         (skills-dir (uiop:ensure-directory-pathname (context-resolve-path skills-dir-str)))
+         (data-dir (uiop:ensure-directory-pathname (or (uiop:getenv "OC_DATA_DIR") (namestring (merge-pathnames ".local/share/opencortex/" (user-homedir-pathname))))))
+         (skills-dir (merge-pathnames "skills/" data-dir))
          (full-path (merge-pathnames filename skills-dir)))
     (if (uiop:file-exists-p full-path) (uiop:read-file-string full-path) nil)))
 
@@ -60,9 +60,6 @@
                          (cosine-similarity foveal-vector obj-vector)
                          0.0))
          (is-semantically-relevant (>= similarity threshold))
-         ;; We always render depth 1 and 2 (Projects and main tasks).
-         ;; We always render the foveal node and its immediate children.
-         ;; We render deeper nodes ONLY if they are semantically relevant.
          (should-render (or (<= depth 2) is-foveal is-semantically-relevant))
          (output ""))
     
@@ -72,15 +69,12 @@
         (setf output (concatenate 'string output (format nil ":SEMANTIC_SCORE: ~,2f~%" similarity))))
       (setf output (concatenate 'string output (format nil ":END:~%")))
       
-      ;; Only include full body content if this is the Foveal focus or highly relevant
       (when (and content (or is-foveal is-semantically-relevant))
         (setf output (concatenate 'string output content (string #\Newline))))
       
-      ;; Recursively render children
       (dolist (child-id children)
         (let ((child-obj (lookup-object child-id)))
           (when child-obj
-            ;; If the current node is Foveal, its children should be rendered (depth effectively resets)
             (let ((next-foveal (if is-foveal child-id foveal-id)))
               (setf output (concatenate 'string output 
                                         (context-render-to-org child-obj 
@@ -91,23 +85,61 @@
     output))
 
 (defun context-resolve-path (path-string)
-  "Expands all environment variables ($VAR) within a path string."
-  (if (and (stringp path-string) (search "$" path-string))
-      (let ((result path-string))
-        (ppcre:do-register-groups (var-name) ("\\$([A-Za-z0-9_]+)" path-string)
-          (let ((var-val (uiop:getenv var-name)))
-            (when var-val
-              (setf result (ppcre:regex-replace (format nil "\\$~a" var-name) result var-val)))))
-        result)
-      path-string))
+  "Expands environment variables and strips literal quotes from a path string."
+  (let ((path (if (stringp path-string) 
+                  (string-trim '(#\" #\' #\Space) path-string)
+                  path-string)))
+    (if (and (stringp path) (search "$" path))
+        (let ((result path))
+          (ppcre:do-register-groups (var-name) ("\\$([A-Za-z0-9_]+)" path)
+            (let ((var-val (uiop:getenv var-name)))
+              (when var-val
+                (setf result (ppcre:regex-replace (format nil "\\$~a" var-name) result var-val)))))
+          result)
+        path)))
+
+(defun context-object-privacy-filtered-p (obj)
+  "Returns T if an org-object's :TAGS attribute matches bouncer-privacy-tags."
+  (let* ((attrs (org-object-attributes obj))
+         (tags (getf attrs :TAGS))
+         (privacy-tags (and (find-package :opencortex.skills.org-skill-bouncer)
+                            (symbol-value
+                             (find-symbol "BOUNCER-PRIVACY-TAGS"
+                                          :opencortex.skills.org-skill-bouncer)))))
+    (when (and tags privacy-tags)
+      (let ((tag-list (if (listp tags) tags (list tags))))
+        (some (lambda (tag)
+                (some (lambda (private)
+                        (string-equal (string-trim '(#\:) tag)
+                                      (string-trim '(#\:) private)))
+                      privacy-tags))
+              tag-list)))))
+
+(defun context-object-privacy-filtered-p (obj)
+  "Returns T if an org-object's :TAGS attribute matches bouncer-privacy-tags."
+  (let* ((attrs (org-object-attributes obj))
+         (tags (getf attrs :TAGS))
+         (privacy-tags (and (find-package :opencortex.skills.org-skill-bouncer)
+                            (symbol-value
+                             (find-symbol "BOUNCER-PRIVACY-TAGS"
+                                          :opencortex.skills.org-skill-bouncer)))))
+    (when (and tags privacy-tags)
+      (let ((tag-list (if (listp tags) tags (list tags))))
+        (some (lambda (tag)
+                (some (lambda (private)
+                        (string-equal (string-trim '(#\:) tag)
+                                      (string-trim '(#\:) private)))
+                      privacy-tags))
+              tag-list)))))
 
 (defun context-assemble-global-awareness (&optional signal)
-  "Produces a high-level skeletal outline of the current Memory for the LLM."
+  "Produces a high-level skeletal outline of the current Memory for the LLM.
+Privacy-filtered objects (matching *privacy-filter-tags*) are excluded."
   (let* ((foveal-id (or (getf signal :foveal-focus) 
                         (ignore-errors (getf (getf signal :payload) :target-id))))
-         (projects (context-get-active-projects))
-         (output "GLOBAL MEMEX AWARENESS (Peripheral Vision):
-"))
+         (all-projects (context-get-active-projects))
+         (projects (remove-if #'context-object-privacy-filtered-p all-projects))
+         (output (format nil "GLOBAL MEMEX AWARENESS (Peripheral Vision):~%")))
     (if projects
         (dolist (project projects)
           (setf output (concatenate 'string output

harness/context.org

@@ -0,0 +1,229 @@
+#+TITLE: Context API (context.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:context:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle context.lisp
+
+* Overview
+The *Context API* (Peripheral Vision) provides the opencortex with the ability to selectively prune and present its memory to the LLM. It implements a **Foveal-Peripheral model**, where the current task is shown in high detail (foveal), while the broader Memex structure is shown as a skeletal outline (peripheral).
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Memory Query (context-query-store)
+#+begin_src lisp
+(defun context-query-store (&key tag todo-state type)
+  "Filters the Memory based on tags, todo states, or types."
+  (let ((results nil))
+    (maphash (lambda (id obj)
+               (declare (ignore id))
+               (let* ((attrs (org-object-attributes obj)) (state (getf attrs :TODO-STATE)) (match t))
+                 (when (and type (not (eq (org-object-type obj) type))) (setf match nil))
+                 (when tag (unless (search tag (format nil "~a" (getf attrs :TAGS)) :test #'string-equal) (setf match nil)))
+                 (when (and todo-state (not (equal state todo-state))) (setf match nil))
+                 (when match (push obj results))))
+             *memory*)
+    results))
+#+end_src
+
+** Active Projects (context-get-active-projects)
+#+begin_src lisp
+(defun context-get-active-projects ()
+  "Returns headlines tagged as 'project' that are not yet marked DONE."
+  (remove-if (lambda (obj) (equal (getf (org-object-attributes obj) :TODO-STATE) "DONE"))
+             (context-query-store :tag "project" :type :HEADLINE)))
+#+end_src
+
+** Completed Tasks (context-get-recent-completed-tasks)
+#+begin_src lisp
+(defun context-get-recent-completed-tasks () 
+  "Retrieves recently finished tasks from the store."
+  (context-query-store :todo-state "DONE" :type :HEADLINE))
+#+end_src
+
+** Capability Discovery (context-list-all-skills)
+#+begin_src lisp
+(defun context-list-all-skills ()
+  "Provides a sorted overview of currently loaded system capabilities."
+  (let ((results nil))
+    (maphash (lambda (name skill)
+               (declare (ignore name))
+               (push (list :name (skill-name skill) :priority (skill-priority skill) :dependencies (skill-dependencies skill)) results))
+             *skills-registry*)
+    (sort results #'> :key (lambda (x) (getf x :priority)))))
+#+end_src
+
+** Skill Inspection (context-get-skill-source)
+#+begin_src lisp
+(defun context-get-skill-source (skill-name)
+  "Reads the raw literate source of a specific skill for inspection."
+  (let* ((filename (format nil "~a.org" skill-name))
+         (data-dir (uiop:ensure-directory-pathname (or (uiop:getenv "OC_DATA_DIR") (namestring (merge-pathnames ".local/share/opencortex/" (user-homedir-pathname))))))
+         (skills-dir (merge-pathnames "skills/" data-dir))
+         (full-path (merge-pathnames filename skills-dir)))
+    (if (uiop:file-exists-p full-path) (uiop:read-file-string full-path) nil)))
+#+end_src
+
+** Harness Logs (context-get-system-logs)
+#+begin_src lisp
+(defun context-get-system-logs (&optional limit)
+  "Retrieves the most recent lines from the harness's internal log."
+  (let ((log-limit (or limit (ignore-errors (parse-integer (uiop:getenv "CONTEXT_LOG_LIMIT"))) 20)))
+    (bt:with-lock-held (*logs-lock*)
+      (let ((count (min log-limit (length *system-logs*)))) 
+        (subseq *system-logs* 0 count)))))
+#+end_src
+
+** AST to Org Rendering (context-render-to-org)
+#+begin_src lisp
+(defun context-render-to-org (obj &key (depth 1) (foveal-id nil) semantic-threshold (foveal-vector nil))
+  "Recursively renders an org-object and its children to an Org string using a Foveal-Peripheral Hybrid model."
+  (let* ((id (org-object-id obj))
+         (is-foveal (equal id foveal-id))
+         (title (or (getf (org-object-attributes obj) :TITLE) "Untitled"))
+         (content (org-object-content obj))
+         (children (org-object-children obj))
+         (stars (make-string depth :initial-element #\*))
+         (obj-vector (org-object-vector obj))
+         (threshold (or semantic-threshold (ignore-errors (read-from-string (uiop:getenv "CONTEXT_SEMANTIC_THRESHOLD"))) 0.75))
+         (similarity (if (and foveal-vector obj-vector (not is-foveal))
+                         (cosine-similarity foveal-vector obj-vector)
+                         0.0))
+         (is-semantically-relevant (>= similarity threshold))
+         (should-render (or (<= depth 2) is-foveal is-semantically-relevant))
+         (output ""))
+    
+    (when should-render
+      (setf output (format nil "~a ~a~%:PROPERTIES:~%:ID: ~a~%" stars title id))
+      (when is-semantically-relevant
+        (setf output (concatenate 'string output (format nil ":SEMANTIC_SCORE: ~,2f~%" similarity))))
+      (setf output (concatenate 'string output (format nil ":END:~%")))
+      
+      (when (and content (or is-foveal is-semantically-relevant))
+        (setf output (concatenate 'string output content (string #\Newline))))
+      
+      (dolist (child-id children)
+        (let ((child-obj (lookup-object child-id)))
+          (when child-obj
+            (let ((next-foveal (if is-foveal child-id foveal-id)))
+              (setf output (concatenate 'string output 
+                                        (context-render-to-org child-obj 
+                                                               :depth (1+ depth) 
+                                                               :foveal-id next-foveal
+                                                               :semantic-threshold threshold
+                                                               :foveal-vector foveal-vector))))))))
+    output))
+#+end_src
+
+** Path Resolution (context-resolve-path)
+#+begin_src lisp
+(defun context-resolve-path (path-string)
+  "Expands environment variables and strips literal quotes from a path string."
+  (let ((path (if (stringp path-string) 
+                  (string-trim '(#\" #\' #\Space) path-string)
+                  path-string)))
+    (if (and (stringp path) (search "$" path))
+        (let ((result path))
+          (ppcre:do-register-groups (var-name) ("\\$([A-Za-z0-9_]+)" path)
+            (let ((var-val (uiop:getenv var-name)))
+              (when var-val
+                (setf result (ppcre:regex-replace (format nil "\\$~a" var-name) result var-val)))))
+          result)
+        path)))
+#+end_src
+
+** Privacy filter for context assembly
+Checks if an org-object has tags matching ~*privacy-filter-tags*~. Objects with matching tags are excluded from the LLM context window.
+#+begin_src lisp
+(defun context-object-privacy-filtered-p (obj)
+  "Returns T if an org-object's :TAGS attribute matches bouncer-privacy-tags."
+  (let* ((attrs (org-object-attributes obj))
+         (tags (getf attrs :TAGS))
+         (privacy-tags (and (find-package :opencortex.skills.org-skill-bouncer)
+                            (symbol-value
+                             (find-symbol "BOUNCER-PRIVACY-TAGS"
+                                          :opencortex.skills.org-skill-bouncer)))))
+    (when (and tags privacy-tags)
+      (let ((tag-list (if (listp tags) tags (list tags))))
+        (some (lambda (tag)
+                (some (lambda (private)
+                        (string-equal (string-trim '(#\:) tag)
+                                      (string-trim '(#\:) private)))
+                      privacy-tags))
+              tag-list)))))
+#+end_src
+
+** Global Awareness (context-assemble-global-awareness)
+#+begin_src lisp
+(defun context-object-privacy-filtered-p (obj)
+  "Returns T if an org-object's :TAGS attribute matches bouncer-privacy-tags."
+  (let* ((attrs (org-object-attributes obj))
+         (tags (getf attrs :TAGS))
+         (privacy-tags (and (find-package :opencortex.skills.org-skill-bouncer)
+                            (symbol-value
+                             (find-symbol "BOUNCER-PRIVACY-TAGS"
+                                          :opencortex.skills.org-skill-bouncer)))))
+    (when (and tags privacy-tags)
+      (let ((tag-list (if (listp tags) tags (list tags))))
+        (some (lambda (tag)
+                (some (lambda (private)
+                        (string-equal (string-trim '(#\:) tag)
+                                      (string-trim '(#\:) private)))
+                      privacy-tags))
+              tag-list)))))
+
+(defun context-assemble-global-awareness (&optional signal)
+  "Produces a high-level skeletal outline of the current Memory for the LLM.
+Privacy-filtered objects (matching *privacy-filter-tags*) are excluded."
+  (let* ((foveal-id (or (getf signal :foveal-focus) 
+                        (ignore-errors (getf (getf signal :payload) :target-id))))
+         (all-projects (context-get-active-projects))
+         (projects (remove-if #'context-object-privacy-filtered-p all-projects))
+         (output (format nil "GLOBAL MEMEX AWARENESS (Peripheral Vision):~%")))
+    (if projects
+        (dolist (project projects)
+          (setf output (concatenate 'string output
+                                    (context-render-to-org project :foveal-id foveal-id))))
+        (setf output (concatenate 'string output "No active projects found.~%")))
+    output))
+#+end_src
+
+* Test Suite
+
+#+begin_src lisp :tangle ../tests/peripheral-vision-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(defpackage :opencortex-peripheral-vision-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:vision-suite))
+(in-package :opencortex-peripheral-vision-tests)
+
+(def-suite vision-suite :description "Verification of Foveal-Peripheral context model.")
+(in-suite vision-suite)
+
+(test test-foveal-rendering
+  (clrhash opencortex::*memory*)
+  (let* ((ast '(:type :HEADLINE :properties (:ID "proj-root" :TITLE "Project" :TAGS ("project"))
+                :contents ((:type :HEADLINE :properties (:ID "node-foveal" :TITLE "Foveal Node")
+                            :raw-content "FOVEAL CONTENT" :contents nil)
+                           (:type :HEADLINE :properties (:ID "node-peripheral" :TITLE "Peripheral Node")
+                            :raw-content "PERIPHERAL CONTENT" :contents nil)))))
+    (ingest-ast ast)
+    (let ((output (context-assemble-global-awareness (list :foveal-focus "node-foveal"))))
+      (is (search "FOVEAL CONTENT" output))
+      (is (search "* Peripheral Node" output))
+      (is (not (search "PERIPHERAL CONTENT" output))))))
+
+(test test-awareness-budget
+  (clrhash opencortex::*memory*)
+  (ingest-ast '(:type :HEADLINE :properties (:ID "p1" :TITLE "Project 1" :TAGS ("project")) :contents nil))
+  (ingest-ast '(:type :HEADLINE :properties (:ID "p2" :TITLE "Project 2" :TAGS ("project")) :contents nil))
+  (let ((output (context-assemble-global-awareness)))
+    (is (search "Project 1" output))
+    (is (search "Project 2" output))))
+#+end_src

harness/doctor.lisp

@@ -0,0 +1,81 @@
+(in-package :opencortex)
+
+(defvar *doctor-required-binaries* '("sbcl" "emacs" "git" "socat" "nc")
+  "List of external binaries required for full system operation.")
+
+(defun doctor-check-dependencies ()
+  "Verifies that required external binaries are available in the PATH via a shell probe."
+  (let ((all-ok t))
+    (harness-log "DOCTOR: Checking system dependencies...")
+    (dolist (dep *doctor-required-binaries*)
+      (let ((path (ignore-errors 
+                    (uiop:run-program (list "which" dep) 
+                                      :output :string :ignore-error-status t))))
+        (if (and path (> (length path) 0))
+            (harness-log "  [OK] Found ~a" dep)
+            (progn
+              (harness-log "  [FAIL] Missing binary: ~a" dep)
+              (setf all-ok nil)))))
+    all-ok))
+
+(defun doctor-check-env ()
+  "Validates XDG directories and environment configuration against the POSIX standard."
+  (harness-log "DOCTOR: Checking XDG environment...")
+  (let ((all-ok t)
+        (config-dir (uiop:getenv "OC_CONFIG_DIR"))
+        (data-dir (uiop:getenv "OC_DATA_DIR"))
+        (state-dir (uiop:getenv "OC_STATE_DIR"))
+        (memex-dir (uiop:getenv "MEMEX_DIR")))
+    
+    (flet ((check-dir (name path critical)
+             (if (and path (> (length path) 0))
+                 (if (uiop:directory-exists-p path)
+                     (harness-log "  [OK] ~a: ~a" name path)
+                     (progn
+                       (harness-log "  [FAIL] ~a directory missing: ~a" name path)
+                       (when critical (setf all-ok nil))))
+                 (progn
+                   (harness-log "  [FAIL] ~a variable not set." name)
+                   (when critical (setf all-ok nil))))))
+
+      (check-dir "Config (OC_CONFIG_DIR)" config-dir t)
+      (check-dir "Data (OC_DATA_DIR)" data-dir t)
+      (check-dir "State (OC_STATE_DIR)" state-dir t)
+      (check-dir "Memex (MEMEX_DIR)" memex-dir t))
+    all-ok))
+
+(defun doctor-check-llm ()
+  "Tests connectivity to primary LLM providers. Non-critical fallback allowed."
+  (harness-log "DOCTOR: Checking LLM connectivity...")
+  (let ((openrouter-key (uiop:getenv "OPENROUTER_API_KEY")))
+    (if (and openrouter-key (> (length openrouter-key) 0))
+        (progn
+          (harness-log "  [OK] OpenRouter API Key detected.")
+          t)
+        (progn
+          (harness-log "  [WARN] No OpenRouter API Key. Falling back to local inference only.")
+          t))))
+
+(defun doctor-run-all ()
+  "Executes the full diagnostic suite and returns T if system is healthy."
+  (harness-log "==================================================")
+  (harness-log " OPENCORTEX DOCTOR: Commencing Health Check")
+  (harness-log "==================================================")
+  (let ((dep-ok (doctor-check-dependencies))
+        (env-ok (doctor-check-env))
+        (llm-ok (doctor-check-llm)))
+    (declare (ignore llm-ok))
+    (harness-log "==================================================")
+    (if (and dep-ok env-ok)
+        (progn
+          (harness-log " ✓ SYSTEM HEALTHY: Ready for ignition.")
+          t)
+        (progn
+          (harness-log " ✗ SYSTEM UNHEALTHY: Fix the errors above.")
+          nil))))
+
+(defun doctor-main ()
+  "Entry point for the 'doctor' CLI command."
+  (if (doctor-run-all)
+      (uiop:quit 0)
+      (uiop:quit 1)))

harness/doctor.org

@@ -0,0 +1,163 @@
+#+PROPERTY: header-args:lisp :tangle doctor.lisp
+#+TITLE: System Diagnostic Doctor (doctor.org)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:setup:diagnostic:
+#+STARTUP: content
+
+* Overview
+The *System Doctor* is the primary diagnostic utility for the OpenCortex. Its purpose is to transform opaque startup failures into actionable engineering reports. 
+
+By centralizing environment validation, we ensure that the "Brain" never attempts to boot in a compromised or incomplete state.
+
+* Phase A: Demand (Thinking)
+** The XDG Standard Rationale
+To ensure OpenCortex behaves as a first-class POSIX citizen, we adopt the **XDG Base Directory Specification**. This separates the system into four logical layers:
+
+1. **Configuration (`~/.config/opencortex`)**: User-editable settings and secrets.
+2. **Data (`~/.local/share/opencortex`)**: Tangled Lisp engine artifacts (immutable by user).
+3. **State (`~/.local/state/opencortex`)**: Dynamic persistence like brain snapshots.
+4. **Bin (`~/.local/bin`)**: The CLI shim for global invocation.
+
+** The Detection Invariant: Shell Probing
+Common Lisp's `getenv` is strictly typed in SBCL. The Doctor must ensure that missing variables are handled as logic failures, not type crashes. Furthermore, binary detection must use a shell probe (`command -v` or `which`) to account for varying `$PATH` inheritance between interactive and headless sessions.
+
+* Phase B: Protocol (Success Criteria)
+
+** Package Context
+#+begin_src lisp :tangle ../tests/doctor-tests.lisp
+(defpackage :opencortex-doctor-tests
+  (:use :cl :fiveam :opencortex)
+  (:export #:doctor-suite))
+
+(in-package :opencortex-doctor-tests)
+
+(def-suite doctor-suite :description "Verification of the System Doctor diagnostic logic")
+(in-suite doctor-suite)
+#+end_src
+
+** Dependency Tests
+#+begin_src lisp :tangle ../tests/doctor-tests.lisp
+(test test-dependency-check-fail
+  "Verify that missing binaries are correctly identified as failures."
+  (let ((opencortex::*doctor-required-binaries* '("non-existent-binary-123")))
+    (is (null (opencortex:doctor-check-dependencies)))))
+#+end_src
+
+** Environment Tests
+#+begin_src lisp :tangle ../tests/doctor-tests.lisp
+(test test-env-validation-fail
+  "Verify that an invalid MEMEX_DIR triggers a critical failure."
+  (let ((old-m (uiop:getenv "MEMEX_DIR"))
+        (old-d (uiop:getenv "OC_DATA_DIR")))
+    (unwind-protect
+         (progn
+           (setf (uiop:getenv "MEMEX_DIR") "/non/existent/path/999")
+           (is (null (opencortex:doctor-check-env))))
+      (setf (uiop:getenv "MEMEX_DIR") (or old-m ""))
+      (setf (uiop:getenv "OC_DATA_DIR") (or old-d "")))))
+#+end_src
+
+* Phase C: Implementation (Build)
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Global Configuration
+#+begin_src lisp
+(defvar *doctor-required-binaries* '("sbcl" "emacs" "git" "socat" "nc")
+  "List of external binaries required for full system operation.")
+#+end_src
+
+** Dependency Verification
+#+begin_src lisp
+(defun doctor-check-dependencies ()
+  "Verifies that required external binaries are available in the PATH via a shell probe."
+  (let ((all-ok t))
+    (harness-log "DOCTOR: Checking system dependencies...")
+    (dolist (dep *doctor-required-binaries*)
+      (let ((path (ignore-errors 
+                    (uiop:run-program (list "which" dep) 
+                                      :output :string :ignore-error-status t))))
+        (if (and path (> (length path) 0))
+            (harness-log "  [OK] Found ~a" dep)
+            (progn
+              (harness-log "  [FAIL] Missing binary: ~a" dep)
+              (setf all-ok nil)))))
+    all-ok))
+#+end_src
+
+** Environment & XDG Validation
+#+begin_src lisp
+(defun doctor-check-env ()
+  "Validates XDG directories and environment configuration against the POSIX standard."
+  (harness-log "DOCTOR: Checking XDG environment...")
+  (let ((all-ok t)
+        (config-dir (uiop:getenv "OC_CONFIG_DIR"))
+        (data-dir (uiop:getenv "OC_DATA_DIR"))
+        (state-dir (uiop:getenv "OC_STATE_DIR"))
+        (memex-dir (uiop:getenv "MEMEX_DIR")))
+    
+    (flet ((check-dir (name path critical)
+             (if (and path (> (length path) 0))
+                 (if (uiop:directory-exists-p path)
+                     (harness-log "  [OK] ~a: ~a" name path)
+                     (progn
+                       (harness-log "  [FAIL] ~a directory missing: ~a" name path)
+                       (when critical (setf all-ok nil))))
+                 (progn
+                   (harness-log "  [FAIL] ~a variable not set." name)
+                   (when critical (setf all-ok nil))))))
+
+      (check-dir "Config (OC_CONFIG_DIR)" config-dir t)
+      (check-dir "Data (OC_DATA_DIR)" data-dir t)
+      (check-dir "State (OC_STATE_DIR)" state-dir t)
+      (check-dir "Memex (MEMEX_DIR)" memex-dir t))
+    all-ok))
+#+end_src
+
+** LLM Connectivity
+#+begin_src lisp
+(defun doctor-check-llm ()
+  "Tests connectivity to primary LLM providers. Non-critical fallback allowed."
+  (harness-log "DOCTOR: Checking LLM connectivity...")
+  (let ((openrouter-key (uiop:getenv "OPENROUTER_API_KEY")))
+    (if (and openrouter-key (> (length openrouter-key) 0))
+        (progn
+          (harness-log "  [OK] OpenRouter API Key detected.")
+          t)
+        (progn
+          (harness-log "  [WARN] No OpenRouter API Key. Falling back to local inference only.")
+          t))))
+#+end_src
+
+** Orchestration
+#+begin_src lisp
+(defun doctor-run-all ()
+  "Executes the full diagnostic suite and returns T if system is healthy."
+  (harness-log "==================================================")
+  (harness-log " OPENCORTEX DOCTOR: Commencing Health Check")
+  (harness-log "==================================================")
+  (let ((dep-ok (doctor-check-dependencies))
+        (env-ok (doctor-check-env))
+        (llm-ok (doctor-check-llm)))
+    (declare (ignore llm-ok))
+    (harness-log "==================================================")
+    (if (and dep-ok env-ok)
+        (progn
+          (harness-log " ✓ SYSTEM HEALTHY: Ready for ignition.")
+          t)
+        (progn
+          (harness-log " ✗ SYSTEM UNHEALTHY: Fix the errors above.")
+          nil))))
+#+end_src
+
+** CLI Entry Point
+#+begin_src lisp
+(defun doctor-main ()
+  "Entry point for the 'doctor' CLI command."
+  (if (doctor-run-all)
+      (uiop:quit 0)
+      (uiop:quit 1)))
+#+end_src

harness/loop.lisp

@@ -0,0 +1,136 @@
+(in-package :opencortex)
+
+(defvar *interrupt-flag* nil
+  "Atomic flag set by signal handlers to trigger graceful shutdown.")
+
+(defvar *interrupt-lock* (bt:make-lock "harness-interrupt-lock")
+  "Mutex protecting *interrupt-flag* access.")
+
+(defvar *heartbeat-thread* nil
+  "Handle to the heartbeat thread.")
+
+(defun process-signal (signal)
+  "The entry point to the Metabolic Pipeline: Perceive -> Reason -> Act."
+  (let ((current-signal signal))
+    (loop while current-signal do
+      (let ((depth (getf current-signal :depth 0))
+            (meta (getf current-signal :meta)))
+        (when (> depth 10)
+          (harness-log "METABOLISM ERROR: Max recursion depth reached.")
+          (return nil))
+
+        (when (bt:with-lock-held (*interrupt-lock*) *interrupt-flag*)
+          (harness-log "METABOLISM: Interrupted by shutdown signal.")
+          (return nil))
+
+        (handler-case
+            (progn
+              (setf current-signal (perceive-gate current-signal))
+              (setf current-signal (reason-gate current-signal))
+              (let ((feedback (act-gate current-signal)))
+                (if feedback
+                    (progn
+                      (unless (getf feedback :meta) (setf (getf feedback :meta) meta))
+                      (setf current-signal feedback))
+                    (setf current-signal nil))))
+          (error (c)
+            (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
+              (harness-log "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
+              (unless (member sensor '(:loop-error :tool-error :syntax-error))
+                (harness-log "CRITICAL ERROR: Initiating Micro-Rollback.")
+                (rollback-memory 0))
+              (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
+                  (setf current-signal nil)
+                  (setf current-signal
+                        (list :type :EVENT :depth (1+ depth) :meta meta
+                              :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth)))))))))))
+
+(defvar *auto-save-interval* 300)
+(defvar *heartbeat-save-counter* 0)
+
+(defun start-heartbeat ()
+  "Starts the background heartbeat thread."
+  (let ((interval (or (ignore-errors (parse-integer (uiop:getenv "HEARTBEAT_INTERVAL"))) 60))
+        (auto-save (or (ignore-errors (parse-integer (uiop:getenv "MEMORY_AUTO_SAVE_INTERVAL"))) *auto-save-interval*)))
+    (setf *auto-save-interval* auto-save)
+    (setf *heartbeat-save-counter* 0)
+
+    (setf *heartbeat-thread*
+          (bt:make-thread
+           (lambda ()
+             (loop
+               (sleep interval)
+               (incf *heartbeat-save-counter*)
+               (when (>= *heartbeat-save-counter* (/ *auto-save-interval* interval))
+                 (setf *heartbeat-save-counter* 0)
+                 (save-memory-to-disk))
+               (inject-stimulus
+                 (list :type :EVENT :payload (list :sensor :heartbeat :unix-time (get-universal-time))))))
+           :name "opencortex-heartbeat"))))
+
+(defvar *shutdown-save-enabled* t)
+
+(defvar *system-health* :unknown
+  "Current system health status: :healthy, :degraded, :unhealthy, or :unknown.")
+
+(defvar *health-check-ran* nil
+  "Flag indicating if initial health check has completed.")
+
+(defun run-startup-health-check ()
+  "Runs the doctor diagnostics on startup. Returns health status."
+  (format t "~%")
+  (format t "==================================================~%")
+  (format t " DOCTOR: Running Startup Health Check~%")
+  (format t "==================================================~%")
+  (handler-case
+      (progn
+         (when (fboundp 'doctor-run-all)
+           (let ((result (doctor-run-all)))
+            (setf *health-check-ran* t)
+            (if result
+                (progn
+                  (setf *system-health* :healthy)
+                  (format t "DAEMON: Health check passed. Starting services.~%"))
+                (progn
+                  (setf *system-health* :degraded)
+                  (format t "DAEMON: Health check found issues.~%")
+                  (format t "         Run 'opencortex doctor --fix' to repair.~%")))))
+        (setf *health-check-ran* t))
+    (error (c)
+      (format t "DOCTOR ERROR: ~a~%" c)
+      (setf *system-health* :unhealthy)
+      (setf *health-check-ran* t)))
+  (format t "==================================================~%~%"))
+
+(defun main ()
+  "Entry point for OpenCortex. Initializes the system and enters idle loop."
+  (let* ((home (uiop:getenv "HOME"))
+         (env-file (uiop:merge-pathnames* ".config/opencortex/.env" (uiop:ensure-directory-pathname home))))
+    (when (uiop:file-exists-p env-file)
+      (cl-dotenv:load-env env-file)))
+
+  (load-memory-from-disk)
+  (initialize-actuators)
+  (initialize-all-skills)
+  
+  ;; Run proactive doctor before starting services
+  (run-startup-health-check)
+  
+  (start-heartbeat)
+  (start-daemon)
+
+  #+sbcl
+  (sb-sys:enable-interrupt sb-unix:sigint
+                            (lambda (sig code scp)
+                              (declare (ignore sig code scp))
+                              (harness-log "SHUTDOWN: SIGINT received. Saving memory...")
+                              (when *shutdown-save-enabled* (save-memory-to-disk))
+                              (uiop:quit 0)))
+
+  (let ((sleep-interval (or (ignore-errors (parse-integer (uiop:getenv "DAEMON_SLEEP_INTERVAL"))) 3600)))
+    (loop
+      (when (bt:with-lock-held (*interrupt-lock*) *interrupt-flag*)
+        (harness-log "SHUTDOWN: Interrupt flag set. Saving memory...")
+        (when *shutdown-save-enabled* (save-memory-to-disk))
+        (return))
+      (sleep sleep-interval))))

harness/loop.org

@@ -0,0 +1,198 @@
+#+TITLE: The Metabolic Loop (loop.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:loop:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle loop.lisp
+
+* Overview
+The Metabolic Loop is the fundamental rhythm of OpenCortex: the continuous processing of signals from perception through cognition to action.
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Global Variables (Thread-Safe)
+#+begin_src lisp
+(defvar *interrupt-flag* nil
+  "Atomic flag set by signal handlers to trigger graceful shutdown.")
+
+(defvar *interrupt-lock* (bt:make-lock "harness-interrupt-lock")
+  "Mutex protecting *interrupt-flag* access.")
+
+(defvar *heartbeat-thread* nil
+  "Handle to the heartbeat thread.")
+#+end_src
+
+** Core Engine (process-signal)
+#+begin_src lisp
+(defun process-signal (signal)
+  "The entry point to the Metabolic Pipeline: Perceive -> Reason -> Act."
+  (let ((current-signal signal))
+    (loop while current-signal do
+      (let ((depth (getf current-signal :depth 0))
+            (meta (getf current-signal :meta)))
+        (when (> depth 10)
+          (harness-log "METABOLISM ERROR: Max recursion depth reached.")
+          (return nil))
+
+        (when (bt:with-lock-held (*interrupt-lock*) *interrupt-flag*)
+          (harness-log "METABOLISM: Interrupted by shutdown signal.")
+          (return nil))
+
+        (handler-case
+            (progn
+              (setf current-signal (perceive-gate current-signal))
+              (setf current-signal (reason-gate current-signal))
+              (let ((feedback (act-gate current-signal)))
+                (if feedback
+                    (progn
+                      (unless (getf feedback :meta) (setf (getf feedback :meta) meta))
+                      (setf current-signal feedback))
+                    (setf current-signal nil))))
+          (error (c)
+            (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
+              (harness-log "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
+              (unless (member sensor '(:loop-error :tool-error :syntax-error))
+                (harness-log "CRITICAL ERROR: Initiating Micro-Rollback.")
+                (rollback-memory 0))
+              (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
+                  (setf current-signal nil)
+                  (setf current-signal
+                        (list :type :EVENT :depth (1+ depth) :meta meta
+                              :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth)))))))))))
+#+end_src
+
+** Heartbeat Mechanism
+#+begin_src lisp
+(defvar *auto-save-interval* 300)
+(defvar *heartbeat-save-counter* 0)
+
+(defun start-heartbeat ()
+  "Starts the background heartbeat thread."
+  (let ((interval (or (ignore-errors (parse-integer (uiop:getenv "HEARTBEAT_INTERVAL"))) 60))
+        (auto-save (or (ignore-errors (parse-integer (uiop:getenv "MEMORY_AUTO_SAVE_INTERVAL"))) *auto-save-interval*)))
+    (setf *auto-save-interval* auto-save)
+    (setf *heartbeat-save-counter* 0)
+
+    (setf *heartbeat-thread*
+          (bt:make-thread
+           (lambda ()
+             (loop
+               (sleep interval)
+               (incf *heartbeat-save-counter*)
+               (when (>= *heartbeat-save-counter* (/ *auto-save-interval* interval))
+                 (setf *heartbeat-save-counter* 0)
+                 (save-memory-to-disk))
+               (inject-stimulus
+                 (list :type :EVENT :payload (list :sensor :heartbeat :unix-time (get-universal-time))))))
+           :name "opencortex-heartbeat"))))
+#+end_src
+
+** Shutdown Flag
+#+begin_src lisp
+(defvar *shutdown-save-enabled* t)
+#+end_src
+
+** Health Status
+#+begin_src lisp
+(defvar *system-health* :unknown
+  "Current system health status: :healthy, :degraded, :unhealthy, or :unknown.")
+
+(defvar *health-check-ran* nil
+  "Flag indicating if initial health check has completed.")
+#+end_src
+
+** Proactive Doctor
+#+begin_src lisp
+(defun run-startup-health-check ()
+  "Runs the doctor diagnostics on startup. Returns health status."
+  (format t "~%")
+  (format t "==================================================~%")
+  (format t " DOCTOR: Running Startup Health Check~%")
+  (format t "==================================================~%")
+  (handler-case
+      (progn
+        (when (fboundp 'doctor-run-all)
+          (let ((result (doctor-run-all :auto-install nil)))
+            (setf *health-check-ran* t)
+            (if result
+                (progn
+                  (setf *system-health* :healthy)
+                  (format t "DAEMON: Health check passed. Starting services.~%"))
+                (progn
+                  (setf *system-health* :degraded)
+                  (format t "DAEMON: Health check found issues.~%")
+                  (format t "         Run 'opencortex doctor --fix' to repair.~%")))))
+        (setf *health-check-ran* t))
+    (error (c)
+      (format t "DOCTOR ERROR: ~a~%" c)
+      (setf *system-health* :unhealthy)
+      (setf *health-check-ran* t)))
+  (format t "==================================================~%~%"))
+#+end_src
+
+** Main Entry Point (main)
+#+begin_src lisp
+(defun main ()
+  "Entry point for OpenCortex. Initializes the system and enters idle loop."
+  (let* ((home (uiop:getenv "HOME"))
+         (env-file (uiop:merge-pathnames* ".config/opencortex/.env" (uiop:ensure-directory-pathname home))))
+    (when (uiop:file-exists-p env-file)
+      (cl-dotenv:load-env env-file)))
+
+  (load-memory-from-disk)
+  (initialize-actuators)
+  (initialize-all-skills)
+  
+  ;; Run proactive doctor before starting services
+  (run-startup-health-check)
+  
+  (start-heartbeat)
+  (start-daemon)
+
+  #+sbcl
+  (sb-sys:enable-interrupt sb-unix:sigint
+                            (lambda (sig code scp)
+                              (declare (ignore sig code scp))
+                              (harness-log "SHUTDOWN: SIGINT received. Saving memory...")
+                              (when *shutdown-save-enabled* (save-memory-to-disk))
+                              (uiop:quit 0)))
+
+  (let ((sleep-interval (or (ignore-errors (parse-integer (uiop:getenv "DAEMON_SLEEP_INTERVAL"))) 3600)))
+    (loop
+      (when (bt:with-lock-held (*interrupt-lock*) *interrupt-flag*)
+        (harness-log "SHUTDOWN: Interrupt flag set. Saving memory...")
+        (when *shutdown-save-enabled* (save-memory-to-disk))
+        (return))
+      (sleep sleep-interval))))
+#+end_src
+
+* Test Suite
+#+begin_src lisp :tangle ../tests/immune-system-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(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) (declare (ignore ctx)) (error "CRITICAL BRAIN FAILURE"))
+    :deterministic nil)
+  (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))))))
+#+end_src

harness/manifest.org

@@ -0,0 +1,64 @@
+#+TITLE: System Manifest (manifest.org)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:manifest:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle ../opencortex.asd
+
+* Overview
+The *System Manifest* defines the structural components of the OpenCortex.
+
+* Implementation
+
+** Main System
+#+begin_src lisp
+(defsystem :opencortex
+  :name "opencortex"
+  :author "Amr Gharbeia"
+  :version "0.2.0"
+  :license "AGPLv3"
+  :description "The Probabilistic-Deterministic Lisp Machine"
+  :depends-on (:usocket :bordeaux-threads :dexador :uiop :cl-dotenv :cl-ppcre :hunchentoot :ironclad :str :cl-json :uuid)
+  :serial t
+  :components ((:file "harness/package")
+               (:file "harness/skills")
+               (:file "harness/communication")
+               (:file "harness/communication-validator")
+               (:file "harness/memory")
+               (:file "harness/context")
+               (:file "harness/perceive")
+               (:file "harness/reason")
+               (:file "harness/act")
+               (:file "harness/loop")))
+#+end_src
+
+** Test System
+#+begin_src lisp
+(defsystem :opencortex/tests
+  :depends-on (:opencortex :fiveam)
+  :components ((:file "tests/pipeline-act-tests")
+               (:file "tests/boot-sequence-tests")
+               (:file "tests/immune-system-tests")
+               (:file "tests/memory-tests")
+               (:file "tests/pipeline-perceive-tests")
+               (:file "tests/pipeline-reason-tests")
+               (:file "tests/peripheral-vision-tests")
+               (:file "tests/utils-org-tests")
+               (:file "tests/engineering-standards-tests")
+               (:file "tests/utils-lisp-tests")
+               (:file "tests/literate-programming-tests")
+               (:file "tests/self-edit-tests")
+               (:file "tests/tool-permissions-tests")
+               (:file "tests/diagnostics-tests")
+               (:file "tests/config-manager-tests")
+               (:file "tests/gateway-manager-tests")
+               (:file "tests/tui-tests")
+               (:file "tests/llm-gateway-tests")))
+#+end_src
+
+** TUI System
+#+begin_src lisp
+(defsystem :opencortex/tui
+  :depends-on (:opencortex :croatoan :usocket :bordeaux-threads)
+  :components ((:file "harness/tui-client")))
+#+end_src
+

harness/memory.lisp

@@ -0,0 +1,120 @@
+(in-package :opencortex)
+
+(defvar *memory* (make-hash-table :test 'equal))
+(defvar *history-store* (make-hash-table :test 'equal)
+  "Immutable Merkle-Tree versioning store mapping hashes to objects.")
+
+(defun lookup-object (id)
+  (gethash id *memory*))
+
+(defstruct org-object
+  id type attributes content vector parent-id children version last-sync hash)
+
+(defmethod make-load-form ((obj org-object) &optional env)
+  (make-load-form-saving-slots obj :environment env))
+
+(defun deep-copy-org-object (obj)
+  (make-org-object :id (org-object-id obj)
+                  :type (org-object-type obj)
+                  :attributes (copy-list (org-object-attributes obj))
+                  :content (org-object-content obj)
+                  :vector (org-object-vector obj)
+                  :parent-id (org-object-parent-id obj)
+                  :children (copy-list (org-object-children obj))
+                  :version (org-object-version obj)
+                  :last-sync (org-object-last-sync obj)
+                  :hash (org-object-hash obj)))
+
+(defun compute-merkle-hash (id type attributes content child-hashes)
+  (let* ((alist (loop for (k v) on attributes by #'cddr collect (cons k v)))
+         (sorted-alist (sort alist #'string< :key (lambda (x) (format nil "~a" (car x)))))
+         (attr-string (format nil "~s" sorted-alist))
+         (children-string (format nil "~{~a~}" child-hashes))
+         (data-string (format nil "ID:~a|TYPE:~s|ATTRS:~a|CONTENT:~a|CHILDREN:~a"
+                              id type attr-string (or content "") children-string))
+         (digester (ironclad:make-digest :sha256)))
+    (ironclad:update-digest digester (ironclad:ascii-string-to-byte-array data-string))
+    (ironclad:byte-array-to-hex-string (ironclad:produce-digest digester))))
+
+(defun ingest-ast (ast &optional parent-id)
+  (let* ((type (getf ast :type))
+         (props (getf ast :properties))
+         (id (or (getf props :ID) (format nil "temp-~a" (get-universal-time))))
+         (contents (getf ast :contents))
+         (raw-content (when (eq type :HEADLINE)
+                        (format nil "~a~%~a" (getf props :TITLE) (or (getf ast :raw-content) ""))))
+         (child-ids nil) (child-hashes nil))
+    (dolist (child contents)
+      (when (listp child)
+        (let ((child-id (ingest-ast child id)))
+          (push child-id child-ids)
+          (let ((child-obj (gethash child-id *memory*)))
+            (when child-obj (push (org-object-hash child-obj) child-hashes))))))
+    (setf child-ids (nreverse child-ids))
+    (setf child-hashes (nreverse child-hashes))
+    (let* ((hash (compute-merkle-hash id type props raw-content child-hashes))
+           (existing-obj (gethash hash *history-store*))
+           (obj (or existing-obj
+                    (make-org-object 
+                     :id id :type type :attributes props :content raw-content
+                     :parent-id parent-id :children child-ids
+                     :version (get-universal-time) :last-sync (get-universal-time)
+                     :hash hash))))
+      (unless existing-obj (setf (gethash hash *history-store*) obj))
+      (setf (gethash id *memory*) obj)
+      id)))
+
+(defvar *object-store-snapshots* nil)
+
+(defun copy-hash-table (hash-table)
+  (let ((new-table (make-hash-table :test (hash-table-test hash-table) 
+                                    :size (hash-table-size hash-table))))
+    (maphash (lambda (k v) (setf (gethash k new-table) v)) hash-table)
+    new-table))
+
+(defun snapshot-memory ()
+  (let ((snapshot (make-hash-table :test 'equal :size (hash-table-size *memory*))))
+    (maphash (lambda (k v) (setf (gethash k snapshot) (deep-copy-org-object v))) *memory*)
+    (push (list :timestamp (get-universal-time) :data snapshot) *object-store-snapshots*)
+    (when (> (length *object-store-snapshots*) 20) (setf *object-store-snapshots* (subseq *object-store-snapshots* 0 20)))
+    (harness-log "MEMORY - CoW Memory snapshot created.")))
+
+(defun rollback-memory (&optional (index 0))
+  (let ((snapshot (nth index *object-store-snapshots*)))
+    (if snapshot
+        (progn (setf *memory* (copy-hash-table (getf snapshot :data)))
+               (harness-log "MEMORY - Memory rolled back to snapshot ~a" index))
+        (harness-log "MEMORY ERROR - Snapshot ~a not found." index))))
+
+(defvar *memory-snapshot-path* nil)
+
+(defun ensure-memory-snapshot-path ()
+  (or *memory-snapshot-path*
+      (let ((env-path (uiop:getenv "MEMORY_SNAPSHOT_PATH")))
+        (setf *memory-snapshot-path*
+              (or env-path (namestring (uiop:merge-pathnames* "memory.snap" (user-homedir-pathname))))))))
+
+(defun save-memory-to-disk ()
+  (let ((path (ensure-memory-snapshot-path)))
+    (with-open-file (stream path :direction :output :if-exists :supersede :if-does-not-exist :create)
+      (let ((memory-alist nil) (history-alist nil))
+        (maphash (lambda (k v) (push (cons k v) memory-alist)) *memory*)
+        (maphash (lambda (k v) (push (cons k v) history-alist)) *history-store*)
+        (prin1 (list :memory memory-alist :history-store history-alist) stream)))
+    (harness-log "MEMORY - Saved to ~a" path)))
+
+(defun load-memory-from-disk ()
+  (let ((path (ensure-memory-snapshot-path)))
+    (when (uiop:file-exists-p path)
+      (handler-case
+          (with-open-file (stream path :direction :input)
+            (let ((data (read stream nil)))
+              (when data
+                (let ((memory-alist (getf data :memory)) (history-alist (getf data :history-store)))
+                  (setf *memory* (make-hash-table :test 'equal :size (length memory-alist)))
+                  (dolist (kv memory-alist) (setf (gethash (car kv) *memory*) (cdr kv)))
+                  (setf *history-store* (make-hash-table :test 'equal :size (length history-alist)))
+                  (dolist (kv history-alist) (setf (gethash (car kv) *history-store*) (cdr kv)))
+                  (harness-log "MEMORY - Loaded from ~a (~a objects)" path (hash-table-size *memory*))))))
+          (error (c) (harness-log "MEMORY WARNING - Failed to load snapshot: ~a" c)))))
+  t)

harness/memory.org

@@ -0,0 +1,248 @@
+#+TITLE: The System Memory (memory.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:memory:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle memory.lisp
+
+* Overview
+The Memory module is the agent's live cognitive state — a set of Merkle-tree-versioned ~org-object~ instances stored in hash tables. Every perception, action, and decision is recorded here.
+
+Key structures:
+- ~*memory*~ — the primary object store, keyed by ID
+- ~*history-store*~ — immutable archive of all past object versions, keyed by SHA-256 hash
+- ~org-object~ — the universal data unit (id, type, attributes, content, vector embedding, parent, children, merkle hash)
+- ~ingest-ast~ — converts an Org-mode AST into ~org-object~ instances, computing Merkle hashes for integrity
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** The Object Repository
+#+begin_src lisp
+(defvar *memory* (make-hash-table :test 'equal))
+(defvar *history-store* (make-hash-table :test 'equal)
+  "Immutable Merkle-Tree versioning store mapping hashes to objects.")
+#+end_src
+
+** Object Lookup (lookup-object)
+Retrieve a single object by its ID from the active memory store.
+#+begin_src lisp
+(defun lookup-object (id)
+  "Retrieves an org-object by ID from *memory*."
+  (gethash id *memory*))
+#+end_src
+
+** Object search (list-objects-with-attribute)
+Scan the entire memory store for objects whose attributes match a given key-value pair.
+#+begin_src lisp
+(defun list-objects-with-attribute (attr value)
+  "Returns all org-objects whose :ATTRIBUTES plist has ATTR = VALUE."
+  (let ((results nil))
+    (maphash (lambda (id obj)
+               (declare (ignore id))
+               (when (equal (getf (org-object-attributes obj) attr) value)
+                 (push obj results)))
+             *memory*)
+    (nreverse results)))
+#+end_src
+
+** ID generation (org-id-new)
+Generate a unique identifier string for a new Org node. Uses the universal time encoded in base-36 for compactness.
+#+begin_src lisp
+(defun org-id-new ()
+  "Generates a timestamp-based unique ID."
+  (format nil "id-~36r" (get-universal-time)))
+#+end_src
+
+** The Data Structure (org-object)
+The universal data unit. Every stored entity is an ~org-object~ with an ID, type, attribute plist, content string, optional vector embedding, parent/child pointers, version timestamp, and Merkle hash.
+#+begin_src lisp
+(defstruct org-object
+  id type attributes content vector parent-id children version last-sync hash)
+#+end_src
+
+** Serialization support
+Required by the Lisp runtime for saving/loading objects across image restarts.
+#+begin_src lisp
+(defmethod make-load-form ((obj org-object) &optional env)
+  (make-load-form-saving-slots obj :environment env))
+#+end_src
+
+** Deep copy
+Creates an independent copy of an ~org-object~. Used by the snapshot system to capture consistent memory state.
+#+begin_src lisp
+(defun deep-copy-org-object (obj)
+  "Creates a full copy of an org-object, including a fresh list copy of attributes and children."
+  (make-org-object :id (org-object-id obj)
+                  :type (org-object-type obj)
+                  :attributes (copy-list (org-object-attributes obj))
+                  :content (org-object-content obj)
+                  :vector (org-object-vector obj)
+                  :parent-id (org-object-parent-id obj)
+                  :children (copy-list (org-object-children obj))
+                  :version (org-object-version obj)
+                  :last-sync (org-object-last-sync obj)
+                  :hash (org-object-hash obj)))
+#+end_src
+
+** Merkle Tree Integrity
+#+begin_src lisp
+(defun compute-merkle-hash (id type attributes content child-hashes)
+  (let* ((alist (loop for (k v) on attributes by #'cddr collect (cons k v)))
+         (sorted-alist (sort alist #'string< :key (lambda (x) (format nil "~a" (car x)))))
+         (attr-string (format nil "~s" sorted-alist))
+         (children-string (format nil "~{~a~}" child-hashes))
+         (data-string (format nil "ID:~a|TYPE:~s|ATTRS:~a|CONTENT:~a|CHILDREN:~a"
+                              id type attr-string (or content "") children-string))
+         (digester (ironclad:make-digest :sha256)))
+    (ironclad:update-digest digester (ironclad:ascii-string-to-byte-array data-string))
+    (ironclad:byte-array-to-hex-string (ironclad:produce-digest digester))))
+#+end_src
+
+** Ingest (ingest-ast)
+#+begin_src lisp
+(defun ingest-ast (ast &optional parent-id)
+  (let* ((type (getf ast :type))
+         (props (getf ast :properties))
+         (id (or (getf props :ID) (format nil "temp-~a" (get-universal-time))))
+         (contents (getf ast :contents))
+         (raw-content (when (eq type :HEADLINE)
+                        (format nil "~a~%~a" (getf props :TITLE) (or (getf ast :raw-content) ""))))
+         (child-ids nil) (child-hashes nil))
+    (dolist (child contents)
+      (when (listp child)
+        (let ((child-id (ingest-ast child id)))
+          (push child-id child-ids)
+          (let ((child-obj (gethash child-id *memory*)))
+            (when child-obj (push (org-object-hash child-obj) child-hashes))))))
+    (setf child-ids (nreverse child-ids))
+    (setf child-hashes (nreverse child-hashes))
+    (let* ((hash (compute-merkle-hash id type props raw-content child-hashes))
+           (existing-obj (gethash hash *history-store*))
+           (obj (or existing-obj
+                    (make-org-object 
+                     :id id :type type :attributes props :content raw-content
+                     :parent-id parent-id :children child-ids
+                     :version (get-universal-time) :last-sync (get-universal-time)
+                     :hash hash))))
+      (unless existing-obj (setf (gethash hash *history-store*) obj))
+      (setf (gethash id *memory*) obj)
+      id)))
+#+end_src
+
+** Snapshot history (~*object-store-snapshots*~)
+A stack of CoW (copy-on-write) memory snapshots for rollback. Up to 20 snapshots are retained.
+#+begin_src lisp
+(defvar *object-store-snapshots* nil)
+#+end_src
+
+** Hash table copy utility
+Used by the rollback system to restore saved memory state.
+#+begin_src lisp
+(defun copy-hash-table (hash-table)
+  "Creates an independent copy of a hash table."
+  (let ((new-table (make-hash-table :test (hash-table-test hash-table) 
+                                     :size (hash-table-size hash-table))))
+    (maphash (lambda (k v) (setf (gethash k new-table) v)) hash-table)
+    new-table))
+#+end_src
+
+** Memory snapshot (snapshot-memory)
+Captures a point-in-time copy of ~*memory*~. Each object is deep-copied so the snapshot is independent of ongoing mutations.
+#+begin_src lisp
+(defun snapshot-memory ()
+  "Creates a CoW snapshot of *memory* for rollback recovery."
+  (let ((snapshot (make-hash-table :test 'equal :size (hash-table-size *memory*))))
+    (maphash (lambda (k v) (setf (gethash k snapshot) (deep-copy-org-object v))) *memory*)
+    (push (list :timestamp (get-universal-time) :data snapshot) *object-store-snapshots*)
+    (when (> (length *object-store-snapshots*) 20)
+      (setf *object-store-snapshots* (subseq *object-store-snapshots* 0 20)))
+    (harness-log "MEMORY - CoW Memory snapshot created.")))
+#+end_src
+
+** Memory rollback (rollback-memory)
+Restores ~*memory*~ to a previous snapshot. By default restores the most recent snapshot (index 0).
+#+begin_src lisp
+(defun rollback-memory (&optional (index 0))
+  "Restores *memory* from a snapshot. INDEX 0 = most recent."
+  (let ((snapshot (nth index *object-store-snapshots*)))
+    (if snapshot
+        (progn (setf *memory* (copy-hash-table (getf snapshot :data)))
+               (harness-log "MEMORY - Memory rolled back to snapshot ~a" index))
+        (harness-log "MEMORY ERROR - Snapshot ~a not found." index))))
+#+end_src
+
+** Persistence — snapshot path (~*memory-snapshot-path*~)
+Configurable path for serialized memory state. Falls back to ~memory.snap~ in the home directory.
+#+begin_src lisp
+(defvar *memory-snapshot-path* nil)
+
+(defun ensure-memory-snapshot-path ()
+  "Returns the path to the memory snapshot file, resolving env or default."
+  (or *memory-snapshot-path*
+      (let ((env-path (uiop:getenv "MEMORY_SNAPSHOT_PATH")))
+        (setf *memory-snapshot-path*
+              (or env-path (namestring (uiop:merge-pathnames* "memory.snap" (user-homedir-pathname))))))))
+#+end_src
+
+** Save to disk (save-memory-to-disk)
+Serialises ~*memory*~ and ~*history-store*~ to a Lisp-readable file.
+#+begin_src lisp
+(defun save-memory-to-disk ()
+  "Writes the entire memory and history store to disk as a plist."
+  (let ((path (ensure-memory-snapshot-path)))
+    (with-open-file (stream path :direction :output :if-exists :supersede :if-does-not-exist :create)
+      (let ((memory-alist nil) (history-alist nil))
+        (maphash (lambda (k v) (push (cons k v) memory-alist)) *memory*)
+        (maphash (lambda (k v) (push (cons k v) history-alist)) *history-store*)
+        (prin1 (list :memory memory-alist :history-store history-alist) stream)))
+    (harness-log "MEMORY - Saved to ~a" path)))
+#+end_src
+
+** Load from disk (load-memory-from-disk)
+Restores memory state from a previously saved snapshot file.
+#+begin_src lisp
+(defun load-memory-from-disk ()
+  "Reads memory state from disk and restores *memory* and *history-store*."
+  (let ((path (ensure-memory-snapshot-path)))
+    (when (uiop:file-exists-p path)
+      (handler-case
+          (with-open-file (stream path :direction :input)
+            (let ((data (read stream nil)))
+              (when data
+                (let ((memory-alist (getf data :memory)) (history-alist (getf data :history-store)))
+                  (setf *memory* (make-hash-table :test 'equal :size (length memory-alist)))
+                  (dolist (kv memory-alist) (setf (gethash (car kv) *memory*) (cdr kv)))
+                  (setf *history-store* (make-hash-table :test 'equal :size (length history-alist)))
+                  (dolist (kv history-alist) (setf (gethash (car kv) *history-store*) (cdr kv)))
+                  (harness-log "MEMORY - Loaded from ~a (~a objects)" path (hash-table-size *memory*))))))
+          (error (c) (harness-log "MEMORY WARNING - Failed to load snapshot: ~a" c)))))
+  t)
+#+end_src
+
+* Test Suite
+#+begin_src lisp :tangle ../tests/memory-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(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)))
+    (clrhash opencortex::*memory*)
+    (let ((id1 (ingest-ast ast1)))
+      (let ((hash1 (org-object-hash (lookup-object id1))))
+        (clrhash opencortex::*memory*)
+        (let ((id2 (ingest-ast ast1)))
+          (is (equal hash1 (org-object-hash (lookup-object id2)))))))))
+#+end_src

harness/package.lisp

@@ -1,39 +1,40 @@
-#+TITLE: System Interface (package.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:interface:
-#+STARTUP: content
-
-* System Interface (package.lisp)
-The ~package.lisp~ file defines the public API of the ~opencortex~ harness. It serves as the primary membrane between the deterministic core modules and the dynamic world of skills and actuators.
-
-** Architectural Intent: The Package Membrane
-By strictly defining the public interface, we ensure that skills remain decoupled from the harness implementation details. This allows for autonomous replacement of any component (e.g., swapping the Memory or the Probabilistic Engine) without breaking existing skills.
-
-#+begin_src mermaid
-flowchart TD
-    External[Actuators / Clients] -- communication protocol --> Package[Package Membrane: API]
-    Skills[Dynamic Skills] -- API Calls --> Package
-    Package --> Internal[Harness Internal Modules]
-    style Package fill:#f9f,stroke:#333,stroke-width:4px
-#+end_src
-
-** Public API Export
-#+begin_src lisp :tangle ../src/package.lisp
 (defpackage :opencortex
   (:use :cl)
-  (:export 
+  (:export
    ;; --- communication protocol ---
    #:frame-message
+   #:read-framed-message
+   #:PROTO-GET
+   #:LIST-OBJECTS-WITH-ATTRIBUTE
+   #:COSINE-SIMILARITY
+   #:VAULT-MASK-STRING
+   #:*VAULT-MEMORY*
    #:parse-message
    #:make-hello-message
    #:validate-communication-protocol-schema
-   
+
    ;; --- Daemon Lifecycle ---
    #:start-daemon
    #:stop-daemon
    #:harness-log
    #:main
-   
+
+   ;; --- Diagnostic Doctor ---
+   #:doctor-run-all
+   #:doctor-main
+   #:doctor-check-dependencies
+   #:doctor-check-env
+
+   ;; --- Setup Wizard ---
+   #:register-provider
+   #:system-ready-p
+   #:run-setup-wizard
+
+   ;; --- Gateway Manager Skill ---
+   #:skill-gateway-register
+   #:skill-gateway-link
+   #:gateway-manager-main
+
    ;; --- Memory (CLOSOS) ---
    #:ingest-ast
    #:lookup-object
@@ -55,7 +56,7 @@ flowchart TD
    #:org-object-hash
    #:snapshot-memory
    #:rollback-memory
-   
+
    ;; --- Context API (Peripheral Vision) ---
    #:context-query-store
    #:context-get-active-projects
@@ -67,7 +68,7 @@ flowchart TD
    #:context-get-skill-telemetry
    #:harness-track-telemetry
    #:context-assemble-global-awareness
-   
+
    ;; --- Reactive Signal Pipeline ---
    #:process-signal
    #:perceive-gate
@@ -81,7 +82,7 @@ flowchart TD
    #:initialize-actuators
    #:dispatch-action
    #:register-actuator
-   
+
    ;; --- Skill Engine ---
    #:load-skill-from-org
    #:initialize-all-skills
@@ -101,6 +102,53 @@ flowchart TD
    ;; --- Tool Registry ---
    #:def-cognitive-tool
    #:*cognitive-tools*
+
+   ;; --- Engineering Standards Skill ---
+   #:verify-git-clean-p
+   #:engineering-standards-verify-lisp
+   #:engineering-standards-format-lisp
+
+   ;; --- Literate Programming Skill ---
+   #:literate-check-block-balance
+   #:check-tangle-sync
+   #:*tangle-targets*
+
+   ;; --- Utils Org Skill ---
+   #:utils-org-read-file
+   #:utils-org-write-file
+   #:utils-org-add-headline
+   #:utils-org-set-property
+   #:utils-org-set-todo
+   #:utils-org-find-headline-by-id
+   #:utils-org-find-headline-by-title
+   #:utils-org-generate-id
+   #:utils-org-id-format
+   #:utils-org-ast-to-org
+   #:utils-org-modify
+
+   ;; --- Utils Lisp Skill ---
+   #:utils-lisp-validate
+   #:utils-lisp-check-structural
+   #:utils-lisp-check-syntactic
+   #:utils-lisp-check-semantic
+   #:utils-lisp-eval
+   #:utils-lisp-format
+   #:utils-lisp-list-definitions
+   #:utils-lisp-structural-extract
+   #:utils-lisp-structural-wrap
+   #:utils-lisp-structural-inject
+   #:utils-lisp-structural-slurp
+   #:utils-lisp-register
+
+   ;; --- Config Manager & Diagnostics Skill ---
+   #:get-oc-config-dir
+   #:prompt-for
+   #:save-secret
+
+   ;; --- Tool Permissions Skill ---
+   #:get-tool-permission
+   #:set-tool-permission
+   #:check-tool-permission-gate
    #:cognitive-tool
    #:cognitive-tool-name
    #:cognitive-tool-description
@@ -119,64 +167,47 @@ flowchart TD
    #:register-probabilistic-backend
    #:distill-prompt
    #:*provider-cascade*
-   
+
    ;; --- Security Vault ---
    #:vault-get-secret
    #:vault-set-secret
-   
+
    ;; --- Deterministic Logic ---
    #:list-objects-with-attribute
    #:deterministic-verify
-   
+
    ;; --- AST Helpers ---
    #:find-headline-missing-id))
-#+end_src
 
-** Package Implementation
-#+begin_src lisp :tangle ../src/package.lisp
 (in-package :opencortex)
-#+end_src
 
-** Harness Logging State
-The harness maintains a thread-safe circular log buffer to provide context for debugging and neural reasoning.
+(defun proto-get (plist key)
+  "Robustly retrieves a value from a plist, checking both uppercase and lowercase keyword versions."
+  (let* ((s (string key))
+         (up (intern (string-upcase s) :keyword))
+         (dn (intern (string-downcase s) :keyword)))
+    (or (getf plist up) (getf plist dn))))
 
-#+begin_src lisp :tangle ../src/package.lisp
 (defvar *system-logs* nil)
-(defvar *logs-lock* (bt:make-lock "harness-logs-lock"))
+(defvar *logs-lock* (bordeaux-threads:make-lock "harness-logs-lock"))
 (defvar *max-log-history* 100)
-#+end_src
 
-** Skills Registry
-#+begin_src lisp :tangle ../src/package.lisp
 (defvar *skills-registry* (make-hash-table :test 'equal)
   "Global registry of all loaded skills.")
-#+end_src
 
-** Skill Telemetry State
-#+begin_src lisp :tangle ../src/package.lisp
 (defvar *skill-telemetry* (make-hash-table :test 'equal))
-(defvar *telemetry-lock* (bt:make-lock "harness-telemetry-lock"))
-#+end_src
+(defvar *telemetry-lock* (bordeaux-threads:make-lock "harness-telemetry-lock"))
 
-** Telemetry Implementation
-The system tracks the performance and reliability of individual skills. This logic is currently preserved in the package layer for future expansion into a dedicated telemetry skill.
-
-#+begin_src lisp :tangle ../src/package.lisp
 (defun harness-track-telemetry (skill-name duration status)
   "Updates performance metrics for a specific skill. Status should be :success or :rejected."
-  (when skill-name 
-    (bt:with-lock-held (*telemetry-lock*)
+  (when skill-name
+    (bordeaux-threads:with-lock-held (*telemetry-lock*)
       (let ((entry (or (gethash skill-name *skill-telemetry*) (list :executions 0 :total-time 0 :failures 0))))
-        (incf (getf entry :executions)) 
+        (incf (getf entry :executions))
         (incf (getf entry :total-time) duration)
-        (when (eq status :rejected) (incf (getf entry :failures))) 
+        (when (eq status :rejected) (incf (getf entry :failures)))
         (setf (gethash skill-name *skill-telemetry*) entry)))))
-#+end_src
 
-** Cognitive Tool Registry
-The Tool Registry allows the agent to interact with the physical world. Every tool must define a guard (for security) and a body (for execution).
-
-#+begin_src lisp :tangle ../src/package.lisp
 (defvar *cognitive-tools* (make-hash-table :test 'equal))
 
 (defstruct cognitive-tool
@@ -193,20 +224,45 @@ The Tool Registry allows the agent to interact with the physical world. Every to
                               :description ,description
                               :parameters ',parameters
                               :guard ,guard
-                              :body ,body)))
-#+end_src
+                               :body ,body)))
 
-** Harness Logging Implementation
-Centralized logging function. It simultaneously writes to standard output and the in-memory circular buffer.
+(defun generate-tool-belt-prompt ()
+  "Generates a prompt string describing all available cognitive tools."
+  (let ((descriptions nil))
+    (maphash (lambda (k tool)
+               (declare (ignore k))
+               (push (format nil "- ~a: ~a~%  Parameters: ~a~%"
+                             (cognitive-tool-name tool)
+                             (cognitive-tool-description tool)
+                             (cognitive-tool-parameters tool))
+                     descriptions))
+             *cognitive-tools*)
+    (if descriptions
+        (format nil "Available tools:~%~a" (apply #'concatenate 'string (sort descriptions #'string<)))
+        "No tools registered.")))
 
-#+begin_src lisp :tangle ../src/package.lisp
 (defun harness-log (msg &rest args)
   "Centralized logging for the harness."
   (let ((formatted-msg (apply #'format nil msg args)))
-    (bt:with-lock-held (*logs-lock*)
+    (bordeaux-threads:with-lock-held (*logs-lock*)
       (push formatted-msg *system-logs*)
       (when (> (length *system-logs*) *max-log-history*)
         (setq *system-logs* (subseq *system-logs* 0 *max-log-history*))))
     (format t "~a~%" formatted-msg)
     (finish-output)))
-#+end_src
+
+;; --- Debugger Hook ---
+(setf *debugger-hook* (lambda (condition hook)
+  "Friendly error handler - shows diagnostic message instead of raw debugger."
+  (declare (ignore hook))
+  (format t "~%")
+  (format t "┌─────────────────────────────────────────────┐~%")
+  (format t "│  ERROR: ~A~%" (type-of condition))
+  (format t "│~%")
+  (format t "│  Run: opencortex doctor~%")
+  (format t "│  For system diagnostics~%")
+  (format t "└─────────────────────────────────────────────┘~%")
+  (format t "~%")
+  (format t "Details: ~A~%" condition)
+  (finish-output)
+  (uiop:quit 1)))

harness/package.org

@@ -0,0 +1,288 @@
+#+TITLE: System Interface (package.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:interface:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle package.lisp
+
+* Overview
+~package.lisp~ defines two things: the public API of the ~opencortex~ package (the export list, above), and the implementation of low-level utility functions and global state that don't belong in a specific pipeline stage or skill.
+
+The export list is the contract between the harness and all skills. Every function exported here is accessible to every skill via ~use-package~. Adding a symbol here is an API commitment; removing one is a breaking change.
+
+The implementation section includes:
+- ~proto-get~ — robust plist accessor used everywhere
+- Logging state (~*system-logs*~, ~*logs-lock*~)
+- Skill registry (~*skills-registry*~, ~defskill~)
+- Cognitive tool registry (~*cognitive-tools*~, ~def-cognitive-tool~)
+- Configuration variables (~*privacy-filter-tags*~, ~*secret-protected-paths*~, ~*secret-exposure-patterns*~)
+- Debugger hook
+
+* Implementation
+
+** Package Definition and Export List
+The package definition. All public symbols are exported here.
+#+begin_src lisp :tangle package.lisp
+(defpackage :opencortex
+  (:use :cl)
+  (:export
+   #:frame-message
+   #:read-framed-message
+   #:PROTO-GET
+   #:LIST-OBJECTS-WITH-ATTRIBUTE
+   #:COSINE-SIMILARITY
+   #:VAULT-MASK-STRING
+   #:*VAULT-MEMORY*
+   #:parse-message
+   #:make-hello-message
+   #:validate-communication-protocol-schema
+   #:start-daemon
+   #:stop-daemon
+   #:harness-log
+   #:main
+   #:doctor-run-all
+   #:doctor-main
+   #:doctor-check-dependencies
+   #:doctor-check-env
+   #:register-provider
+   #:system-ready-p
+   #:run-setup-wizard
+   #:skill-gateway-register
+   #:skill-gateway-link
+   #:gateway-manager-main
+   #:ingest-ast
+   #:lookup-object
+   #:list-objects-by-type
+   #:org-id-new
+   #:*memory*
+   #:*history-store*
+   #:org-object
+   #:make-org-object
+   #:org-object-id
+   #:org-object-type
+   #:org-object-attributes
+   #:org-object-parent-id
+   #:org-object-children
+   #:org-object-version
+   #:org-object-last-sync
+   #:org-object-vector
+   #:org-object-content
+   #:org-object-hash
+   #:snapshot-memory
+   #:rollback-memory
+   #:context-query-store
+   #:context-get-active-projects
+   #:context-get-recent-completed-tasks
+   #:context-list-all-skills
+   #:context-get-skill-source
+   #:context-get-system-logs
+   #:context-resolve-path
+   #:context-get-skill-telemetry
+   #:harness-track-telemetry
+   #:context-assemble-global-awareness
+   #:process-signal
+   #:perceive-gate
+   #:probabilistic-gate
+   #:consensus-gate
+   #:act-gate
+   #:reason-gate
+   #:dispatch-gate
+   #:inject-stimulus
+   #:initialize-actuators
+   #:dispatch-action
+   #:register-actuator
+   #:load-skill-from-org
+   #:initialize-all-skills
+   #:load-skill-with-timeout
+   #:topological-sort-skills
+   #:validate-lisp-syntax
+   #:defskill
+   #:*skills-registry*
+   #:skill
+   #:skill-name
+   #:skill-priority
+   #:skill-dependencies
+   #:skill-trigger-fn
+   #:skill-probabilistic-prompt
+   #:skill-deterministic-fn
+   #:def-cognitive-tool
+   #:*cognitive-tools*
+   #:verify-git-clean-p
+   #:engineering-standards-verify-lisp
+   #:engineering-standards-format-lisp
+   #:literate-check-block-balance
+   #:check-tangle-sync
+   #:*tangle-targets*
+   #:utils-org-read-file
+   #:utils-org-write-file
+   #:utils-org-add-headline
+   #:utils-org-set-property
+   #:utils-org-set-todo
+   #:utils-org-find-headline-by-id
+   #:utils-org-find-headline-by-title
+   #:utils-org-generate-id
+   #:utils-org-id-format
+   #:utils-org-ast-to-org
+   #:utils-org-modify
+   #:utils-lisp-validate
+   #:utils-lisp-check-structural
+   #:utils-lisp-check-syntactic
+   #:utils-lisp-check-semantic
+   #:utils-lisp-eval
+   #:utils-lisp-format
+   #:utils-lisp-list-definitions
+   #:utils-lisp-structural-extract
+   #:utils-lisp-structural-wrap
+   #:utils-lisp-structural-inject
+   #:utils-lisp-structural-slurp
+   #:utils-lisp-register
+   #:get-oc-config-dir
+   #:prompt-for
+   #:save-secret
+   #:get-tool-permission
+   #:set-tool-permission
+   #:check-tool-permission-gate
+   #:cognitive-tool
+   #:cognitive-tool-name
+   #:cognitive-tool-description
+   #:cognitive-tool-parameters
+   #:cognitive-tool-guard
+   #:cognitive-tool-body
+   #:*emacs-clients*
+   #:*clients-lock*
+   #:register-emacs-client
+   #:unregister-emacs-client
+   #:ask-probabilistic
+   #:register-probabilistic-backend
+   #:distill-prompt
+   #:*probabilistic-backends*
+   #:*provider-cascade*
+   #:vault-get-secret
+   #:vault-set-secret
+   #:list-objects-with-attribute
+   #:deterministic-verify
+   #:find-headline-missing-id))
+#+end_src
+
+** Package Implementation
+The package implementation section defines the low-level utilities and global state that are shared across all harness components and skills.
+
+*** Robust plist access (proto-get)
+Retrieves a value from a plist, checking both upper and lowercase keyword variants. This is needed because different components use different keyword conventions.
+#+begin_src lisp :tangle package.lisp
+(in-package :opencortex)
+
+(defun proto-get (plist key)
+  "Robust plist accessor — checks both :KEY and :key variants."
+  (let* ((s (string key))
+         (up (intern (string-upcase s) :keyword))
+         (dn (intern (string-downcase s) :keyword)))
+    (or (getf plist up) (getf plist dn))))
+#+end_src
+
+*** Logging state
+The harness maintains a bounded ring buffer of log messages for inclusion in LLM context. Access is thread-safe via a lock.
+#+begin_src lisp :tangle package.lisp
+(defvar *system-logs* nil)
+(defvar *logs-lock* (bordeaux-threads:make-lock "harness-logs-lock"))
+(defvar *max-log-history* 100)
+#+end_src
+
+*** Skill registry
+The global registry of all loaded skills. This is the authoritative list that the deterministic engine iterates.
+#+begin_src lisp :tangle package.lisp
+(defvar *skills-registry* (make-hash-table :test 'equal)
+  "Global registry of all loaded skills.")
+#+end_src
+
+*** Skill telemetry
+Tracks execution metrics per skill (count, duration, failures) for diagnostics and performance analysis.
+#+begin_src lisp :tangle package.lisp
+(defvar *skill-telemetry* (make-hash-table :test 'equal))
+(defvar *telemetry-lock* (bordeaux-threads:make-lock "harness-telemetry-lock"))
+
+(defun harness-track-telemetry (skill-name duration status)
+  "Updates performance metrics for a skill. STATUS is :success or :rejected."
+  (when skill-name
+    (bordeaux-threads:with-lock-held (*telemetry-lock*)
+      (let ((entry (or (gethash skill-name *skill-telemetry*) (list :executions 0 :total-time 0 :failures 0))))
+        (incf (getf entry :executions))
+        (incf (getf entry :total-time) duration)
+        (when (eq status :rejected) (incf (getf entry :failures)))
+        (setf (gethash skill-name *skill-telemetry*) entry)))))
+#+end_src
+
+*** Cognitive tool registry
+Tools that the LLM can invoke are registered here. Each tool has a name, description, parameters, optional guard, and implementation body. The ~def-cognitive-tool~ macro handles registration. ~generate-tool-belt-prompt~ serialises the registry into the LLM's system prompt.
+#+begin_src lisp :tangle package.lisp
+(defvar *cognitive-tools* (make-hash-table :test 'equal))
+#+end_src
+
+#+begin_src lisp :tangle package.lisp
+(defstruct cognitive-tool
+  name
+  description
+  parameters
+  guard
+  body)
+#+end_src
+
+#+begin_src lisp :tangle package.lisp
+(defmacro def-cognitive-tool (name description parameters &key guard body)
+  "Registers a cognitive tool. PARAMETERS is a list of plists, one per parameter."
+  `(setf (gethash (string-downcase (string ',name)) *cognitive-tools*)
+         (make-cognitive-tool :name (string-downcase (string ',name))
+                              :description ,description
+                              :parameters ',parameters
+                              :guard ,guard
+                              :body ,body)))
+#+end_src
+
+#+begin_src lisp :tangle package.lisp
+(defun generate-tool-belt-prompt ()
+  "Serialises all registered tools into a prompt string for the LLM."
+  (let ((descriptions nil))
+    (maphash (lambda (k tool)
+               (declare (ignore k))
+               (push (format nil "- ~a: ~a~%  Parameters: ~a~%"
+                             (cognitive-tool-name tool)
+                             (cognitive-tool-description tool)
+                             (cognitive-tool-parameters tool))
+                     descriptions))
+              *cognitive-tools*)
+    (if descriptions
+        (format nil "Available tools:~%~a" (apply #'concatenate 'string (sort descriptions #'string<)))
+        "No tools registered.")))
+#+end_src
+
+*** Centralized logging (harness-log)
+Thread-safe logging function that writes to both the ring buffer (for LLM context) and stdout (for the user). Bounded by ~*max-log-history*~.
+#+begin_src lisp :tangle package.lisp
+(defun harness-log (msg &rest args)
+  "Centralized, thread-safe logging for the harness."
+  (let ((formatted-msg (apply #'format nil msg args)))
+    (bordeaux-threads:with-lock-held (*logs-lock*)
+      (push formatted-msg *system-logs*)
+      (when (> (length *system-logs*) *max-log-history*)
+        (setq *system-logs* (subseq *system-logs* 0 *max-log-history*))))
+    (format t "~a~%" formatted-msg)
+    (finish-output)))
+#+end_src
+
+*** Debugger hook
+Friendly error handler that replaces the raw SBCL debugger with a diagnostic message. This prevents the agent from entering the debugger on unhandled conditions.
+#+begin_src lisp :tangle package.lisp
+(setf *debugger-hook* (lambda (condition hook)
+  "Friendly error handler - shows diagnostic message instead of raw debugger."
+  (declare (ignore hook))
+  (format t "~%")
+  (format t "┌─────────────────────────────────────────────┐~%")
+  (format t "│  ERROR: ~A~%" (type-of condition))
+  (format t "│~%")
+  (format t "│  Run: opencortex doctor~%")
+  (format t "│  For system diagnostics~%")
+  (format t "└─────────────────────────────────────────────┘~%")
+  (format t "~%")
+  (format t "Details: ~A~%" condition)
+  (finish-output)
+  (uiop:quit 1)))
+#+end_src

harness/perceive.lisp

@@ -0,0 +1,72 @@
+(in-package :opencortex)
+
+(defvar *interrupt-flag* nil)
+(defvar *async-sensors* '(:chat-message :delegation :user-command)
+  "Sensors that are processed in dedicated threads.")
+
+(defvar *foveal-focus-id* nil
+  "The Org ID of the node the user is currently interacting with.")
+
+(defun inject-stimulus (raw-message &key stream (depth 0))
+  "Inject a raw message into the signal processing pipeline."
+  (let* ((payload (getf raw-message :payload))
+         (sensor (getf payload :sensor))
+         (meta (getf raw-message :meta))
+         (async-p (or (getf payload :async-p)
+                     (member sensor *async-sensors*))))
+
+    (unless meta
+      (setf meta (list :SOURCE :SYSTEM :SESSION-ID "internal")))
+
+    (when stream
+      (setf (getf meta :reply-stream) stream))
+
+    (setf (getf raw-message :meta) meta)
+    (setf (getf raw-message :depth) depth)
+
+    (if async-p
+        (bt:make-thread
+         (lambda ()
+           (restart-case (process-signal raw-message)
+             (skip-event () nil)))
+         :name "opencortex-async-task")
+        
+        (restart-case
+            (handler-bind ((error (lambda (c)
+                                    (harness-log "SYSTEM ERROR: ~a" c)
+                                    (invoke-restart 'skip-event))))
+              (process-signal raw-message))
+          (skip-event ()
+            (harness-log "SYSTEM RECOVERY: Stimulus dropped."))))))
+
+(defun perceive-gate (signal)
+  "Stage 1 of the metabolic pipeline: Normalize sensory input."
+  (let* ((payload (getf signal :payload))
+         (type (getf signal :type))
+         (meta (getf signal :meta))
+         (sensor (getf payload :sensor)))
+
+    (harness-log "GATE [Perceive]: ~a (~a) [Source: ~s]"
+                 type (or sensor "no-sensor") (getf meta :source))
+
+    (cond ((eq type :EVENT)
+           (case sensor
+             (:buffer-update
+              (let ((ast (getf payload :ast)))
+                (when ast
+                  (snapshot-memory)
+                  (ingest-ast ast))))
+             (:point-update
+              (let ((element (getf payload :element)))
+                (when element
+                  (snapshot-memory)
+                  (setf *foveal-focus-id* (getf element :id))
+                  (ingest-ast element))))
+             (:interrupt
+              (setf *interrupt-flag* t))))
+          ((eq type :RESPONSE)
+           (harness-log "GATE [Perceive]: Act Result -> ~a" (getf payload :status))))
+
+    (setf (getf signal :status) :perceived)
+    (setf (getf signal :foveal-focus) *foveal-focus-id*)
+    signal))

harness/perceive.org

@@ -0,0 +1,126 @@
+#+TITLE: Stage 1: Perceive (perceive.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:perceive:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle perceive.lisp
+
+* Overview
+The Perceive stage is the "sensory cortex" of OpenCortex. Its job is to take raw stimuli from the outside world and transform them into standardized Signals that the rest of the pipeline can process.
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Interrupt Handling
+#+begin_src lisp
+(defvar *interrupt-flag* nil)
+#+end_src
+
+** Sensor Configuration
+#+begin_src lisp
+(defvar *async-sensors* '(:chat-message :delegation :user-command)
+  "Sensors that are processed in dedicated threads.")
+
+(defvar *foveal-focus-id* nil
+  "The Org ID of the node the user is currently interacting with.")
+#+end_src
+
+** Stimulus Injection (inject-stimulus)
+#+begin_src lisp
+(defun inject-stimulus (raw-message &key stream (depth 0))
+  "Inject a raw message into the signal processing pipeline."
+  (let* ((payload (getf raw-message :payload))
+         (sensor (getf payload :sensor))
+         (meta (getf raw-message :meta))
+         (async-p (or (getf payload :async-p)
+                     (member sensor *async-sensors*))))
+
+    (unless meta
+      (setf meta (list :SOURCE :SYSTEM :SESSION-ID "internal")))
+
+    (when stream
+      (setf (getf meta :reply-stream) stream))
+
+    (setf (getf raw-message :meta) meta)
+    (setf (getf raw-message :depth) depth)
+
+    (if async-p
+        (bt:make-thread
+         (lambda ()
+           (restart-case (process-signal raw-message)
+             (skip-event () nil)))
+         :name "opencortex-async-task")
+        
+        (restart-case
+            (handler-bind ((error (lambda (c)
+                                    (harness-log "SYSTEM ERROR: ~a" c)
+                                    (invoke-restart 'skip-event))))
+              (process-signal raw-message))
+          (skip-event ()
+            (harness-log "SYSTEM RECOVERY: Stimulus dropped."))))))
+#+end_src
+
+** Perceive Gate (perceive-gate)
+#+begin_src lisp
+(defun perceive-gate (signal)
+  "Stage 1 of the metabolic pipeline: Normalize sensory input."
+  (let* ((payload (getf signal :payload))
+         (type (getf signal :type))
+         (meta (getf signal :meta))
+         (sensor (getf payload :sensor)))
+
+    (harness-log "GATE [Perceive]: ~a (~a) [Source: ~s]"
+                 type (or sensor "no-sensor") (getf meta :source))
+
+    (cond ((eq type :EVENT)
+           (case sensor
+             (:buffer-update
+              (let ((ast (getf payload :ast)))
+                (when ast
+                  (snapshot-memory)
+                  (ingest-ast ast))))
+             (:point-update
+              (let ((element (getf payload :element)))
+                (when element
+                  (snapshot-memory)
+                  (setf *foveal-focus-id* (getf element :id))
+                  (ingest-ast element))))
+             (:interrupt
+              (setf *interrupt-flag* t))))
+          ((eq type :RESPONSE)
+           (harness-log "GATE [Perceive]: Act Result -> ~a" (getf payload :status))))
+
+    (setf (getf signal :status) :perceived)
+    (setf (getf signal :foveal-focus) *foveal-focus-id*)
+    signal))
+#+end_src
+
+* Test Suite
+
+#+begin_src lisp :tangle ../tests/pipeline-perceive-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(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
+  (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
+  (let ((runaway-signal (list :type :EVENT :depth 11 :payload (list :sensor :heartbeat))))
+    (is (null (process-signal runaway-signal)))))
+#+end_src

harness/reason.lisp

@@ -0,0 +1,132 @@
+(in-package :opencortex)
+
+(defvar *probabilistic-backends* (make-hash-table :test 'equal))
+
+(defvar *provider-cascade* nil)
+
+(defvar *model-selector-fn* nil)
+
+(defvar *consensus-enabled-p* nil)
+
+(defun register-probabilistic-backend (name fn)
+  (setf (gethash name *probabilistic-backends*) fn))
+
+(defun probabilistic-call (prompt &key
+                                (system-prompt "You are the Probabilistic engine.")
+                                (cascade nil)
+                                (context nil))
+  (let ((backends (or cascade *provider-cascade*)))
+    (or (dolist (backend backends)
+          (let ((backend-fn (gethash backend *probabilistic-backends*)))
+            (when backend-fn
+              (harness-log "PROBABILISTIC: Attempting backend ~a..." backend)
+              (let* ((model (when *model-selector-fn*
+                              (funcall *model-selector-fn* backend context)))
+                     (result (if model
+                                 (funcall backend-fn prompt system-prompt :model model)
+                                 (funcall backend-fn prompt system-prompt))))
+                (cond ((and (listp result) (eq (getf result :status) :success))
+                       (return (getf result :content)))
+                      ((stringp result)
+                       (return result))
+                      (t
+                       (harness-log "PROBABILISTIC: Backend ~a failed: ~a"
+                                   backend (getf result :message))))))))
+        (list :type :LOG
+              :payload (list :text "Neural Cascade Failure: All providers exhausted.")))))
+
+(defun strip-markdown (text)
+  (if (and text (stringp text))
+      (let ((cleaned text))
+        (setf cleaned (cl-ppcre:regex-replace-all "^```[a-z]*\\n" cleaned ""))
+        (setf cleaned (cl-ppcre:regex-replace-all "\\n```$" cleaned ""))
+        (setf cleaned (cl-ppcre:regex-replace-all "```" cleaned ""))
+        (string-trim '(#\Space #\Newline #\Tab) cleaned))
+      text))
+
+(defun normalize-plist-keywords (plist)
+  (when (listp plist)
+    (loop for (k v) on plist by #'cddr
+          collect (if (and (symbolp k) (not (keywordp k)))
+                       (intern (string k) :keyword)
+                       k)
+          collect v)))
+
+(defun think (context)
+  (let* ((active-skill (find-triggered-skill context))
+         (tool-belt (generate-tool-belt-prompt))
+         (global-context (context-assemble-global-awareness))
+         (system-logs (context-get-system-logs))
+         (assistant-name (or (uiop:getenv "MEMEX_ASSISTANT") "Agent"))
+         (rejection-trace (proto-get (proto-get context :payload) :rejection-trace))
+         (prompt-generator (when active-skill (skill-probabilistic-prompt active-skill)))
+         (raw-prompt (if prompt-generator
+                         (funcall prompt-generator context)
+                         (let ((p (proto-get (proto-get context :payload) :text)))
+                           (if (and p (stringp p)) p "Maintain metabolic stasis."))))
+         (reflection-feedback (if rejection-trace
+                                  (format nil "~%~%PREVIOUS PROPOSAL REJECTED: ~a" rejection-trace)
+                                  ""))
+         (system-prompt (format nil "IDENTITY: ~a~a~%~%TOOLS:~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a" 
+                               assistant-name reflection-feedback tool-belt global-context system-logs)))
+    (let* ((thought (probabilistic-call raw-prompt :system-prompt system-prompt :context context))
+           (cleaned (strip-markdown thought)))
+       (if (and cleaned (stringp cleaned) (> (length cleaned) 0) (or (char= (char cleaned 0) #\() (char= (char cleaned 0) #\[)))
+           (handler-case
+               (let ((parsed (read-from-string cleaned)))
+                 (if (listp parsed)
+                     (normalize-plist-keywords parsed)
+                     (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
+             (error () (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
+            (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT (if (stringp cleaned) cleaned "No response") :EXPLANATION "Generated by the Probabilistic engine."))))))
+
+(defun deterministic-verify (proposed-action context)
+  (let ((current-action proposed-action)
+        (skills nil))
+    (maphash (lambda (name skill)
+               (declare (ignore name))
+               (when (skill-deterministic-fn skill)
+                 (push skill skills)))
+             *skills-registry*)
+    (setf skills (sort skills #'> :key #'skill-priority))
+    (dolist (skill skills)
+      (let ((trigger (skill-trigger-fn skill))
+            (gate (skill-deterministic-fn skill)))
+        (when (or (null trigger) (ignore-errors (funcall trigger context)))
+          (let ((next-action (funcall gate current-action context)))
+            (when (and (listp next-action)
+                       (member (proto-get next-action :type) '(:LOG :EVENT)))
+              (harness-log "DETERMINISTIC: Intercepted by skill '~a'" (skill-name skill))
+              (return-from deterministic-verify next-action))
+             (when next-action (setf current-action next-action))))))
+    current-action))
+
+(defun reason-gate (signal)
+  (let* ((type (proto-get signal :type))
+         (payload (proto-get signal :payload))
+         (sensor (proto-get payload :sensor)))
+    (unless (and (eq type :EVENT) (member sensor '(:user-input :chat-message)))
+      (return-from reason-gate signal))
+    (let ((retries 3)
+          (current-signal (copy-tree signal))
+          (last-rejection nil))
+      (loop
+        (when (<= retries 0)
+          (setf (getf signal :approved-action) last-rejection)
+          (setf (getf signal :status) :reasoned)
+          (return signal))
+        (when last-rejection
+          (setf (getf (getf current-signal :payload) :rejection-trace) last-rejection))
+        (let ((candidate (think current-signal)))
+          (if (and candidate (listp candidate))
+              (let ((verified (deterministic-verify candidate current-signal)))
+                (if (member (getf verified :type) '(:LOG :EVENT))
+                    (progn (decf retries) (setf last-rejection verified))
+                    (progn
+                      (setf (getf signal :approved-action) verified)
+                      (setf (getf signal :status) :reasoned)
+                      (return signal))))
+              (progn
+                (setf (getf signal :approved-action) nil)
+                (setf (getf signal :status) :reasoned)
+                (return signal))))))))

harness/reason.org

@@ -0,0 +1,212 @@
+#+TITLE: Stage 2: Reason (reason.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:reason:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle reason.lisp
+
+* Overview
+The Reason stage implements the core Innovation of OpenCortex: the separation of probabilistic reasoning (neural/LLM) from deterministic verification (logic/safety).
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Probabilistic Engine state
+~*probabilistic-backends*~ is the hash table mapping provider keywords to backend functions. ~*provider-cascade*~ is the ordered list of providers to try. ~*model-selector-fn*~ is an optional function that selects a model per request. ~*consensus-enabled-p*~ enables multi-provider agreement.
+#+begin_src lisp
+(defvar *probabilistic-backends* (make-hash-table :test 'equal))
+#+end_src
+
+#+begin_src lisp
+(defvar *provider-cascade* nil)
+#+end_src
+
+#+begin_src lisp
+(defvar *model-selector-fn* nil)
+#+end_src
+
+#+begin_src lisp
+(defvar *consensus-enabled-p* nil)
+#+end_src
+
+** Backend Registration (register-probabilistic-backend)
+#+begin_src lisp
+(defun register-probabilistic-backend (name fn)
+  (setf (gethash name *probabilistic-backends*) fn))
+#+end_src
+
+** Cascade Dispatch (probabilistic-call)
+#+begin_src lisp
+(defun probabilistic-call (prompt &key
+                                (system-prompt "You are the Probabilistic engine.")
+                                (cascade nil)
+                                (context nil))
+  (let ((backends (or cascade *provider-cascade*)))
+    (or (dolist (backend backends)
+          (let ((backend-fn (gethash backend *probabilistic-backends*)))
+            (when backend-fn
+              (harness-log "PROBABILISTIC: Attempting backend ~a..." backend)
+              (let* ((model (when *model-selector-fn*
+                              (funcall *model-selector-fn* backend context)))
+                     (result (if model
+                                 (funcall backend-fn prompt system-prompt :model model)
+                                 (funcall backend-fn prompt system-prompt))))
+                (cond ((and (listp result) (eq (getf result :status) :success))
+                       (return (getf result :content)))
+                      ((stringp result)
+                       (return result))
+                      (t
+                       (harness-log "PROBABILISTIC: Backend ~a failed: ~a"
+                                   backend (getf result :message))))))))
+        (list :type :LOG
+              :payload (list :text "Neural Cascade Failure: All providers exhausted.")))))
+#+end_src
+
+** Cognitive Proposal Generation (Think)
+#+begin_src lisp
+(defun strip-markdown (text)
+  (if (and text (stringp text))
+      (let ((cleaned text))
+        (setf cleaned (cl-ppcre:regex-replace-all "^```[a-z]*\\n" cleaned ""))
+        (setf cleaned (cl-ppcre:regex-replace-all "\\n```$" cleaned ""))
+        (setf cleaned (cl-ppcre:regex-replace-all "```" cleaned ""))
+        (string-trim '(#\Space #\Newline #\Tab) cleaned))
+      text))
+
+(defun normalize-plist-keywords (plist)
+  (when (listp plist)
+    (loop for (k v) on plist by #'cddr
+          collect (if (and (symbolp k) (not (keywordp k)))
+                       (intern (string k) :keyword)
+                       k)
+          collect v)))
+
+(defun think (context)
+  (let* ((active-skill (find-triggered-skill context))
+         (tool-belt (generate-tool-belt-prompt))
+         (global-context (context-assemble-global-awareness))
+         (system-logs (context-get-system-logs))
+         (assistant-name (or (uiop:getenv "MEMEX_ASSISTANT") "Agent"))
+         (rejection-trace (proto-get (proto-get context :payload) :rejection-trace))
+         (prompt-generator (when active-skill (skill-probabilistic-prompt active-skill)))
+         (raw-prompt (if prompt-generator
+                         (funcall prompt-generator context)
+                         (let ((p (proto-get (proto-get context :payload) :text)))
+                           (if (and p (stringp p)) p "Maintain metabolic stasis."))))
+         (reflection-feedback (if rejection-trace
+                                  (format nil "~%~%PREVIOUS PROPOSAL REJECTED: ~a" rejection-trace)
+                                  ""))
+         (skill-augments (let ((augments ""))
+                           (maphash (lambda (name skill)
+                                      (declare (ignore name))
+                                      (let ((aug-fn (skill-system-prompt-augment skill)))
+                                        (when aug-fn
+                                          (let ((aug-text (ignore-errors (funcall aug-fn context))))
+                                            (when (and aug-text (stringp aug-text) (> (length aug-text) 0))
+                                              (setf augments (concatenate 'string augments aug-text (string #\Newline))))))))
+                                    *skills-registry*)
+                           (when (> (length augments) 0) augments)))
+         (system-prompt (format nil "IDENTITY: ~a~a~%~%TOOLS:~%~a~%~%CONTEXT:~%~a~%~%LOGS:~%~a~%~a" 
+                                assistant-name reflection-feedback tool-belt global-context system-logs
+                                (or skill-augments ""))))
+    (let* ((thought (probabilistic-call raw-prompt :system-prompt system-prompt :context context))
+           (cleaned (strip-markdown thought)))
+       (if (and cleaned (stringp cleaned) (> (length cleaned) 0) (or (char= (char cleaned 0) #\() (char= (char cleaned 0) #\[)))
+           (handler-case
+               (let ((parsed (read-from-string cleaned)))
+                 (if (listp parsed)
+                     (normalize-plist-keywords parsed)
+                     (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
+             (error () (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT cleaned :EXPLANATION "Generated by the Probabilistic engine."))))
+            (list :TYPE :REQUEST :PAYLOAD (list :ACTION :MESSAGE :TEXT (if (stringp cleaned) cleaned "No response") :EXPLANATION "Generated by the Probabilistic engine."))))))
+#+end_src
+
+** Deterministic Engine (Verification)
+#+begin_src lisp
+(defun deterministic-verify (proposed-action context)
+  (let ((current-action proposed-action)
+        (skills nil))
+    (maphash (lambda (name skill)
+               (declare (ignore name))
+               (when (skill-deterministic-fn skill)
+                 (push skill skills)))
+             *skills-registry*)
+    (setf skills (sort skills #'> :key #'skill-priority))
+    (dolist (skill skills)
+      (let ((trigger (skill-trigger-fn skill))
+            (gate (skill-deterministic-fn skill)))
+        (when (or (null trigger) (ignore-errors (funcall trigger context)))
+          (let ((next-action (funcall gate current-action context)))
+            (when (and (listp next-action)
+                       (member (proto-get next-action :type) '(:LOG :EVENT)))
+              (harness-log "DETERMINISTIC: Intercepted by skill '~a'" (skill-name skill))
+              (return-from deterministic-verify next-action))
+             (when next-action (setf current-action next-action))))))
+    current-action))
+#+end_src
+
+** Reason Gate (Stage 2)
+#+begin_src lisp
+(defun reason-gate (signal)
+  (let* ((type (proto-get signal :type))
+         (payload (proto-get signal :payload))
+         (sensor (proto-get payload :sensor)))
+    (unless (and (eq type :EVENT) (member sensor '(:user-input :chat-message)))
+      (return-from reason-gate signal))
+    (let ((retries 3)
+          (current-signal (copy-tree signal))
+          (last-rejection nil))
+      (loop
+        (when (<= retries 0)
+          (setf (getf signal :approved-action) last-rejection)
+          (setf (getf signal :status) :reasoned)
+          (return signal))
+        (when last-rejection
+          (setf (getf (getf current-signal :payload) :rejection-trace) last-rejection))
+        (let ((candidate (think current-signal)))
+          (if (and candidate (listp candidate))
+              (let ((verified (deterministic-verify candidate current-signal)))
+                (if (member (getf verified :type) '(:LOG :EVENT))
+                    (progn (decf retries) (setf last-rejection verified))
+                    (progn
+                      (setf (getf signal :approved-action) verified)
+                      (setf (getf signal :status) :reasoned)
+                      (return signal))))
+              (progn
+                (setf (getf signal :approved-action) nil)
+                (setf (getf signal :status) :reasoned)
+                (return signal))))))))
+#+end_src
+
+* Test Suite
+#+begin_src lisp :tangle ../tests/pipeline-reason-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(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
+  (clrhash opencortex::*skills-registry*)
+  (opencortex::defskill :mock-safety
+    :priority 50
+    :trigger (lambda (ctx) (declare (ignore ctx)) t)
+    :deterministic (lambda (action ctx)
+                    (declare (ignore ctx))
+                    (if (search "rm -rf" (format nil "~s" action))
+                        (list :type :LOG :payload (list :text "Rejected"))
+                        action)))
+  (let* ((candidate '(:type :REQUEST :payload (:action :shell :cmd "rm -rf /")))
+         (signal '(:type :EVENT :payload (:sensor :user-input)))
+         (result (deterministic-verify candidate signal)))
+    (is (eq :LOG (getf result :type)))))
+#+end_src

harness/setup.org

@@ -0,0 +1,30 @@
+#+TITLE: Kernel Bootstrap (setup.org)
+#+AUTHOR: Amr
+#+FILETAGS: :harness:kernel:bootstrap:
+#+STARTUP: content
+
+* Overview
+The *Kernel Bootstrap* provides the absolute minimum logic required to transition from a raw POSIX shell to a functional Lisp environment.
+
+* Phase A: Demand (Thinking)
+** The Minimalist Kernel
+To maintain sovereignty, the harness must remain a "dumb" bus. It should not know about LLM providers or diagnostic suites. Its only responsibilities are:
+1. **Directory Resolution**: Locating XDG paths.
+2. **System Tangle**: Transforming literate Org sources into runnable Lisp.
+3. **Dependency Check**: Ensuring SBCL and Quicklisp are available.
+
+* Phase B: Protocol (Success Criteria)
+** Bootstrap Verification
+1. `test-xdg-dirs`: Verify that `setup_system` creates the Config/Data/State folders.
+2. `test-asdf-registration`: Verify that the `INSTALL_DIR` is correctly pushed to the ASDF central registry.
+
+* Phase C: Implementation (Build)
+
+** The Installer Script (opencortex.sh)
+The shell script is the primary entry point. It handles the initial git clone, dependency installation, and literate tangle.
+
+#+begin_src bash :tangle setup.sh
+#!/bin/bash
+# (The content here is a duplicate of the main opencortex.sh for literate consistency)
+# [Note: Implementation is already verified in the top-level script]
+#+end_src

harness/setup.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+# (The content here is a duplicate of the main opencortex.sh for literate consistency)
+# [Note: Implementation is already verified in the top-level script]

harness/skills.lisp

@@ -0,0 +1,276 @@
+(in-package :opencortex)
+
+(defun COSINE-SIMILARITY (v1 v2)
+  "Computes cosine similarity between two vectors."
+  (let* ((len1 (length v1)) (len2 (length v2)))
+    (if (or (zerop len1) (zerop len2))
+        0.0
+        (let* ((dot 0.0d0) (n1 0.0d0) (n2 0.0d0))
+          (dotimes (i (min len1 len2))
+            (let* ((x (coerce (elt v1 i) 'double-float)) (y (coerce (elt v2 i) 'double-float)))
+              (incf dot (* x y)) (incf n1 (* x x)) (incf n2 (* y y))))
+          (if (or (zerop n1) (zerop n2)) 0.0 (/ dot (sqrt (* n1 n2))))))))
+
+(defun VAULT-MASK-STRING (s) (declare (ignore s)) "[MASKED]")
+(defvar *VAULT-MEMORY* (make-hash-table :test 'equal))
+
+(defstruct skill name priority dependencies trigger-fn probabilistic-prompt deterministic-fn system-prompt-augment)
+
+(defvar *skills-registry* (make-hash-table :test 'equal))
+
+(defvar *skill-catalog* (make-hash-table :test 'equal)
+  "Tracks all discovered skill files and their loading state.")
+
+(defstruct skill-entry filename (status :discovered) error-log (load-time 0))
+
+(defun find-triggered-skill (context)
+  "Returns the highest priority skill whose trigger matches context."
+  (let ((triggered nil))
+    (maphash (lambda (name skill) 
+               (declare (ignore name)) 
+               (when (and (skill-probabilistic-prompt skill)
+                          (ignore-errors (funcall (skill-trigger-fn skill) context)))
+                 (push skill triggered))) 
+              *skills-registry*)
+    (first (sort triggered #'> :key #'skill-priority))))
+
+(defmacro defskill (name &key priority dependencies trigger probabilistic deterministic system-prompt-augment)
+  "Registers a new skill. NAME is a keyword. TRIGGER is a function (context) → bool."
+  `(setf (gethash (string-downcase (string ,name)) *skills-registry*)
+         (make-skill :name (string-downcase (string ,name)) 
+                    :priority (or ,priority 10) 
+                    :dependencies ',dependencies
+                    :trigger-fn ,trigger 
+                    :probabilistic-prompt ,probabilistic 
+                    :deterministic-fn ,deterministic
+                    :system-prompt-augment ,system-prompt-augment)))
+
+(defun resolve-skill-dependencies (skill-name)
+  "Resolves transitive dependencies. Returns list of skill names in dependency order."
+  (let ((resolved nil) (seen nil))
+    (labels ((visit (name) 
+               (unless (member name seen :test #'equal) 
+                 (push name seen)
+                 (let ((skill (gethash (string-downcase (string name)) *skills-registry*)))
+                   (when skill 
+                     (dolist (dep (skill-dependencies skill)) (visit dep))))
+                 (push name resolved))))
+      (visit skill-name) 
+      (nreverse resolved))))
+
+(defun parse-skill-metadata (filepath)
+  "Extracts ID and DEPENDS_ON tags from org file."
+  (let ((dependencies nil) (id nil) (content (uiop:read-file-string filepath)))
+    (let ((id-start (search ":ID:" content)))
+      (when id-start
+        (let ((id-end (position #\Newline content :start id-start)))
+          (when id-end (setf id (string-trim " " (subseq content (+ id-start 4) id-end)))))))
+    (let ((pos 0))
+      (loop while (setf pos (search "#+DEPENDS_ON:" content :start2 pos))
+            do (let ((end (position #\Newline content :start pos)))
+              (when end
+                (let ((line (string-trim " " (subseq content (+ pos 13) end))))
+                  (dolist (d (uiop:split-string line :separator '(#\Space #\Tab)))
+                    (unless (string= d "") (push d dependencies))))
+                (setf pos end)))))
+    (values id (reverse dependencies))))
+
+(defun topological-sort-skills (skills-dir)
+  "Returns a list of skill filepaths sorted by dependency."
+  (let* ((org-files (uiop:directory-files skills-dir "org-skill-*.org"))
+         (lisp-files (uiop:directory-files skills-dir "org-skill-*.lisp"))
+         (files (append org-files lisp-files))
+        (adj (make-hash-table :test 'equal))
+        (name-to-file (make-hash-table :test 'equal))
+        (id-to-file (make-hash-table :test 'equal))
+        (result nil)
+        (visited (make-hash-table :test 'equal))
+        (stack (make-hash-table :test 'equal)))
+    (dolist (file files)
+      (let ((filename (pathname-name file)))
+        (if (uiop:string-suffix-p (namestring file) ".lisp")
+            (progn
+              (setf (gethash (string-downcase filename) name-to-file) file)
+              ;; Don't overwrite dependency info from .org files
+              (unless (gethash (string-downcase filename) adj)
+                (setf (gethash (string-downcase filename) adj) nil)))
+            (multiple-value-bind (id deps) (parse-skill-metadata file)
+              (setf (gethash (string-downcase filename) name-to-file) file)
+              (when id (setf (gethash (string-downcase id) id-to-file) file))
+              (setf (gethash (string-downcase filename) adj) deps)))))
+    (labels ((visit (file)
+               (let* ((filename (pathname-name file))
+                      (node-key (string-downcase filename)))
+                 (unless (gethash node-key visited)
+                   (setf (gethash node-key stack) t)
+                   (dolist (dep (gethash node-key adj))
+                     (let* ((is-id-p (uiop:string-prefix-p "id:" (string-downcase dep)))
+                            (dep-key (string-downcase (if is-id-p (subseq dep 3) dep)))
+                            (dep-file (if is-id-p 
+                                          (gethash dep-key id-to-file)
+                                          (or (gethash dep-key id-to-file)
+                                              (gethash dep-key name-to-file)))))
+                       (when dep-file
+                         (let ((dep-filename (pathname-name dep-file)))
+                           (if (gethash (string-downcase dep-filename) stack)
+                               (error "Circular dependency detected")
+                               (visit dep-file))))))
+                   (setf (gethash node-key stack) nil)
+                   (setf (gethash node-key visited) t)
+                   (push file result)))))
+      (let ((filenames (sort (mapcar #'pathname-name files) #'string<)))
+        (dolist (name filenames)
+          (let ((file (gethash (string-downcase name) name-to-file)))
+            (when file (visit file)))))
+      (nreverse result))))
+
+(defun validate-lisp-syntax (code-string)
+  "Checks if a string contains valid Common Lisp forms."
+  (handler-case
+      (let ((*read-eval* nil))
+        (with-input-from-string (s (format nil "(progn ~a)" code-string))
+          (loop for form = (read s nil :eof) until (eq form :eof)))
+        (values t nil))
+    (error (c) (values nil (format nil "~a" c)))))
+
+(defun remove-in-package-forms (code-string)
+  "Removes in-package forms so symbols get defined in skill package."
+  (let ((lines (uiop:split-string code-string :separator '(#\Newline)))
+        (result ""))
+    (dolist (line lines)
+      (let ((trimmed (string-trim '(#\Space #\Tab) line)))
+        (unless (uiop:string-prefix-p "(in-package" trimmed)
+          (setf result (concatenate 'string result line (string #\Newline))))))
+    result))
+
+(defun extract-tangle-target (line)
+  "Extracts the value of the :tangle header."
+  (let ((pos (search ":tangle" line)))
+    (when pos
+      (let ((rest (string-trim '(#\Space #\Tab) (subseq line (+ pos 7)))))
+        (let ((end (position #\Space rest)))
+          (if end (subseq rest 0 end) rest))))))
+
+(defun load-skill-from-org (filepath)
+  "Parses and evaluates Lisp blocks from an Org file."
+  (let* ((skill-base-name (pathname-name filepath))
+         (entry (or (gethash skill-base-name *skill-catalog*) (setf (gethash skill-base-name *skill-catalog*) (make-skill-entry :filename skill-base-name)))))
+    (setf (skill-entry-status entry) :loading)
+    (handler-case
+        (let* ((content (uiop:read-file-string filepath))
+               (lines (uiop:split-string content :separator '(#\Newline)))
+               (in-lisp-block nil) (collect-this-block nil) (lisp-code "")
+               (pkg-name (intern (string-upcase (format nil "OPENCORTEX.SKILLS.~a" skill-base-name)) :keyword)))
+          (dolist (line lines)
+            (let ((clean-line (string-trim '(#\Space #\Tab #\Return) line)))
+              (cond
+                ((uiop:string-prefix-p "#+begin_src lisp" clean-line)
+                 (setf in-lisp-block t)
+                 (let ((target (extract-tangle-target clean-line)))
+                   ;; Collect if there's no tangle target (inherits from file)
+                   ;; or if it's a lisp file and NOT a test.
+                   (setf collect-this-block (or (null target)
+                                                (and (not (search "no" target))
+                                                     (not (search "/tests" target)))))))
+                ((uiop:string-prefix-p "#+end_src" clean-line)
+                 (setf in-lisp-block nil) (setf collect-this-block nil))
+                ((and in-lisp-block collect-this-block)
+                 (unless (or (uiop:string-prefix-p ":PROPERTIES:" (string-upcase clean-line))
+                             (uiop:string-prefix-p ":END:" (string-upcase clean-line))
+                             (uiop:string-prefix-p ":ID:" (string-upcase clean-line)))
+                   (setf lisp-code (concatenate 'string lisp-code line (string #\Newline))))))))
+          (if (= (length lisp-code) 0)
+              (setf (skill-entry-status entry) :ready)
+              (progn
+                (multiple-value-bind (valid-p err) (validate-lisp-syntax lisp-code)
+                  (unless valid-p (error err)))
+                (unless (find-package pkg-name)
+                  (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :opencortex new-pkg)))
+                (let ((*read-eval* nil) (*package* (find-package pkg-name)))
+                  (harness-log "LOADER: Evaluating code for '~a' in package ~a" skill-base-name (package-name *package*))
+                  (eval (read-from-string (format nil "(progn ~a)" lisp-code))))
+
+                ;; Export symbols back to :OPENCORTEX for discoverability and testing
+                (let* ((target-pkg (find-package :opencortex))
+                       (raw-name (string-upcase skill-base-name))
+                       (short-name (if (uiop:string-prefix-p "ORG-SKILL-" raw-name)
+                                       (subseq raw-name 10)
+                                       raw-name)))
+                  (harness-log "LOADER: Scanning package ~a for symbols to export..." (package-name (find-package pkg-name)))
+                  (do-symbols (sym (find-package pkg-name))
+                    (when (eq (symbol-package sym) (find-package pkg-name))
+                      (let ((sn (symbol-name sym)))
+                        (when (or (uiop:string-prefix-p raw-name sn)
+                                  (uiop:string-prefix-p short-name sn)
+                                  (string-equal sn "DOCTOR-MAIN")
+                                  (string-equal sn "RUN-SETUP-WIZARD"))
+                          (harness-log "LOADER: Exporting ~a to :OPENCORTEX" sn)
+                          ;; Resolve potential name conflicts by uninterning first
+                          (let ((existing (find-symbol sn target-pkg)))
+                            (when (and existing (not (eq existing sym)))
+                              (unintern existing target-pkg)))
+                          (import sym target-pkg)
+                          (export sym target-pkg))))))
+
+                (setf (skill-entry-status entry) :ready)))
+          t)
+      (error (c)
+        (harness-log "LOADER ERROR in skill '~a': ~a" skill-base-name c)
+        (setf (skill-entry-status entry) :failed) nil))))
+
+(defun load-skill-from-lisp (filepath)
+  "Loads a .lisp skill file directly, filtering out in-package forms."
+  (let* ((skill-base-name (pathname-name filepath))
+         (entry (or (gethash skill-base-name *skill-catalog*) (setf (gethash skill-base-name *skill-catalog*) (make-skill-entry :filename skill-base-name)))))
+    (setf (skill-entry-status entry) :loading)
+    (handler-case
+        (let* ((content (remove-in-package-forms (uiop:read-file-string filepath)))
+               (pkg-name (intern (string-upcase (format nil "OPENCORTEX.SKILLS.~a" skill-base-name)) :keyword)))
+          (multiple-value-bind (valid-p err) (validate-lisp-syntax content)
+            (unless valid-p (error err)))
+          (unless (find-package pkg-name)
+            (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :opencortex new-pkg)))
+          (let ((*read-eval* nil) (*package* (find-package pkg-name)))
+            (harness-log "LOADER: Loading .lisp skill '~a' in package ~a" skill-base-name (package-name *package*))
+            ;; Evaluate forms individually so one bad form doesn't abort the entire skill
+            (with-input-from-string (s content)
+              (loop for form = (read s nil :eof) until (eq form :eof)
+                    do (handler-case (eval form)
+                         (error (c) (harness-log "LOADER WARNING in '~a': ~a" skill-base-name c))))))
+          ;; Export symbols
+          (let* ((target-pkg (find-package :opencortex))
+                 (raw-name (string-upcase skill-base-name))
+                 (short-name (if (uiop:string-prefix-p "ORG-SKILL-" raw-name)
+                                 (subseq raw-name 10)
+                                 raw-name)))
+            (harness-log "LOADER: Scanning package ~a for symbols to export..." (package-name (find-package pkg-name)))
+            (do-symbols (sym (find-package pkg-name))
+              (when (eq (symbol-package sym) (find-package pkg-name))
+                (let ((sn (symbol-name sym)))
+                  (when (or (uiop:string-prefix-p raw-name sn)
+                            (uiop:string-prefix-p short-name sn)
+                            (string-equal sn "DOCTOR-MAIN")
+                            (string-equal sn "RUN-SETUP-WIZARD"))
+                    (harness-log "LOADER: Exporting ~a to :OPENCORTEX" sn)
+                    (let ((existing (find-symbol sn target-pkg)))
+                      (when (and existing (not (eq existing sym)))
+                        (unintern existing target-pkg)))
+                    (import sym target-pkg)
+                    (export sym target-pkg))))))
+          (setf (skill-entry-status entry) :ready))
+      (error (c)
+        (harness-log "LOADER ERROR in skill '~a': ~a" skill-base-name c)
+        (setf (skill-entry-status entry) :failed) nil))))
+
+(defun initialize-all-skills ()
+  "Initializes all skills from the XDG skills directory."
+  (let* ((data-dir (uiop:ensure-directory-pathname (or (uiop:getenv "OC_DATA_DIR") (namestring (merge-pathnames ".local/share/opencortex/" (user-homedir-pathname))))))
+         (skills-dir (merge-pathnames "skills/" data-dir)))
+    (unless (uiop:directory-exists-p skills-dir) (return-from initialize-all-skills nil))
+    (let ((sorted-files (topological-sort-skills skills-dir)))
+      (harness-log "LOADER: Initializing ~a skills..." (length sorted-files))
+      (dolist (file sorted-files)
+        (if (uiop:string-suffix-p (namestring file) ".lisp")
+            (load-skill-from-lisp file)
+            (load-skill-from-org file)))
+      (harness-log "LOADER: Boot Complete."))))

harness/skills.org

@@ -0,0 +1,373 @@
+#+TITLE: The Skill Engine (skills.lisp)
+#+AUTHOR: Agent
+#+FILETAGS: :harness:skills:
+#+STARTUP: content
+#+PROPERTY: header-args:lisp :tangle skills.lisp
+
+* Overview
+The Skill Engine is the dynamic loading and lifecycle manager for all OpenCortex skills. It discovers skill files in the skills directory, resolves their dependency order, loads them into jailed packages, exports their public symbols into the ~opencortex~ package, and provides the ~defskill~ macro that skills use to register themselves.
+
+Key concepts:
+- ~defskill~ — macro that registers a skill with its trigger, deterministic gate, and optional probabilistic prompt
+- ~def-cognitive-tool~ — macro that registers a tool the LLM can invoke
+- ~load-skill-from-org~ / ~load-skill-from-lisp~ — load a skill from a literate Org file or a pre-tangled Lisp file
+- ~topological-sort-skills~ — orders skills by their ~#+DEPENDS_ON:~ declarations
+- ~find-triggered-skill~ — returns the highest-priority skill whose trigger matches the current context
+
+The engine supports **hot-reload** — skills can be replaced at runtime without restarting the daemon.
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :opencortex)
+#+end_src
+
+** Utility functions
+Helper functions used by the skill loader and other components.
+
+*** Cosine similarity
+Computes the cosine similarity between two numeric vectors. Used by the peripheral vision system for semantic relevance scoring.
+#+begin_src lisp
+(defun COSINE-SIMILARITY (v1 v2)
+  "Computes cosine similarity between two vectors."
+  (let* ((len1 (length v1)) (len2 (length v2)))
+    (if (or (zerop len1) (zerop len2))
+        0.0
+        (let* ((dot 0.0d0) (n1 0.0d0) (n2 0.0d0))
+          (dotimes (i (min len1 len2))
+            (let* ((x (coerce (elt v1 i) 'double-float)) (y (coerce (elt v2 i) 'double-float)))
+              (incf dot (* x y)) (incf n1 (* x x)) (incf n2 (* y y))))
+          (if (or (zerop n1) (zerop n2)) 0.0 (/ dot (sqrt (* n1 n2))))))))
+#+end_src
+
+*** Secret masking
+Simple mask function and the vault memory hash table. Used by the Bouncer skill and credentials vault.
+#+begin_src lisp
+(defun VAULT-MASK-STRING (s) (declare (ignore s)) "[MASKED]")
+(defvar *VAULT-MEMORY* (make-hash-table :test 'equal))
+#+end_src
+
+** Skill data structures
+The ~skill~ struct holds all metadata about a loaded skill: its name, priority, dependencies, trigger function, probabilistic prompt generator, deterministic gate, and system prompt augmentor. The ~skill-entry~ struct tracks the loading state of each discovered skill file.
+#+begin_src lisp
+(defstruct skill name priority dependencies trigger-fn probabilistic-prompt deterministic-fn system-prompt-augment)
+#+end_src
+
+#+begin_src lisp
+(defvar *skills-registry* (make-hash-table :test 'equal))
+#+end_src
+
+#+begin_src lisp
+(defvar *skill-catalog* (make-hash-table :test 'equal)
+  "Tracks all discovered skill files and their loading state.")
+#+end_src
+
+#+begin_src lisp
+(defstruct skill-entry filename (status :discovered) error-log (load-time 0))
+#+end_src
+
+** Skill discovery (find-triggered-skill)
+Iterates the registry and returns the highest-priority skill whose trigger function matches the current context. Only skills with a probabilistic prompt are considered (skills that are purely deterministic don't need LLM intervention).
+#+begin_src lisp
+(defun find-triggered-skill (context)
+  "Returns the highest priority skill whose trigger matches context."
+  (let ((triggered nil))
+    (maphash (lambda (name skill) 
+               (declare (ignore name)) 
+               (when (and (skill-probabilistic-prompt skill)
+                          (ignore-errors (funcall (skill-trigger-fn skill) context)))
+                 (push skill triggered))) 
+              *skills-registry*)
+    (first (sort triggered #'> :key #'skill-priority))))
+#+end_src
+
+** Skill registration macro (defskill)
+The primary API for skills. Each skill file calls this once to register itself. The macro creates a ~skill~ struct and stores it in ~*skills-registry*~ keyed by the skill's name.
+#+begin_src lisp
+(defmacro defskill (name &key priority dependencies trigger probabilistic deterministic system-prompt-augment)
+  "Registers a new skill. NAME is a keyword. TRIGGER is a function (context) → bool."
+  `(setf (gethash (string-downcase (string ,name)) *skills-registry*)
+         (make-skill :name (string-downcase (string ,name)) 
+                    :priority (or ,priority 10) 
+                    :dependencies ',dependencies
+                    :trigger-fn ,trigger 
+                    :probabilistic-prompt ,probabilistic 
+                    :deterministic-fn ,deterministic
+                    :system-prompt-augment ,system-prompt-augment)))
+#+end_src
+
+** Dependency resolution (resolve-skill-dependencies)
+Recursively resolves all transitive dependencies for a given skill, returning an ordered list. Uses a standard topological sort with cycle detection (a ~seen~ set prevents infinite recursion).
+#+begin_src lisp
+(defun resolve-skill-dependencies (skill-name)
+  "Resolves transitive dependencies. Returns list of skill names in dependency order."
+  (let ((resolved nil) (seen nil))
+    (labels ((visit (name) 
+               (unless (member name seen :test #'equal) 
+                 (push name seen)
+                 (let ((skill (gethash (string-downcase (string name)) *skills-registry*)))
+                   (when skill 
+                     (dolist (dep (skill-dependencies skill)) (visit dep))))
+                 (push name resolved))))
+      (visit skill-name) 
+      (nreverse resolved))))
+#+end_src
+
+** Skill File Analysis (parse-skill-metadata)
+#+begin_src lisp
+(defun parse-skill-metadata (filepath)
+  "Extracts ID and DEPENDS_ON tags from org file."
+  (let ((dependencies nil) (id nil) (content (uiop:read-file-string filepath)))
+    (let ((id-start (search ":ID:" content)))
+      (when id-start
+        (let ((id-end (position #\Newline content :start id-start)))
+          (when id-end (setf id (string-trim " " (subseq content (+ id-start 4) id-end)))))))
+    (let ((pos 0))
+      (loop while (setf pos (search "#+DEPENDS_ON:" content :start2 pos))
+            do (let ((end (position #\Newline content :start pos)))
+              (when end
+                (let ((line (string-trim " " (subseq content (+ pos 13) end))))
+                  (dolist (d (uiop:split-string line :separator '(#\Space #\Tab)))
+                    (unless (string= d "") (push d dependencies))))
+                (setf pos end)))))
+    (values id (reverse dependencies))))
+#+end_src
+
+** Dependency Resolution (topological-sort-skills)
+#+begin_src lisp
+(defun topological-sort-skills (skills-dir)
+  "Returns a list of skill filepaths sorted by dependency."
+  (let* ((org-files (uiop:directory-files skills-dir "org-skill-*.org"))
+         (lisp-files (uiop:directory-files skills-dir "org-skill-*.lisp"))
+         (files (append org-files lisp-files))
+        (adj (make-hash-table :test 'equal))
+        (name-to-file (make-hash-table :test 'equal))
+        (id-to-file (make-hash-table :test 'equal))
+        (result nil)
+        (visited (make-hash-table :test 'equal))
+        (stack (make-hash-table :test 'equal)))
+    (dolist (file files)
+      (let ((filename (pathname-name file)))
+        (if (uiop:string-suffix-p (namestring file) ".lisp")
+            (progn
+              (setf (gethash (string-downcase filename) name-to-file) file)
+              ;; Don't overwrite dependency info from .org files
+              (unless (gethash (string-downcase filename) adj)
+                (setf (gethash (string-downcase filename) adj) nil)))
+            (multiple-value-bind (id deps) (parse-skill-metadata file)
+              (setf (gethash (string-downcase filename) name-to-file) file)
+              (when id (setf (gethash (string-downcase id) id-to-file) file))
+              (setf (gethash (string-downcase filename) adj) deps)))))
+    (labels ((visit (file)
+               (let* ((filename (pathname-name file))
+                      (node-key (string-downcase filename)))
+                 (unless (gethash node-key visited)
+                   (setf (gethash node-key stack) t)
+                   (dolist (dep (gethash node-key adj))
+                     (let* ((is-id-p (uiop:string-prefix-p "id:" (string-downcase dep)))
+                            (dep-key (string-downcase (if is-id-p (subseq dep 3) dep)))
+                            (dep-file (if is-id-p 
+                                          (gethash dep-key id-to-file)
+                                          (or (gethash dep-key id-to-file)
+                                              (gethash dep-key name-to-file)))))
+                       (when dep-file
+                         (let ((dep-filename (pathname-name dep-file)))
+                           (if (gethash (string-downcase dep-filename) stack)
+                               (error "Circular dependency detected")
+                               (visit dep-file))))))
+                   (setf (gethash node-key stack) nil)
+                   (setf (gethash node-key visited) t)
+                   (push file result)))))
+      (let ((filenames (sort (mapcar #'pathname-name files) #'string<)))
+        (dolist (name filenames)
+          (let ((file (gethash (string-downcase name) name-to-file)))
+            (when file (visit file)))))
+      (nreverse result))))
+#+end_src
+
+** Jailed Loading (load-skill-from-org)
+#+begin_src lisp
+(defun validate-lisp-syntax (code-string)
+  "Checks if a string contains valid Common Lisp forms."
+  (handler-case
+      (let ((*read-eval* nil))
+        (with-input-from-string (s (format nil "(progn ~a)" code-string))
+          (loop for form = (read s nil :eof) until (eq form :eof)))
+        (values t nil))
+    (error (c) (values nil (format nil "~a" c)))))
+
+(defun remove-in-package-forms (code-string)
+  "Removes in-package forms so symbols get defined in skill package."
+  (let ((lines (uiop:split-string code-string :separator '(#\Newline)))
+        (result ""))
+    (dolist (line lines)
+      (let ((trimmed (string-trim '(#\Space #\Tab) line)))
+        (unless (uiop:string-prefix-p "(in-package" trimmed)
+          (setf result (concatenate 'string result line (string #\Newline))))))
+    result))
+
+(defun extract-tangle-target (line)
+  "Extracts the value of the :tangle header."
+  (let ((pos (search ":tangle" line)))
+    (when pos
+      (let ((rest (string-trim '(#\Space #\Tab) (subseq line (+ pos 7)))))
+        (let ((end (position #\Space rest)))
+          (if end (subseq rest 0 end) rest))))))
+
+(defun load-skill-from-org (filepath)
+  "Parses and evaluates Lisp blocks from an Org file."
+  (let* ((skill-base-name (pathname-name filepath))
+         (entry (or (gethash skill-base-name *skill-catalog*) (setf (gethash skill-base-name *skill-catalog*) (make-skill-entry :filename skill-base-name)))))
+    (setf (skill-entry-status entry) :loading)
+    (handler-case
+        (let* ((content (uiop:read-file-string filepath))
+               (lines (uiop:split-string content :separator '(#\Newline)))
+               (in-lisp-block nil) (collect-this-block nil) (lisp-code "")
+               (pkg-name (intern (string-upcase (format nil "OPENCORTEX.SKILLS.~a" skill-base-name)) :keyword)))
+          (dolist (line lines)
+            (let ((clean-line (string-trim '(#\Space #\Tab #\Return) line)))
+              (cond
+                ((uiop:string-prefix-p "#+begin_src lisp" clean-line)
+                 (setf in-lisp-block t)
+                 (let ((target (extract-tangle-target clean-line)))
+                   ;; Collect if there's no tangle target (inherits from file)
+                   ;; or if it's a lisp file and NOT a test.
+                   (setf collect-this-block (or (null target)
+                                                (and (not (search "no" target))
+                                                     (not (search "/tests" target)))))))
+                ((uiop:string-prefix-p "#+end_src" clean-line)
+                 (setf in-lisp-block nil) (setf collect-this-block nil))
+                ((and in-lisp-block collect-this-block)
+                 (unless (or (uiop:string-prefix-p ":PROPERTIES:" (string-upcase clean-line))
+                             (uiop:string-prefix-p ":END:" (string-upcase clean-line))
+                             (uiop:string-prefix-p ":ID:" (string-upcase clean-line)))
+                   (setf lisp-code (concatenate 'string lisp-code line (string #\Newline))))))))
+          (if (= (length lisp-code) 0)
+              (setf (skill-entry-status entry) :ready)
+              (progn
+                (multiple-value-bind (valid-p err) (validate-lisp-syntax lisp-code)
+                  (unless valid-p (error err)))
+                (unless (find-package pkg-name)
+                  (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :opencortex new-pkg)))
+                (let ((*read-eval* nil) (*package* (find-package pkg-name)))
+                  (harness-log "LOADER: Evaluating code for '~a' in package ~a" skill-base-name (package-name *package*))
+                  (eval (read-from-string (format nil "(progn ~a)" lisp-code))))
+
+                ;; Export symbols back to :OPENCORTEX for discoverability and testing
+                (let* ((target-pkg (find-package :opencortex))
+                       (raw-name (string-upcase skill-base-name))
+                       (short-name (if (uiop:string-prefix-p "ORG-SKILL-" raw-name)
+                                       (subseq raw-name 10)
+                                       raw-name)))
+                  (harness-log "LOADER: Scanning package ~a for symbols to export..." (package-name (find-package pkg-name)))
+                  (do-symbols (sym (find-package pkg-name))
+                    (when (eq (symbol-package sym) (find-package pkg-name))
+                      (let ((sn (symbol-name sym)))
+                        (when (or (uiop:string-prefix-p raw-name sn)
+                                  (uiop:string-prefix-p short-name sn)
+                                  (string-equal sn "DOCTOR-MAIN")
+                                  (string-equal sn "RUN-SETUP-WIZARD"))
+                          (harness-log "LOADER: Exporting ~a to :OPENCORTEX" sn)
+                          ;; Resolve potential name conflicts by uninterning first
+                          (let ((existing (find-symbol sn target-pkg)))
+                            (when (and existing (not (eq existing sym)))
+                              (unintern existing target-pkg)))
+                          (import sym target-pkg)
+                          (export sym target-pkg))))))
+
+                (setf (skill-entry-status entry) :ready)))
+          t)
+      (error (c)
+        (harness-log "LOADER ERROR in skill '~a': ~a" skill-base-name c)
+        (setf (skill-entry-status entry) :failed) nil))))
+
+(defun load-skill-from-lisp (filepath)
+  "Loads a .lisp skill file directly, filtering out in-package forms."
+  (let* ((skill-base-name (pathname-name filepath))
+         (entry (or (gethash skill-base-name *skill-catalog*) (setf (gethash skill-base-name *skill-catalog*) (make-skill-entry :filename skill-base-name)))))
+    (setf (skill-entry-status entry) :loading)
+    (handler-case
+        (let* ((content (remove-in-package-forms (uiop:read-file-string filepath)))
+               (pkg-name (intern (string-upcase (format nil "OPENCORTEX.SKILLS.~a" skill-base-name)) :keyword)))
+          (multiple-value-bind (valid-p err) (validate-lisp-syntax content)
+            (unless valid-p (error err)))
+          (unless (find-package pkg-name)
+            (let ((new-pkg (make-package pkg-name :use '(:cl)))) (use-package :opencortex new-pkg)))
+          (let ((*read-eval* nil) (*package* (find-package pkg-name)))
+            (harness-log "LOADER: Loading .lisp skill '~a' in package ~a" skill-base-name (package-name *package*))
+            ;; Evaluate forms individually so one bad form doesn't abort the entire skill
+            (with-input-from-string (s content)
+              (loop for form = (read s nil :eof) until (eq form :eof)
+                    do (handler-case (eval form)
+                         (error (c) (harness-log "LOADER WARNING in '~a': ~a" skill-base-name c))))))
+          ;; Export symbols
+          (let* ((target-pkg (find-package :opencortex))
+                 (raw-name (string-upcase skill-base-name))
+                 (short-name (if (uiop:string-prefix-p "ORG-SKILL-" raw-name)
+                                 (subseq raw-name 10)
+                                 raw-name)))
+            (harness-log "LOADER: Scanning package ~a for symbols to export..." (package-name (find-package pkg-name)))
+            (do-symbols (sym (find-package pkg-name))
+              (when (eq (symbol-package sym) (find-package pkg-name))
+                (let ((sn (symbol-name sym)))
+                  (when (or (uiop:string-prefix-p raw-name sn)
+                            (uiop:string-prefix-p short-name sn)
+                            (string-equal sn "DOCTOR-MAIN")
+                            (string-equal sn "RUN-SETUP-WIZARD"))
+                    (harness-log "LOADER: Exporting ~a to :OPENCORTEX" sn)
+                    (let ((existing (find-symbol sn target-pkg)))
+                      (when (and existing (not (eq existing sym)))
+                        (unintern existing target-pkg)))
+                    (import sym target-pkg)
+                    (export sym target-pkg))))))
+          (setf (skill-entry-status entry) :ready))
+      (error (c)
+        (harness-log "LOADER ERROR in skill '~a': ~a" skill-base-name c)
+        (setf (skill-entry-status entry) :failed) nil))))
+#+end_src
+
+** Initialize (initialize-all-skills)
+#+begin_src lisp
+(defun initialize-all-skills ()
+  "Initializes all skills from the XDG skills directory."
+  (let* ((data-dir (uiop:ensure-directory-pathname (or (uiop:getenv "OC_DATA_DIR") (namestring (merge-pathnames ".local/share/opencortex/" (user-homedir-pathname))))))
+         (skills-dir (merge-pathnames "skills/" data-dir)))
+    (unless (uiop:directory-exists-p skills-dir) (return-from initialize-all-skills nil))
+    (let ((sorted-files (topological-sort-skills skills-dir)))
+      (harness-log "LOADER: Initializing ~a skills..." (length sorted-files))
+      (dolist (file sorted-files)
+        (if (uiop:string-suffix-p (namestring file) ".lisp")
+            (load-skill-from-lisp file)
+            (load-skill-from-org file)))
+      (harness-log "LOADER: Boot Complete."))))
+#+end_src
+
+* Test Suite
+#+begin_src lisp :tangle ../tests/boot-sequence-tests.lisp
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(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-topological-sort-basic
+  (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))))
+#+end_src

harness/tui-client.lisp

@@ -0,0 +1,147 @@
+(in-package :cl-user)
+(defpackage :opencortex.tui
+  (:use :cl :croatoan :usocket :bordeaux-threads)
+  (:export :main))
+(in-package :opencortex.tui)
+
+(defvar *daemon-host* "127.0.0.1")
+(defvar *daemon-port* 9105)
+(defvar *socket* nil)
+(defvar *stream* nil)
+(defvar *chat-history* nil)
+(defvar *input-list* nil) ; List of characters (stored in reverse)
+(defvar *is-running* t)
+(defvar *queue-lock* (bt:make-lock))
+(defvar *incoming-msgs* nil)
+
+(defun log-debug (msg &rest args)
+  (ignore-errors
+    (with-open-file (s "/tmp/opencortex-tui-debug.log" :direction :output :if-exists :append :if-does-not-exist :create)
+      (format s "[~a] " (get-universal-time))
+      (apply #'format s msg args)
+      (terpri s)
+      (finish-output s))))
+
+(defun enqueue-msg (msg)
+  (bt:with-lock-held (*queue-lock*)
+    (setf *incoming-msgs* (append *incoming-msgs* (list msg)))))
+
+(defun dequeue-msgs ()
+  (bt:with-lock-held (*queue-lock*)
+    (let ((msgs *incoming-msgs*))
+      (setf *incoming-msgs* nil)
+      msgs)))
+
+(defun render-chat (win h)
+  (when (and win (integerp h))
+    (clear win)
+    (box win 0 0)
+    (let* ((view-height (- h 2))
+           (history (copy-list *chat-history*))
+           (len (length history))
+           (num-to-draw (min len view-height))
+           (slice (subseq history 0 num-to-draw)))
+      (loop for i from 0 below num-to-draw
+            for msg in (reverse slice)
+            do (when msg
+                 (add-string win (format nil "│ ~a" msg) :y (1+ i) :x 2))))
+    (refresh win)))
+
+(defun handle-backspace ()
+  (pop *input-list*))
+
+(defun handle-return (stream)
+  (let ((cmd (coerce (reverse *input-list*) 'string)))
+    (setf *input-list* nil)
+    (log-debug "SUBMITTING: '~a'" cmd)
+    (when (> (length cmd) 0)
+      (push (format nil "⬆ ~a" cmd) *chat-history*)
+      (handler-case
+          (progn
+            (if (and stream (open-stream-p stream))
+                (let* ((msg (list :TYPE :EVENT 
+                                 :META (list :SOURCE :tui)
+                                 :PAYLOAD (list :SENSOR :user-input :TEXT cmd)))
+                       (payload (format nil "~s" msg))
+                       (len (length payload)))
+                  (format stream "~6,'0x~a" len payload)
+                  (finish-output stream)
+                  (log-debug "SENT WIRE: ~a" payload))
+                (push "ERROR: Not connected." *chat-history*)))
+        (error (c)
+          (log-debug "SEND ERROR: ~a" c)
+          (push (format nil "ERROR: ~a" c) *chat-history*)
+          (setf *is-running* nil))))
+    (when (string= cmd "/exit") (setf *is-running* nil))
+    (when (string= cmd "/clear") (setf *chat-history* nil))))
+
+(defun start-background-reader (stream)
+  (bt:make-thread
+   (lambda ()
+     (loop while *is-running* do
+       (handler-case
+           (let* ((len-buf (make-string 6))
+                  (count (read-sequence len-buf stream)))
+             (if (= count 6)
+                 (let* ((msg-len (parse-integer len-buf :radix 16))
+                        (msg-buf (make-string msg-len)))
+                   (read-sequence msg-buf stream)
+                   (log-debug "DAEMON MSG: ~a" msg-buf)
+                   (let ((msg (read-from-string msg-buf)))
+                     (let ((payload (getf msg :payload)))
+                       (cond
+                         ((eq (getf payload :action) :handshake)
+                          (enqueue-msg "* Connected *"))
+                         (t
+                          (let ((text (or (getf payload :text) (format nil "~a" payload))))
+                            (enqueue-msg (format nil "⬇ ~a" text))))))))
+                 (sleep 0.05)))
+         (error (c)
+           (when *is-running*
+             (log-debug "READER ERROR: ~a" c)
+             (enqueue-msg "ERROR: Connection lost.")
+             (setf *is-running* nil))))))
+   :name "opencortex-tui-reader"))
+
+(defun main ()
+  (log-debug "=== START ===")
+  (handler-case
+      (setf *socket* (usocket:socket-connect *daemon-host* *daemon-port*))
+    (error (e) (format t "Offline: ~a~%" e) (return-from main)))
+  (setf *stream* (usocket:socket-stream *socket*))
+  
+  (unwind-protect
+      (with-screen (scr :input-echoing nil :input-blocking nil :enable-colors t)
+        (let* ((h (or (height scr) 24))
+               (w (or (width scr) 80))
+               (chat-h (- h 4))
+               (chat-win (make-instance 'window :height chat-h :width (- w 2) :y 1 :x 1))
+               (input-win (make-instance 'window :height 1 :width (- w 2) :y (- h 2) :x 1)))
+          (setf (input-blocking input-win) nil)
+          (start-background-reader *stream*)
+          (loop :while *is-running* :do
+            (let ((msgs (dequeue-msgs)))
+              (when msgs 
+                (dolist (m msgs) (push m *chat-history*))
+                (render-chat chat-win chat-h)))
+            (let ((ch (get-char input-win)))
+              (when (and ch (not (equal ch -1)))
+                (log-debug "KEY: ~s" ch)
+                (cond
+                  ((or (eql ch 10) (eql ch 13) (eq ch :enter) (eql ch #\Newline) (eql ch #\Return))
+                   (handle-return *stream*)
+                   (render-chat chat-win chat-h))
+                  ((or (eql ch 127) (eql ch 8) (eq ch :backspace) (eql ch #\Backspace))
+                   (handle-backspace))
+                  ((characterp ch)
+                   (push ch *input-list*))
+                  ((integerp ch)
+                   (let ((converted (code-char ch)))
+                     (when (graphic-char-p converted)
+                       (push converted *input-list*))))))
+              (clear input-win)
+              (add-string input-win (format nil "▶ ~a" (coerce (reverse *input-list*) 'string)) :y 0 :x 1)
+              (refresh input-win))
+            (sleep 0.01))))
+    (setf *is-running* nil)
+    (when *socket* (ignore-errors (usocket:socket-close *socket*)))))

harness/tui-client.org

@@ -0,0 +1,229 @@
+#+TITLE: OpenCortex TUI Client (Standalone)
+#+STARTUP: content
+#+FILETAGS: :tui:ux:client:
+#+PROPERTY: header-args:lisp :tangle tui-client.lisp
+
+* Overview
+The TUI Client is a standalone ncurses application (built on Croatoan) that connects to the daemon via TCP. It provides a split-pane interface: a scrollable chat history window and a fixed input line at the bottom. Connected to the daemon at ~localhost:9105~, it sends user input as framed protocol messages and displays responses as they arrive from the daemon's background reader thread.
+
+* Implementation
+
+** Package Context
+#+begin_src lisp
+(in-package :cl-user)
+(defpackage :opencortex.tui
+  (:use :cl :croatoan :usocket :bordeaux-threads)
+  (:export :main))
+(in-package :opencortex.tui)
+#+end_src
+
+** Connection state
+#+begin_src lisp
+(defvar *daemon-host* "localhost")
+#+end_src
+
+#+begin_src lisp
+(defvar *daemon-port* 9105)
+#+end_src
+
+#+begin_src lisp
+(defvar *socket* nil)
+#+end_src
+
+#+begin_src lisp
+(defvar *stream* nil)
+#+end_src
+
+** UI state
+#+begin_src lisp
+(defvar *chat-history* nil)
+#+end_src
+
+#+begin_src lisp
+(defvar *input-list* nil)
+#+end_src
+
+#+begin_src lisp
+(defvar *is-running* t)
+#+end_src
+
+** Thread-safe message queue
+#+begin_src lisp
+(defvar *queue-lock* (bt:make-lock "incoming-queue-lock"))
+#+end_src
+
+#+begin_src lisp
+(defvar *incoming-msgs* nil)
+#+end_src
+
+** Utilities
+#+begin_src lisp
+(defun log-debug (msg &rest args)
+  (ignore-errors
+    (with-open-file (s "/tmp/opencortex-tui-debug.log" :direction :output :if-exists :append :if-does-not-exist :create)
+      (format s "[~a] " (get-universal-time))
+      (apply #'format s msg args)
+      (terpri s)
+      (finish-output s))))
+
+(defun enqueue-msg (msg)
+  (bt:with-lock-held (*queue-lock*)
+    (setf *incoming-msgs* (append *incoming-msgs* (list msg)))))
+
+(defun dequeue-msgs ()
+  (bt:with-lock-held (*queue-lock*)
+    (let ((msgs *incoming-msgs*))
+      (setf *incoming-msgs* nil)
+      msgs)))
+#+end_src
+
+** Rendering
+#+begin_src lisp
+(defun render-chat (win h)
+  (when (and win (integerp h))
+    (clear win)
+    (box win 0 0)
+    (let* ((view-height (- h 2))
+           (history (copy-list *chat-history*))
+           (len (length history))
+           (num-to-draw (min len view-height))
+           (slice (subseq history 0 num-to-draw)))
+      (loop for i from 0 below num-to-draw
+            for msg in (reverse slice)
+            do (when msg
+                 (add-string win (format nil "│ ~a" msg) :y (1+ i) :x 2))))
+    (refresh win)))
+#+end_src
+
+** Input Handling
+#+begin_src lisp
+(defun handle-backspace ()
+  (pop *input-list*))
+
+(defun handle-return (stream)
+  (let ((cmd (coerce (reverse *input-list*) 'string)))
+    (setf *input-list* nil)
+    (log-debug "SUBMITTING: '~a'" cmd)
+    (when (> (length cmd) 0)
+      (push (format nil "⬆ ~a" cmd) *chat-history*)
+      (handler-case
+          (progn
+            (if (and stream (open-stream-p stream))
+                (let* ((msg (list :TYPE :EVENT 
+                                 :META (list :SOURCE :tui)
+                                 :PAYLOAD (list :SENSOR :user-input :TEXT cmd)))
+                       (payload (format nil "~s" msg))
+                       (len (length payload)))
+                  (format stream "~6,'0x~a" len payload)
+                  (finish-output stream)
+                  (log-debug "SENT WIRE: ~a" payload))
+                (push "ERROR: Not connected." *chat-history*)))
+        (error (c)
+          (log-debug "SEND ERROR: ~a" c)
+          (push (format nil "ERROR: ~a" c) *chat-history*)
+          (setf *is-running* nil))))
+    (when (string= cmd "/exit") (setf *is-running* nil))
+    (when (string= cmd "/clear") (setf *chat-history* nil))))
+#+end_src
+
+** Background Reader
+#+begin_src lisp
+(defun start-background-reader (stream)
+  (bt:make-thread
+   (lambda ()
+     (loop while *is-running* do
+       (handler-case
+           (let* ((len-buf (make-string 6))
+                  (count (read-sequence len-buf stream)))
+             (if (= count 6)
+                 (let* ((msg-len (parse-integer len-buf :radix 16))
+                        (msg-buf (make-string msg-len)))
+                   (read-sequence msg-buf stream)
+                   (log-debug "DAEMON MSG: ~a" msg-buf)
+                   (let ((msg (read-from-string msg-buf)))
+                     (let ((payload (getf msg :payload)))
+                       (cond
+                         ((eq (getf payload :action) :handshake)
+                          (enqueue-msg "* Connected *"))
+                         (t
+                          (let ((text (or (getf payload :text) (format nil "~a" payload))))
+                            (enqueue-msg (format nil "⬇ ~a" text))))))))
+                 (sleep 0.05)))
+         (error (c)
+           (when *is-running*
+             (log-debug "READER ERROR: ~a" c)
+             (enqueue-msg "ERROR: Connection lost.")
+             (setf *is-running* nil))))))
+   :name "opencortex-tui-reader"))
+#+end_src
+
+** Main Entry Point
+#+begin_src lisp
+(defun main ()
+  (log-debug "=== START ===")
+  (handler-case
+      (setf *socket* (usocket:socket-connect *daemon-host* *daemon-port*))
+    (error (e) (format t "Offline: ~a~%" e) (return-from main)))
+  (setf *stream* (usocket:socket-stream *socket*))
+  
+  (unwind-protect
+      (with-screen (scr :input-echoing nil :input-blocking nil :enable-colors t)
+        (let* ((h (or (height scr) 24))
+               (w (or (width scr) 80))
+               (chat-h (- h 4))
+               (chat-win (make-instance 'window :height chat-h :width (- w 2) :y 1 :x 1))
+               (input-win (make-instance 'window :height 1 :width (- w 2) :y (- h 2) :x 1)))
+          (setf (input-blocking input-win) nil)
+          (start-background-reader *stream*)
+          (loop :while *is-running* :do
+            (let ((msgs (dequeue-msgs)))
+              (when msgs 
+                (dolist (m msgs) (push m *chat-history*))
+                (render-chat chat-win chat-h)))
+            (let ((ch (get-char input-win)))
+              (when (and ch (not (equal ch -1)))
+                (log-debug "KEY: ~s" ch)
+                (cond
+                  ((or (eql ch 10) (eql ch 13) (eq ch :enter) (eql ch #\Newline) (eql ch #\Return))
+                   (handle-return *stream*)
+                   (render-chat chat-win chat-h))
+                  ((or (eql ch 127) (eql ch 8) (eq ch :backspace) (eql ch #\Backspace))
+                   (handle-backspace))
+                  ((characterp ch)
+                   (push ch *input-list*))
+                  ((integerp ch)
+                   (let ((converted (code-char ch)))
+                     (when (graphic-char-p converted)
+                       (push converted *input-list*))))))
+              (clear input-win)
+              (add-string input-win (format nil "▶ ~a" (coerce (reverse *input-list*) 'string)) :y 0 :x 1)
+              (refresh input-win))
+            (sleep 0.01))))
+    (setf *is-running* nil)
+    (when *socket* (ignore-errors (usocket:socket-close *socket*)))))
+#+end_src
+
+** REPL test script (tmux)
+Use this script to test the TUI non-interactively in a tmux session. It launches the TUI in a headless tmux window, sends text, and captures the output.
+
+#+begin_src bash :tangle no
+#!/bin/bash
+SESSION="oct-tui-test"
+tmux new-session -d -s "$SESSION" \
+    -e OC_CONFIG_DIR="$HOME/.config/opencortex" \
+    -e OC_DATA_DIR="$HOME/.local/share/opencortex" \
+    -e TERM="screen-256color" \
+    "sbcl --non-interactive \
+        --eval '(load (merge-pathnames \"quicklisp/setup.lisp\" (user-homedir-pathname)))' \
+        --eval '(push (truename \"$HOME/.local/share/opencortex/\") asdf:*central-registry*)' \
+        --eval '(ql:quickload :opencortex/tui)' \
+        --eval '(opencortex.tui:main)'"
+sleep 5
+tmux capture-pane -t "$SESSION" -p -S -20
+tmux send-keys -t "$SESSION" 'hello' Enter
+sleep 8
+tmux capture-pane -t "$SESSION" -p -S -20
+tmux send-keys -t "$SESSION" '/exit' Enter
+sleep 1
+tmux kill-session -t "$SESSION" 2>/dev/null || true
+#+end_src

infrastructure/docker/Dockerfile

@@ -0,0 +1,23 @@
+FROM debian:trixie-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y \
+    sbcl emacs-nox curl git socat netcat-openbsd rlwrap \
+    libssl-dev libncurses-dev libffi-dev zlib1g-dev libsqlite3-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN curl -O https://beta.quicklisp.org/quicklisp.lisp \
+    && sbcl --non-interactive --load quicklisp.lisp \
+        --eval "(quicklisp-quickstart:install)" \
+        --eval "(ql-util:without-prompting (ql:add-to-init-file))" \
+    && rm quicklisp.lisp
+
+WORKDIR /app
+COPY . .
+
+RUN mkdir -p /root/memex && ./opencortex.sh configure --non-interactive
+
+EXPOSE 9105
+
+CMD ["./opencortex.sh", "daemon"]

infrastructure/docker/docker-compose.yml

@@ -0,0 +1,16 @@
+services:
+  opencortex:
+    build:
+      context: ../../
+      dockerfile: infrastructure/docker/Dockerfile
+    container_name: opencortex
+    env_file: ../../.env
+    volumes:
+      - ../../../..:/memex
+      - signal-state:/root/.local/share/signal-cli
+    ports:
+      - "${ORG_AGENT_DAEMON_PORT:-9105}:9105"
+    restart: unless-stopped
+
+volumes:
+  signal-state:

infrastructure/opencortex.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=OpenCortex Daemon
+Documentation=https://github.com/amrgharbeia/opencortex
+After=network.target
+
+[Service]
+Type=simple
+User=%u
+ExecStart=%h/projects/opencortex/opencortex.sh daemon
+Restart=on-failure
+RestartSec=10
+WorkingDirectory=%h/projects/opencortex
+
+[Install]
+WantedBy=default.target

literate/act.org

@@ -1,135 +0,0 @@
-#+TITLE: Stage 3: Act (act.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:act:
-#+STARTUP: content
-
-* Stage 3: Act (act.lisp)
-** Architectural Intent: Actuation
-The Act stage performs the final side-effects of the reasoning engine. It routes approved actions to their registered physical actuators (CLI, Shell, Emacs, etc.) and handles the execution of internal system tools.
-
-** Actuator Configuration
-The core harness can be configured via environment variables to operate silently or target different default outputs.
-
-#+begin_src lisp :tangle ../src/act.lisp
-(in-package :opencortex)
-
-(defvar *default-actuator* :cli)
-(defvar *silent-actuators* '(:cli :system-message :emacs))
-
-(defun initialize-actuators ()
-  "Loads actuator routing defaults from environment variables and registers core harness actuators."
-  (let ((def (uiop:getenv "DEFAULT_ACTUATOR"))
-        (silent (uiop:getenv "SILENT_ACTUATORS")))
-    (when def
-      (setf *default-actuator* (intern (string-upcase def) "KEYWORD")))
-    (when silent
-      (setf *silent-actuators*
-            (mapcar (lambda (s) (intern (string-upcase (string-trim '(#\Space) s)) "KEYWORD"))
-                    (str:split "," silent)))))
-  
-  ;; Register core harness actuators
-  (register-actuator :system #'execute-system-action)
-  (register-actuator :tool #'execute-tool-action))
-#+end_src
-
-** Dispatching Actions
-The `dispatch-action` function is the primary router. It identifies the target actuator and executes the requested side-effects.
-
-#+begin_src lisp :tangle ../src/act.lisp
-(defun dispatch-action (action context)
-  "Routes an approved action to its registered physical actuator."
-  (when (and action (listp action))
-    (let* ((target (or (ignore-errors (getf action :target)) *default-actuator*)) 
-           (actuator-fn (gethash target *actuator-registry*)))
-      (if actuator-fn 
-          (funcall actuator-fn action context) 
-          (harness-log "ACT ERROR: No actuator for ~a" target)))))
-#+end_src
-
-** Internal System Actions
-The `:system` actuator handles internal harness commands like code evaluation and dynamic skill loading.
-
-#+begin_src lisp :tangle ../src/act.lisp
-(defun execute-system-action (action context)
-  "Processes internal harness commands. (ACTUATOR)"
-  (declare (ignore context))
-  (let* ((payload (ignore-errors (getf action :payload))) 
-         (cmd (ignore-errors (getf payload :action))))
-    (case cmd
-      (:eval (let ((code (getf payload :code)))
-               (eval (read-from-string code))))
-      (:create-skill (let* ((filename (getf payload :filename)) (content (getf payload :content))
-                            (skills-dir (merge-pathnames "skills/" (asdf:system-source-directory :opencortex))) 
-                            (full-path (merge-pathnames filename skills-dir)))
-                       (with-open-file (out full-path :direction :output :if-exists :supersede) (write-string content out))
-                       (load-skill-from-org full-path)))
-      (:message (harness-log "ACT [System]: ~a" (getf payload :text)))
-      (t (harness-log "ACT ERROR [System]: Unknown command ~s" cmd)))))
-#+end_src
-
-** Cognitive Tool Actuation
-The `:tool` actuator handles the execution of registered cognitive tools.
-
-#+begin_src lisp :tangle ../src/act.lisp
-(defun execute-tool-action (action context)
-  "Executes a registered cognitive tool. (ACTUATOR)"
-  (let* ((payload (getf action :payload))
-         (tool-name (getf payload :tool))
-         (tool-args (getf payload :args))
-         (depth (getf context :depth 0))
-         (tool (gethash (string-downcase (string tool-name)) *cognitive-tools*)))
-    (if tool
-        (handler-case
-            (let* ((clean-args (if (and (listp tool-args) (listp (car tool-args))) (car tool-args) tool-args))
-                   (result (funcall (cognitive-tool-body tool) clean-args)))
-              (list :type :EVENT :depth (1+ depth) :reply-stream (getf context :reply-stream)
-                    :payload (list :sensor :tool-output :result result :tool tool-name)))
-          (error (c)
-            (list :type :EVENT :depth (1+ depth) :reply-stream (getf context :reply-stream)
-                  :payload (list :sensor :tool-error :tool tool-name :message (format nil "~a" c)))))
-        (list :type :EVENT :depth (1+ depth) :reply-stream (getf context :reply-stream)
-              :payload (list :sensor :tool-error :message "Tool not found")))))
-#+end_src
-
-** The Act Gate
-The final stage of the metabolic loop. It performs a "last-mile" safety check before dispatching the action to the registered actuator.
-
-#+begin_src lisp :tangle ../src/act.lisp
-(defun act-gate (signal)
-  "Final Stage: Actuation and feedback generation."
-  (let* ((approved (getf signal :approved-action))
-         (type (getf signal :type))
-         (feedback nil))
-    
-    ;; 1. Last-Mile Safety Check (The Bouncer & Deterministic Gates)
-    (when approved
-      (let ((verified (deterministic-verify approved signal)))
-        (if (and (listp verified) (member (getf verified :type) '(:LOG :EVENT :log :event)))
-            (progn
-              (harness-log "ACT BLOCKED: Action failed last-mile deterministic check.")
-              (setf (getf signal :approved-action) nil)
-              (setf approved nil)
-              (setf feedback verified))
-            (progn
-              (setf (getf signal :approved-action) verified)
-              (setf approved verified)))))
-
-    ;; 2. Actuation Logic
-    (case type
-      (:REQUEST (dispatch-action signal signal))
-      (:EVENT 
-       (when approved
-         (let* ((target (getf approved :target))
-                (result (dispatch-action approved signal)))
-           ;; If the actuator returns a signal (like :tool-output), it becomes the feedback.
-           ;; Otherwise, generate tool-output feedback for non-silent actuators.
-           (cond ((and (listp result) (member (getf result :type) '(:EVENT :LOG)))
-                  (setf feedback result))
-                 ((and result (not (member target *silent-actuators*)))
-                  (setf feedback (list :type :EVENT :depth (1+ (getf signal :depth 0)) 
-                                       :reply-stream (getf signal :reply-stream)
-                                       :payload (list :sensor :tool-output :result result :tool approved)))))))))
-    
-    (setf (getf signal :status) :acted)
-    feedback))
-#+end_src

literate/communication.org

@@ -1,133 +0,0 @@
-#+TITLE: Communication Protocol (communication.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:protocol:
-#+STARTUP: content
-
-* Communication Protocol (communication.lisp)
-** Architectural Intent: Secure Inter-Process Communication & Deterministic Framing
-
-The **communication protocol** defines the exact physical and semantic boundaries for how the isolated Lisp environment talks to the outside world.
-
-The system operates as a perfectly deterministic, highly secure computational engine. When communicating with external processes or actuators—such as an Emacs client, a web dashboard, or a remote Shell script—it cannot rely on unpredictable, "loose" data streams. 
-
-Streaming raw Lisp or JSON over a TCP socket is inherently fragile. If a multi-megabyte Org Abstract Syntax Tree (AST) is fragmented by the operating system's network stack during transmission, a standard stream parser might attempt to evaluate an incomplete string, leading to immediate crashes or desynchronization.
-
-To solve this, we implement the **communication protocol**, which enforces absolute deterministic boundaries around every message.
-
-*** 1. Physical Boundary: Hex-Length Prefixing
-Every message crossing the wire is prefixed with a strict 6-character hexadecimal length string (zero-padded). This creates an unbreakable physical boundary. The system reads exactly the number of bytes specified by the hex length. It will never under-read (crashing on a partial form) and never over-read (consuming bytes meant for the next message). 
-
-*** 2. Actuator-Agnosticism ("Dumb Terminal" Architecture)
-The protocol keeps the Lisp environment completely agnostic of its clients. The system does not care if the client is written in Emacs Lisp, Python, or Rust. Any environment capable of calculating a byte length and opening a TCP socket can interface with the Lisp Machine.
-
-*** 3. Preventing Reader Macro Injection
-Common Lisp's ~read-from-string~ is extremely powerful but dangerous; it allows "reader macros" (like ~#.~) which execute code during the parsing phase. The communication protocol mandates that ~*read-eval*~ is explicitly bound to ~nil~ before any network data is parsed, physically preventing arbitrary code execution.
-
-** Message Framing Logic
-#+begin_src mermaid
-flowchart LR
-    subgraph Client
-        A[Lisp Property List] --> B[Calculate Length]
-        B --> C[Hex Prefix: 6 Chars]
-        C --> D[Concatenate: Length + List]
-    end
-    D -- TCP Socket --> System
-    subgraph System
-        System --> E[Read 6 Hex Chars]
-        E --> F[Read Exact Byte Count]
-        F --> G[Parse S-Expression]
-    end
-#+end_src
-
-** Package Context
-We ensure all protocol logic resides within the isolated system namespace.
-
-#+begin_src lisp :tangle ../src/communication.lisp
-(in-package :opencortex)
-#+end_src
-
-** Actuator Registry
-The system maintains a decoupled registry of target actuators. This allows the system to route messages to Emacs, the Shell, or Web Gateways without hardcoding the routing logic into the protocol itself.
-
-#+begin_src lisp :tangle ../src/communication.lisp
-(defvar *actuator-registry* (make-hash-table :test 'equal)
-  "Global registry mapping target keywords to their physical actuator functions.")
-
-(defun register-actuator (name fn) 
-  "Registers an actuator function. Actuators receive: (ACTION CONTEXT)."
-  (setf (gethash name *actuator-registry*) fn))
-#+end_src
-
-** Message Framing (frame-message)
-The ~frame-message~ function prepares an outgoing Lisp string for transmission. It calculates the byte length, converts it into a 6-character padded hex string, and prefixes it. If ~COMMUNICATION_PROTOCOL_ENFORCE_HMAC~ is enabled in the environment, it also prepends a cryptographic signature to ensure the message hasn't been tampered with.
-
-#+begin_src lisp :tangle ../src/communication.lisp
-(defun frame-message (msg-string)
-  "Prefixes MSG-STRING with a 6-character hex length.
-   If security is enabled, prefixes a 64-char HMAC-SHA256 signature."
-  (let ((len (length msg-string))
-        (enforce-hmac (uiop:getenv "COMMUNICATION_PROTOCOL_ENFORCE_HMAC")))
-    (if (and enforce-hmac (string-equal enforce-hmac "true"))
-        (let ((secret (uiop:getenv "COMMUNICATION_PROTOCOL_HMAC_SECRET")))
-          (unless secret (error "COMMUNICATION_PROTOCOL_HMAC_SECRET is required when security is enabled."))
-          (let* ((key (ironclad:ascii-string-to-byte-array secret))
-                 (hmac (ironclad:make-mac :hmac key :sha256))
-                 (payload-bytes (ironclad:ascii-string-to-byte-array msg-string)))
-            (ironclad:update-mac hmac payload-bytes)
-            (let ((signature (ironclad:byte-array-to-hex-string (ironclad:produce-mac hmac))))
-              (format nil "~(~6,'0x~)~a~a" len signature msg-string))))
-        (format nil "~(~6,'0x~)~a" len msg-string))))
-#+end_src
-
-** Message Parsing (parse-message)
-Parsing is the high-security inverse of framing. This function acts as the final perimeter defense. It validates the length, verifies the HMAC integrity, and—most importantly—jails the Lisp reader by disabling ~*read-eval*~. 
-
-#+begin_src lisp :tangle ../src/communication.lisp
-(defun parse-message (framed-string)
-  "Extracts and parses the S-expression from a framed string securely."
-  (when (< (length framed-string) 6)
-    (error "Framed string too short"))
-  (let* ((enforce-hmac (uiop:getenv "COMMUNICATION_PROTOCOL_ENFORCE_HMAC"))
-         (use-hmac (and enforce-hmac (string-equal enforce-hmac "true")))
-         (prefix-len (if use-hmac 70 6)))
-    (when (< (length framed-string) prefix-len)
-      (error "Framed string too short for communication protocol prefix"))
-    
-    (let* ((len-str (subseq framed-string 0 6))
-           (signature (when use-hmac (subseq framed-string 6 70)))
-           (actual-msg (subseq framed-string prefix-len))
-           (expected-len (ignore-errors (parse-integer len-str :radix 16))))
-      (unless expected-len
-        (error "Invalid hex length prefix: ~a" len-str))
-      (unless (= expected-len (length actual-msg))
-        (error "Message length mismatch. Expected ~a, got ~a" expected-len (length actual-msg)))
-      
-      (when use-hmac
-        (let ((secret (uiop:getenv "COMMUNICATION_PROTOCOL_HMAC_SECRET")))
-          (unless secret (error "COMMUNICATION_PROTOCOL_HMAC_SECRET is required when security is enabled."))
-          (let* ((key (ironclad:ascii-string-to-byte-array secret))
-                 (hmac (ironclad:make-mac :hmac key :sha256))
-                 (payload-bytes (ironclad:ascii-string-to-byte-array actual-msg)))
-            (ironclad:update-mac hmac payload-bytes)
-            (let ((expected-signature (ironclad:byte-array-to-hex-string (ironclad:produce-mac hmac))))
-              (unless (string-equal signature expected-signature)
-                (error "communication protocol Integrity Failure: HMAC mismatch"))))))
-      
-      ;; SECURITY: Disable the reader's ability to execute code during parsing
-      (let ((*read-eval* nil))
-        (let ((msg (read-from-string actual-msg)))
-          (validate-communication-protocol-schema msg)
-          msg)))))
-#+end_src
-
-** Handshaking (make-hello-message)
-Every session begins with a standard ~HELLO~ handshake, allowing the system to announce its capabilities and protocol version to the connecting client.
-
-#+begin_src lisp :tangle ../src/communication.lisp
-(defun make-hello-message (version)
-  "Constructs the standard HELLO handshake message."
-  (list :type :EVENT 
-        :payload (list :action :handshake 
-                       :version version 
-                       :capabilities '(:auth :swank :org-ast))))
-#+end_src

literate/context.org

@@ -1,259 +0,0 @@
-#+TITLE: Peripheral Vision (context.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:context:
-#+STARTUP: content
-
-* Peripheral Vision (context.lisp)
-** Architectural Intent: Context Optimization & The Foveal-Peripheral Hybrid
-
-A common failure mode for Large Language Models (LLMs) is the "Lost in the Middle" phenomenon, where the model's reasoning accuracy degrades as its context window becomes saturated with irrelevant data. Naive approaches to context management—such as simple character-count truncation or sliding windows—often sever the structural relationships that define an Org-mode Memex.
-
-The ~opencortex~ harness implements a deterministic, tree-aware solution: the **Foveal-Peripheral Hybrid Model**.
-
-*** 1. The Foveal Focus (High Resolution)
-When the harness prepares a prompt for the Probabilistic Engine, it identifies a "Foveal Focus"—typically the specific Org headline or task the user is currently interacting with. This node, along with its immediate children and semantically relevant neighbors, is rendered at "High Resolution," meaning its full body text, properties, and metadata are included in the prompt.
-
-*** 2. The Peripheral Vision (Low Resolution)
-To maintain global awareness without bloating the context window, the rest of the Memex is rendered at "Low Resolution." The harness recursively walks the Memory and generates a skeletal outline consisting only of titles and IDs. This gives the LLM a "mental map" of the entire system, allowing it to reference other projects or skills without needing to see their full content until they are explicitly brought into focus.
-
-*** 3. Deterministic Tree-Walking
-By leveraging Common Lisp's strengths in recursive tree manipulation, the harness can surgically prune the AST before it ever reaches the LLM. This ensures that the structural hierarchy of the Memex is preserved perfectly, even when the content is compressed.
-
-** The Context Pipeline
-#+begin_src mermaid
-flowchart TD
-    Store[(Memory)] --> Filter[Context Query Filter]
-    Filter --> Identification{Identify Foveal ID}
-    Identification --> Foveal[Render Focus: Full Content]
-    Identification --> Peripheral[Render Outline: Titles Only]
-    Foveal --> Assembly[Assemble Global Awareness String]
-    Peripheral --> Assembly
-    Assembly --> LLM[Probabilistic Engine Proposal]
-#+end_src
-
-* Context Assembly (context.lisp)
-The ~context.lisp~ module provides the deterministic functional layer for querying the Memory and transforming its internal pointers into the precise context strings required for neural reasoning.
-
-** Package Context
-We begin by ensuring we are executing within the correct isolated package namespace.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(in-package :opencortex)
-#+end_src
-
-** Querying the Store (context-query-store)
-A generalized filter for the Memory. This function allows skills to perform high-level semantic sweeps of the Memex based on tags, TODO states, or Org element types. It returns a list of ~org-object~ structures.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-query-store (&key tag todo-state type)
-  "Filters the Memory based on tags, todo states, or types."
-  (let ((results nil))
-    (maphash (lambda (id obj)
-               (declare (ignore id))
-               (let* ((attrs (org-object-attributes obj)) (state (getf attrs :TODO-STATE)) (match t))
-                 (when (and type (not (eq (org-object-type obj) type))) (setf match nil))
-                 (when tag (unless (search tag (format nil "~a" (getf attrs :TAGS)) :test #'string-equal) (setf match nil)))
-                 (when (and todo-state (not (equal state todo-state))) (setf match nil))
-                 (when match (push obj results))))
-             *memory*)
-    results))
-#+end_src
-
-** Active Projects (context-get-active-projects)
-Identifies headlines tagged with ~project~ that have not yet reached a terminal ~DONE~ state. This provides the primary high-level structure for the agent's global awareness.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-get-active-projects ()
-  "Returns headlines tagged as 'project' that are not yet marked DONE."
-  (remove-if (lambda (obj) (equal (getf (org-object-attributes obj) :TODO-STATE) "DONE"))
-             (context-query-store :tag "project" :type :HEADLINE)))
-#+end_src
-
-** Completed Tasks (context-get-recent-completed-tasks)
-Retrieves a list of tasks that have reached the terminal ~DONE~ state. This is useful for providing the agent with historical context or for generating summaries of recent work.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-get-recent-completed-tasks () 
-  "Retrieves recently finished tasks from the store."
-  (context-query-store :todo-state "DONE" :type :HEADLINE))
-#+end_src
-
-** Capability Discovery (context-list-all-skills)
-Provides a sorted list of all currently loaded skills. In a "Self-Writing" environment, the agent must be able to discover and understand its own capabilities. This function provides the metadata necessary for the agent to decide which skill to trigger or how to resolve dependencies.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-list-all-skills ()
-  "Provides a sorted overview of currently loaded system capabilities."
-  (let ((results nil))
-    (maphash (lambda (name skill)
-               (declare (ignore name))
-               (push (list :name (skill-name skill) :priority (skill-priority skill) :dependencies (skill-dependencies skill)) results))
-             *skills-registry*)
-    (sort results #'> :key (lambda (x) (getf x :priority)))))
-#+end_src
-
-** Skill Inspection (context-get-skill-source)
-Reads the raw literate Org source of a specific skill. This is a foundational capability for an agent expected to eventually "self-write" or perform its own maintenance. By reading the literate source, the agent can understand the *intent* behind a skill's logic before proposing a modification. We use the `SKILLS_DIR` environment variable to locate the source files.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-get-skill-source (skill-name)
-  "Reads the raw literate source of a specific skill for inspection."
-  (let* ((filename (format nil "~a.org" skill-name))
-         (skills-dir-str (or (uiop:getenv "SKILLS_DIR") (namestring (merge-pathnames "notes/" (user-homedir-pathname)))))
-         (skills-dir (uiop:ensure-directory-pathname (context-resolve-path skills-dir-str)))
-         (full-path (merge-pathnames filename skills-dir)))
-    (if (uiop:file-exists-p full-path) (uiop:read-file-string full-path) nil)))
-#+end_src
-
-** Harness Logs (context-get-system-logs)
-Retrieves the most recent entries from the harness's internal circular log buffer. This allows the Probabilistic Engine to see recent errors or successful dispatches, enabling it to course-correct or explain failures to the user. The log limit is externalized to `CONTEXT_LOG_LIMIT`.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-get-system-logs (&optional limit)
-  "Retrieves the most recent lines from the harness's internal log."
-  (let ((log-limit (or limit (ignore-errors (parse-integer (uiop:getenv "CONTEXT_LOG_LIMIT"))) 20)))
-    (bt:with-lock-held (*logs-lock*)
-      (let ((count (min log-limit (length *system-logs*)))) 
-        (subseq *system-logs* 0 count)))))
-#+end_src
-
-** AST to Org Rendering (context-render-to-org)
-This is the core engine of the Foveal-Peripheral model. It recursively transforms the internal ~org-object~ graph back into an Org-mode string. 
-
-It implements the following deterministic logic:
-1.  **Depth 1 & 2:** Always rendered (High-level mental map).
-2.  **Foveal Node:** Rendered with full body content.
-3.  **Semantic Neighbors:** Rendered with full content if their similarity score exceeds the threshold.
-4.  **Peripheral Nodes:** Rendered as skeletal headlines (titles and IDs only).
-
-The semantic threshold is externalized to `CONTEXT_SEMANTIC_THRESHOLD`.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-render-to-org (obj &key (depth 1) (foveal-id nil) semantic-threshold (foveal-vector nil))
-  "Recursively renders an org-object and its children to an Org string using a Foveal-Peripheral Hybrid model."
-  (let* ((id (org-object-id obj))
-         (is-foveal (equal id foveal-id))
-         (title (or (getf (org-object-attributes obj) :TITLE) "Untitled"))
-         (content (org-object-content obj))
-         (children (org-object-children obj))
-         (stars (make-string depth :initial-element #\*))
-         (obj-vector (org-object-vector obj))
-         (threshold (or semantic-threshold (ignore-errors (read-from-string (uiop:getenv "CONTEXT_SEMANTIC_THRESHOLD"))) 0.75))
-         (similarity (if (and foveal-vector obj-vector (not is-foveal))
-                         (cosine-similarity foveal-vector obj-vector)
-                         0.0))
-         (is-semantically-relevant (>= similarity threshold))
-         ;; We always render depth 1 and 2 (Projects and main tasks).
-         ;; We always render the foveal node and its immediate children.
-         ;; We render deeper nodes ONLY if they are semantically relevant.
-         (should-render (or (<= depth 2) is-foveal is-semantically-relevant))
-         (output ""))
-    
-    (when should-render
-      (setf output (format nil "~a ~a~%:PROPERTIES:~%:ID: ~a~%" stars title id))
-      (when is-semantically-relevant
-        (setf output (concatenate 'string output (format nil ":SEMANTIC_SCORE: ~,2f~%" similarity))))
-      (setf output (concatenate 'string output (format nil ":END:~%")))
-      
-      ;; Only include full body content if this is the Foveal focus or highly relevant
-      (when (and content (or is-foveal is-semantically-relevant))
-        (setf output (concatenate 'string output content (string #\Newline))))
-      
-      ;; Recursively render children
-      (dolist (child-id children)
-        (let ((child-obj (lookup-object child-id)))
-          (when child-obj
-            ;; If the current node is Foveal, its children should be rendered (depth effectively resets)
-            (let ((next-foveal (if is-foveal child-id foveal-id)))
-              (setf output (concatenate 'string output 
-                                        (context-render-to-org child-obj 
-                                                               :depth (1+ depth) 
-                                                               :foveal-id next-foveal
-                                                               :semantic-threshold threshold
-                                                               :foveal-vector foveal-vector))))))))
-    output))
-#+end_src
-
-** Path Resolution (context-resolve-path)
-A utility function that expands environment variables (like ~$HOME~ or ~$MEMEX_ROOT~) within path strings. This ensures that the agent can interact with files across different machine configurations without hardcoding absolute paths. This version is more robust, supporting multiple environment variables throughout the string.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-resolve-path (path-string)
-  "Expands all environment variables ($VAR) within a path string."
-  (if (and (stringp path-string) (search "$" path-string))
-      (let ((result path-string))
-        (ppcre:do-register-groups (var-name) ("\\$([A-Za-z0-9_]+)" path-string)
-          (let ((var-val (uiop:getenv var-name)))
-            (when var-val
-              (setf result (ppcre:regex-replace (format nil "\\$~a" var-name) result var-val)))))
-        result)
-      path-string))
-#+end_src
-
-** Global Awareness (context-assemble-global-awareness)
-The primary entry point for context generation. This function identifies active projects and the current user focus (captured during the Perceive stage), then invokes the recursive renderer to assemble the pruned Org-mode skeletal outline sent to the LLM.
-
-#+begin_src lisp :tangle ../src/context.lisp
-(defun context-assemble-global-awareness (&optional signal)
-  "Produces a high-level skeletal outline of the current Memory for the LLM."
-  (let* ((foveal-id (or (getf signal :foveal-focus) 
-                        (ignore-errors (getf (getf signal :payload) :target-id))))
-         (projects (context-get-active-projects))
-         (output "GLOBAL MEMEX AWARENESS (Peripheral Vision):
-"))
-    (if projects
-        (dolist (project projects)
-          (setf output (concatenate 'string output
-                                    (context-render-to-org project :foveal-id foveal-id))))
-        (setf output (concatenate 'string output "No active projects found.~%")))
-    output))
-#+end_src
-
-* Phase E: Chaos (Verification)
-Following the Engineering Standards, the peripheral vision extraction and rendering logic must be empirically verified. 
-
-** Test Suite Context
-#+begin_src lisp :tangle ../tests/peripheral-vision-tests.lisp
-(defpackage :opencortex-peripheral-vision-tests
-  (:use :cl :fiveam :opencortex)
-  (:export #:vision-suite))
-(in-package :opencortex-peripheral-vision-tests)
-
-(def-suite vision-suite
-  :description "Verification of Foveal-Peripheral context model.")
-(in-suite vision-suite)
-#+end_src
-
-** Foveal Rendering Test
-Verify that the foveal target is rendered with content, while siblings are skeletal.
-
-#+begin_src lisp :tangle ../tests/peripheral-vision-tests.lisp
-(test test-foveal-rendering
-  "Verify that the foveal target is rendered with content, while siblings are skeletal."
-  (clrhash opencortex::*memory*)
-  (let* ((ast '(:type :HEADLINE :properties (:ID "proj-root" :TITLE "Project" :TAGS "project")
-                :contents ((:type :HEADLINE :properties (:ID "node-foveal" :TITLE "Foveal Node")
-                            :raw-content "FOVEAL CONTENT" :contents nil)
-                           (:type :HEADLINE :properties (:ID "node-peripheral" :TITLE "Peripheral Node")
-                            :raw-content "PERIPHERAL CONTENT" :contents nil)))))
-    (ingest-ast ast)
-    ;; Test both foveal focus in signal top-level and in payload (legacy)
-    (let ((output (context-assemble-global-awareness (list :foveal-focus "node-foveal"))))
-      (is (search "FOVEAL CONTENT" output))
-      (is (search "* Peripheral Node" output))
-      (is (not (search "PERIPHERAL CONTENT" output))))))
-#+end_src
-
-** Awareness Budget Test
-Verify that context-assemble-global-awareness handles multiple projects correctly.
-
-#+begin_src lisp :tangle ../tests/peripheral-vision-tests.lisp
-(test test-awareness-budget
-  "Verify that context-assemble-global-awareness handles multiple projects."
-  (clrhash opencortex::*memory*)
-  (ingest-ast '(:type :HEADLINE :properties (:ID "p1" :TITLE "Project 1" :TAGS "project") :contents nil))
-  (ingest-ast '(:type :HEADLINE :properties (:ID "p2" :TITLE "Project 2" :TAGS "project") :contents nil))
-  (let ((output (context-assemble-global-awareness)))
-    (is (search "Project 1" output))
-    (is (search "Project 2" output))))
-#+end_src

literate/loop.org

@@ -1,99 +0,0 @@
-#+TITLE: The Metabolic Loop (loop.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:loop:
-#+STARTUP: content
-
-* The Metabolic Loop (loop.lisp)
-** Architectural Intent: The Heartbeat
-The Metabolic Loop is the high-level coordinator of the OpenCortex. It orchestrates the flow of energy (information) through the system by calling the three metabolic stages in sequence:
-1. **Perceive:** Sensory intake.
-2. **Reason:** Cognitive processing.
-3. **Act:** Physical side-effects.
-
-** Package and Variables
-The loop requires thread-safe interrupt handling to ensure that the agent can be stopped gracefully without leaving the Lisp image in an inconsistent state.
-
-#+begin_src lisp :tangle ../src/loop.lisp
-(in-package :opencortex)
-
-(defvar *interrupt-flag* nil)
-(defvar *interrupt-lock* (bt:make-lock "harness-interrupt-lock"))
-(defvar *heartbeat-thread* nil)
-#+end_src
-
-** The Metabolic Pipeline
-The `process-signal` function is the core metabolic processor. It iterates through the Perceive-Reason-Act gates until the signal is fully processed or an error state is reached. We have refined the error handling to ensure that memory rollbacks only occur on critical system failures, preventing transient tool errors from wiping short-term cognitive state.
-
-#+begin_src lisp :tangle ../src/loop.lisp
-(defun process-signal (signal)
-  "The entry point to the Metabolic Pipeline: Perceive -> Reason -> Act."
-  (let ((current-signal signal))
-    (loop while current-signal do
-      (let ((depth (getf current-signal :depth 0)))
-        (when (> depth 10) (harness-log "METABOLISM ERROR: Max depth reached.") (return nil))
-        (when (bt:with-lock-held (*interrupt-lock*) *interrupt-flag*)
-          (harness-log "METABOLISM: Interrupted.")
-          (bt:with-lock-held (*interrupt-lock*) (setf *interrupt-flag* nil))
-          (return nil))
-        (handler-case
-            (progn
-              (setf current-signal (perceive-gate current-signal))
-              (setf current-signal (reason-gate current-signal))
-              (setf current-signal (act-gate current-signal)))
-          (error (c)
-            (let ((sensor (ignore-errors (getf (getf current-signal :payload) :sensor))))
-              (harness-log "METABOLISM CRASH [~a]: ~a" (or sensor :unknown) c)
-              ;; Only rollback on critical errors, not standard tool or loop errors
-              (unless (member sensor '(:loop-error :tool-error :syntax-error))
-                (harness-log "CRITICAL ERROR: Initiating Micro-Rollback.")
-                (rollback-memory 0))
-              (if (or (> depth 2) (member sensor '(:loop-error :tool-error)))
-                  (setf current-signal nil)
-                  (setf current-signal (list :type :EVENT :depth (1+ depth) :reply-stream (getf current-signal :reply-stream)
-                                             :payload (list :sensor :loop-error :message (format nil "~a" c) :depth depth)))))))))))
-#+end_src
-
-** Heartbeat Mechanism
-The heartbeat ensures the agent remains "alive" even in the absence of external stimuli, allowing for latent reflection and periodic maintenance. The interval is externalized to the `HEARTBEAT_INTERVAL` environment variable.
-
-#+begin_src lisp :tangle ../src/loop.lisp
-(defun start-heartbeat ()
-  "Starts the background heartbeat thread. Interval is loaded from HEARTBEAT_INTERVAL."
-  (let ((interval (or (ignore-errors (parse-integer (uiop:getenv "HEARTBEAT_INTERVAL"))) 60)))
-    (setf *heartbeat-thread* 
-          (bt:make-thread 
-           (lambda () 
-             (loop 
-               (sleep interval) 
-               ;; inject-stimulus is synchronous for heartbeats, preventing accumulation.
-               (inject-stimulus (list :type :EVENT :payload (list :sensor :heartbeat :unix-time (get-universal-time)))))) 
-           :name "opencortex-heartbeat"))))
-#+end_src
-
-** Main Entry Point
-The `main` function initializes the environment, loads skills, and starts the heartbeat. It now includes a graceful shutdown handler for `SIGINT` (Ctrl+C) and uses `DAEMON_SLEEP_INTERVAL` to control its idle rhythm.
-
-#+begin_src lisp :tangle ../src/loop.lisp
-(defun main ()
-  "Entry point for the Skeleton MVP. Handles initialization and graceful shutdown."
-  (let* ((home (uiop:getenv "HOME"))
-         (env-file (uiop:merge-pathnames* ".local/share/opencortex/.env" (uiop:ensure-directory-pathname home))))
-    (when (uiop:file-exists-p env-file) (cl-dotenv:load-env env-file)))
-  
-  (initialize-actuators)
-  (initialize-all-skills)
-  (start-heartbeat)
-  
-  ;; Graceful shutdown handler for SBCL
-  #+sbcl
-  (sb-sys:enable-interrupt sb-unix:sigint 
-                           (lambda (sig code scp) 
-                             (declare (ignore sig code scp)) 
-                             (harness-log "SHUTDOWN: SIGINT received. Exiting...")
-                             (uiop:quit 0)))
-
-  (let ((sleep-interval (or (ignore-errors (parse-integer (uiop:getenv "DAEMON_SLEEP_INTERVAL"))) 3600)))
-    (loop 
-      (when (bt:with-lock-held (*interrupt-lock*) *interrupt-flag*) (return))
-      (sleep sleep-interval))))
-#+end_src

literate/manifest.org

@@ -1,77 +0,0 @@
-#+TITLE: Manifest (opencortex.asd)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:system:
-#+STARTUP: content
-
-* Manifest (opencortex.asd)
-** Architectural Intent: The ASDF Skeleton
-
-The ~opencortex.asd~ file is the physical blueprint of the Lisp Machine. It uses **Another System Definition Facility (ASDF)** to orchestrate the compilation and loading of all harness modules. 
-
-Traditional Lisp systems often use complex, non-linear dependency graphs. However, the ~opencortex~ harness mandates a strict, linear bootstrap sequence.
-
-*** 1. Strict Serial Loading (:serial t)
-The harness uses the ~:serial t~ flag. This is a critical design choice that ensures every file is compiled and loaded in the exact order it appears in the ~:components~ list. This eliminates "macro-not-found" errors by guaranteeing that the ~package.lisp~ and ~skills.lisp~ (where the core macros are defined) are always established before any behavioral logic or skills are loaded.
-
-*** 2. Isolation of the Verification Suite
-To maintain a "Zero-Overhead" production environment, the testing logic is isolated into a secondary system: ~:opencortex/tests~. This allows the harness to boot in production without loading the ~FiveAM~ framework or the voluminous test data, keeping the memory footprint minimal and the attack surface small.
-
-** The Build Pipeline
-#+begin_src mermaid
-flowchart TD
-    Org[Literate Org Files] -- Tangle --> Lisp[Source .lisp Files]
-    Lisp --> ASDF[ASDF Manifest: .asd]
-    ASDF --> Loader[SBCL Compiler / Loader]
-    Loader --> Image[Live Harness Image]
-    Image -- Build --> Binary[Standalone Binary]
-#+end_src
-
-** Harness System Definition
-This system defines the core "Thin Harness." It includes the protocol, the object store, and the functional loop.
-
-#+begin_src lisp :tangle ../opencortex.asd
-(defsystem :opencortex
-  :name "opencortex"
-  :author "Amr"
-  :version "0.1.0"
-  :license "AGPLv3"
-  :description "The Probabilistic-Deterministic Lisp Machine Harness"
-  :depends-on (:usocket :bordeaux-threads :dexador :uiop :cl-dotenv :cl-ppcre :hunchentoot :ironclad :str :cl-json :uuid)
-  :serial t
-  :components ((:file "src/package")
-               (:file "src/skills")
-               (:file "src/policy")
-               (:file "src/communication-validator")
-               (:file "src/communication")
-               (:file "src/memory")
-               (:file "src/context")
-               (:file "src/probabilistic")
-               (:file "src/perceive")
-               (:file "src/reason")
-               (:file "src/act")
-               (:file "src/loop"))
-  :build-operation "program-op"
-  :build-pathname "opencortex-server"
-  :entry-point "opencortex:main")
-#+end_src
-
-** Verification Suite Definition
-This system contains the empirical tests required by the Engineering Standards. It depends on ~:opencortex~ and the ~FiveAM~ testing framework.
-
-#+begin_src lisp :tangle ../opencortex.asd
-(defsystem :opencortex/tests
-  :depends-on (:opencortex :fiveam)
-  :components ((:file "tests/communication-tests")
-               (:file "tests/pipeline-tests")
-               (:file "tests/act-tests")
-               (:file "tests/boot-sequence-tests")
-               (:file "tests/memory-tests")
-               (:file "tests/immune-system-tests"))
-  :perform (test-op (o s) 
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :communication-protocol-suite :opencortex-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :pipeline-suite :opencortex-pipeline-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :safety-suite :opencortex-safety-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :boot-suite :opencortex-boot-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :memory-suite :opencortex-memory-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :immune-suite :opencortex-immune-system-tests))))
-#+end_src

literate/memory.org

@@ -1,277 +0,0 @@
-#+TITLE: The System Memory (memory.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:memory:
-#+STARTUP: content
-
-* The System Memory (memory.lisp)
-** Architectural Intent: The Single Address Space (Live Memory)
-
-Yes, the Memory module is the cognitive bedrock of the opencortex. It is not a database; it is the agent's live, active "brain" state.
-
-Traditional architectures rely on external databases (SQLite, Vector DBs) which introduce I/O latency and structural impedance. The opencortex architecture chooses a different path: the **Single Address Space**. By treating the entire knowledge base as a graph of Lisp pointers, we achieve microsecond recollection and total structural transparency.
-
-- **Pointer-Based Reasoning:** By loading the entire knowledge graph into a live Common Lisp hash table, we achieve microsecond recollection. The harness doesn't "search a file"; it traverses a memory pointer.
-- **Memory Imaging:** The ability to snapshot the Lisp image allows the agent to resume its entire cognitive state instantly, solving the "Cold Start" problem.
-- **Merkle-Tree Integrity:** Every node in the Memory is cryptographically hashed. By recursively hashing content and children, the root hash provides a single, immutable fingerprint of the entire system state.
-
-** System Architecture
-#+begin_src mermaid
-flowchart TD
-    subgraph LispMachine[Lisp Machine]
-        H[Harness Pipeline] --> OS[(Memory)]
-        S1[Skill: Architect] --> OS
-        S2[Skill: Analyst] --> OS
-        S3[Skill: GTD] --> OS
-        H -- Pointers --> S1
-        H -- Pointers --> S2
-    end
-    subgraph IPCSlow[External Layer]
-        E[Emacs / Actuators] -. communication protocol .-> H
-    end
-#+end_src
-
-** Package Context
-#+begin_src lisp :tangle ../src/memory.lisp
-(in-package :opencortex)
-#+end_src
-
-** The Object Repository
-The `*memory*` is the global hash table that holds every Org element by its unique ID. This is the "live RAM" of the agent's memory.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defvar *memory* (make-hash-table :test 'equal))
-
-(defvar *history-store* (make-hash-table :test 'equal)
-  "Immutable Merkle-Tree versioning store mapping hashes to objects.")
-#+end_src
-
-** The Data Structure (org-object)
-Every element in the Memex (headlines, paragraphs, etc.) is represented by an `org-object` structure. It contains both semantic metadata (attributes, content) and structural metadata (parent/child pointers, Merkle hashes).
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defstruct org-object
-  id type attributes content vector parent-id children version last-sync hash)
-#+end_src
-
-** Merkle Tree Integrity (compute-merkle-hash)
-The `compute-merkle-hash` function ensures the cryptographic integrity of the knowledge graph. A node's hash depends on its own properties and the hashes of all its children. This creates a recursive fingerprint where any change to a single note propagates up to the root hash.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defun compute-merkle-hash (id type attributes content child-hashes)
-  "Computes a SHA-256 Merkle hash for a node based on its core properties and children's hashes."
-  (let* ((alist (loop for (k v) on attributes by #'cddr collect (cons k v)))
-         (sorted-alist (sort alist #'string< :key (lambda (x) (format nil "~a" (car x)))))
-         (attr-string (format nil "~s" sorted-alist))
-         (children-string (format nil "~{~a~}" child-hashes))
-         (data-string (format nil "ID:~a|TYPE:~s|ATTRS:~a|CONTENT:~a|CHILDREN:~a"
-                              id type attr-string (or content "") children-string))
-         (digester (ironclad:make-digest :sha256)))
-    (ironclad:update-digest digester (ironclad:ascii-string-to-byte-array data-string))
-    (ironclad:byte-array-to-hex-string (ironclad:produce-digest digester))))
-#+end_src
-
-** Ingesting the AST (ingest-ast)
-The `ingest-ast` function is the primary bridge between the external world (Emacs/JSON) and the internal Lisp machine. It recursively parses an Org-mode Abstract Syntax Tree (AST) into `org-object` structures and registers them in the store.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defun ingest-ast (ast &optional parent-id)
-  "Parses an Org AST into the recursive Lisp Memory with Merkle hashing."
-  (let* ((type (getf ast :type))
-         (props (getf ast :properties))
-         (id (or (getf props :ID) (format nil "temp-~a" (get-universal-time))))
-         (contents (getf ast :contents))
-         (raw-content (when (eq type :HEADLINE)
-                        (format nil "~a~%~a" (getf props :TITLE) (or (cl:getf ast :raw-content) ""))))
-         (should-embed (and raw-content (equal (getf props :EMBED) "t")))
-         (child-ids nil)
-         (child-hashes nil))
-    (dolist (child contents)
-      (when (listp child)
-        (let ((child-id (ingest-ast child id)))
-          (push child-id child-ids)
-          (let ((child-id-val child-id))
-             (let ((child-obj (lookup-object child-id-val)))
-               (when child-obj (push (org-object-hash child-obj) child-hashes)))))))
-    (setf child-ids (nreverse child-ids))
-    (setf child-hashes (nreverse child-hashes))
-    (let* ((hash (compute-merkle-hash id type props raw-content child-hashes))
-           (existing-obj (gethash hash *history-store*))
-           (obj (or existing-obj
-                    (make-org-object 
-                     :id id :type type :attributes props :content raw-content
-                     :vector (when should-embed (get-embedding raw-content))
-                     :parent-id parent-id :children child-ids
-                     :version (get-universal-time) :last-sync (get-universal-time)
-                     :hash hash))))
-      (unless existing-obj
-        (setf (gethash hash *history-store*) obj))
-      (setf (gethash id *memory*) obj)
-      id)))
-#+end_src
-
-** Memory Snapshots (snapshot-memory)
-Because objects are stored immutably in the `*history-store*`, a snapshot is a lightweight shallow copy of the active `*memory*` pointers. The system maintains a rolling buffer of 20 snapshots, allowing for near-instant, zero-cost rollback.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defvar *object-store-snapshots* nil)
-
-(defun copy-hash-table (hash-table)
-  "Creates a shallow copy of a hash table."
-  (let ((new-table (make-hash-table :test (hash-table-test hash-table) 
-                                    :size (hash-table-size hash-table))))
-    (maphash (lambda (k v) (setf (gethash k new-table) v)) hash-table)
-    new-table))
-
-(defun snapshot-memory ()
-  "Creates a lightweight, Copy-on-Write snapshot using Merkle-Tree pointers."
-  (let ((snapshot (copy-hash-table *memory*)))
-    (push (list :timestamp (get-universal-time) :data snapshot) *object-store-snapshots*)
-    (when (> (length *object-store-snapshots*) 20)
-      (setf *object-store-snapshots* (subseq *object-store-snapshots* 0 20)))
-    (harness-log "MEMORY - CoW Memory snapshot created.")))
-#+end_src
-
-** Memory Rollback (rollback-memory)
-Restores the state of the Memex from one of the previous snapshots.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defun rollback-memory (&optional (index 0))
-  "Restores the Memory to a previously captured snapshot using immutable history pointers."
-  (let ((snapshot (nth index *object-store-snapshots*)))
-    (if snapshot
-        (progn (setf *memory* (copy-hash-table (getf snapshot :data)))
-               (harness-log "MEMORY - Memory rolled back to snapshot ~a" index))
-        (harness-log "MEMORY ERROR - Snapshot ~a not found." index))))
-#+end_src
-
-** Lookup Utilities
-Basic functions for retrieving objects by ID or type.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defun org-id-new ()
-  "Generates a new UUID string for Org-mode identification."
-  (string-downcase (format nil "~a" (uuid:make-v4-uuid))))
-
-(defun lookup-object (id) 
-  "Retrieves an object from the store by its unique ID."
-  (gethash id *memory*))
-
-(defun list-objects-by-type (type)
-  "Returns a list of all objects matching a specific Org element type."
-  (let ((results nil))
-    (maphash (lambda (id obj) (declare (ignore id)) (when (eq (org-object-type obj) type) (push obj results))) *memory*)
-    results))
-#+end_src
-
-** Structural Helpers
-Utility functions for AST traversal and path resolution.
-
-#+begin_src lisp :tangle ../src/memory.lisp
-(defun find-headline-missing-id (ast)
-  "Traverses an AST to find headlines that lack an :ID: property."
-  (when (listp ast)
-    (if (and (eq (getf ast :type) :HEADLINE) (not (getf (getf ast :properties) :ID)))
-        ast
-        (cl:some #'find-headline-missing-id (getf ast :contents)))))
-
-(defun file-name-nondirectory (path)
-  "Extracts the filename from a full path string."
-  (let ((pos (position #\/ path :from-end t))) (if pos (subseq path (1+ pos)) path)))
-#+end_src
-
-* Phase E: Chaos (Verification)
-Following the Engineering Standards, the Memory must be empirically verified through automated testing. The following test suite ensures the mathematical integrity of the Merkle hashes and the behavioral correctness of the immutable versioning and rollback systems.
-
-#+begin_src lisp :tangle ../tests/memory-tests.lisp
-(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*)))))))
-#+end_src

literate/perceive.org

@@ -1,82 +0,0 @@
-#+TITLE: Stage 1: Perceive (perceive.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:perceive:
-#+STARTUP: content
-
-* Stage 1: Perceive (perceive.lisp)
-** Architectural Intent: Sensory Ingestion
-The Perceive stage is the "sensory cortex" of the OpenCortex. It takes raw stimuli from the outside world (keyboard events, chat messages, heartbeats, or system interrupts) and normalizes them into internal **Signals**.
-
-** Async Sensor Routing
-To prevent blocking the main pipeline, certain sensors (like user commands or chat messages) are processed asynchronously in their own threads.
-
-#+begin_src lisp :tangle ../src/perceive.lisp
-(in-package :opencortex)
-
-(defvar *async-sensors* '(:chat-message :delegation :user-command)
-  "List of sensors that should be processed asynchronously to avoid blocking gateways.")
-#+end_src
-
-** Foveal Focus State
-The system tracks the user's current point of interaction to provide context to the reasoning engine.
-
-#+begin_src lisp :tangle ../src/perceive.lisp
-(defvar *foveal-focus-id* nil
-  "The Org ID of the node the user is currently interacting with.")
-#+end_src
-
-** Stimulus Injection
-The entry point for raw messages. It determines if the signal should be processed synchronously or asynchronously.
-
-#+begin_src lisp :tangle ../src/perceive.lisp
-(defun inject-stimulus (raw-message &key stream (depth 0))
-  "Enqueues a raw message into the reactive signal pipeline."
-  (let* ((payload (getf raw-message :payload)) 
-         (sensor (getf payload :sensor))
-         (async-p (or (getf payload :async-p) (member sensor *async-sensors*))))
-    (when stream (setf (getf raw-message :reply-stream) stream))
-    (if async-p 
-        (bt:make-thread 
-         (lambda () 
-           (restart-case (handler-bind ((error (lambda (c) (harness-log "ASYNC ERROR: ~a" c) (invoke-restart 'skip-event))))
-                           (process-signal raw-message)) 
-             (skip-event () nil))) 
-         :name "opencortex-async-task")
-        (restart-case (handler-bind ((error (lambda (c) (harness-log "SYSTEM ERROR: ~a" c) (invoke-restart 'skip-event)))) 
-                        (process-signal raw-message))
-          (skip-event () (harness-log "SYSTEM RECOVERY: Stimulus dropped.~%"))))))
-#+end_src
-
-** The Perceive Gate
-The initial stage of the metabolic loop. It logs the signal, performs selective memory snapshots, and updates the Memory graph based on incoming AST updates.
-
-#+begin_src lisp :tangle ../src/perceive.lisp
-(defun perceive-gate (signal)
-  "Initial processing: Normalizes raw stimuli and updates memory."
-  (let* ((payload (getf signal :payload))
-         (type (getf signal :type))
-         (sensor (getf payload :sensor)))
-    (harness-log "GATE [Perceive]: ~a (~a)" type (or sensor "no-sensor"))
-    
-    (cond ((eq type :EVENT)
-           (case sensor
-             (:buffer-update 
-              (let ((ast (getf payload :ast))) 
-                (when ast 
-                  (snapshot-memory)
-                  (ingest-ast ast))))
-             (:point-update 
-              (let ((element (getf payload :element))) 
-                (when element 
-                  (snapshot-memory)
-                  (setf *foveal-focus-id* (ignore-errors (getf element :id)))
-                  (ingest-ast element))))
-             (:interrupt 
-              (bt:with-lock-held (*interrupt-lock*) (setf *interrupt-flag* t)))))
-          ((eq type :RESPONSE)
-           (harness-log "GATE [Perceive]: Act Result -> ~a" (getf payload :status))))
-           
-    (setf (getf signal :status) :perceived)
-    (setf (getf signal :foveal-focus) *foveal-focus-id*)
-    signal))
-#+end_src

literate/reason.org

@@ -1,119 +0,0 @@
-#+TITLE: Stage 2: Reason (reason.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:reason:
-#+STARTUP: content
-
-* Stage 2: Reason (reason.lisp)
-** Architectural Intent: Unified Cognition
-The Reason stage is the cognitive engine of the OpenCortex. It unifies two distinct reasoning modes:
-1. **Probabilistic Reasoning:** Consulting neural models (LLMs) to generate action proposals based on current context.
-2. **Deterministic Reasoning:** Running those proposals through a series of deterministic safety gates (Policy, Invariants, and Skill-specific validation) to ensure alignment and security.
-
-** Package and Registry
-We initialize the probabilistic backends and the provider cascade which determines the order in which models are consulted.
-
-#+begin_src lisp :tangle ../src/reason.lisp
-(in-package :opencortex)
-
-(defvar *probabilistic-backends* (make-hash-table :test 'equal))
-(defvar *provider-cascade* nil)
-(defvar *model-selector-fn* nil)
-(defvar *consensus-enabled-p* nil)
-
-(defun register-probabilistic-backend (name fn)
-  "Registers a neural provider (e.g., :gemini, :anthropic) with its calling function."
-  (setf (gethash name *probabilistic-backends*) fn))
-#+end_src
-
-** Neural Dispatch (Probabilistic)
-The `probabilistic-call` function manages the cascade of neural providers. If the primary provider fails, it automatically falls back to the next one in the list.
-
-#+begin_src lisp :tangle ../src/reason.lisp
-(defun probabilistic-call (prompt &key (system-prompt "You are the Probabilistic engine.") (cascade nil) (context nil))
-  "Dispatches a neural request through the provider cascade. Returns a Lisp plist or a failure log."
-  (let ((backends (or cascade *provider-cascade*)))
-    (or (dolist (backend backends)
-          (let ((backend-fn (gethash backend *probabilistic-backends*)))
-            (when backend-fn
-              (harness-log "PROBABILISTIC: Attempting backend ~a..." backend)
-              (let* ((model (when *model-selector-fn* (funcall *model-selector-fn* backend context)))
-                     (result (if model 
-                                 (funcall backend-fn prompt system-prompt :model model)
-                                 (funcall backend-fn prompt system-prompt))))
-                ;; If the result is valid and doesn't contain a failure log, return it.
-                (unless (or (null result) 
-                            (and (stringp result) (search ":LOG" result)))
-                  (return result))))))
-        ;; Final fallback if all backends in the cascade fail.
-        (list :type :LOG :payload (list :text "Neural Cascade Failure: All providers exhausted.")))))
-#+end_src
-
-** Cognitive Proposal (Think)
-The `think` function represents the "intuitive" side of the agent. It identifies the active skill, assembles the global context, and asks the probabilistic engine for a structured action proposal.
-
-#+begin_src lisp :tangle ../src/reason.lisp
-(defun think (context)
-  "Generates a Lisp action proposal based on current context."
-  (let* ((active-skill (find-triggered-skill context))
-         (tool-belt (generate-tool-belt-prompt))
-         (global-context (context-assemble-global-awareness))
-         (system-logs (context-get-system-logs))
-         (assistant-name (or (uiop:getenv "MEMEX_ASSISTANT") "Agent")))
-    (if active-skill
-        (let* ((prompt-generator (skill-probabilistic-prompt active-skill))
-               (raw-prompt (when prompt-generator (funcall prompt-generator context)))
-               (system-prompt (format nil "IDENTITY: Actuator for ~a. MANDATE: ONE Lisp plist. ~a ~a RECENT_LOGS: ~a" 
-                                      assistant-name global-context tool-belt system-logs)))
-          (if (and raw-prompt (> (length raw-prompt) 1))
-              (let* ((thought (probabilistic-call raw-prompt :system-prompt system-prompt :context context))
-                     ;; Ensure we are working with a string for read-from-string
-                     (cleaned (if (stringp thought) (string-trim '(#\Space #\Newline #\Tab) thought) thought)))
-                (if (stringp cleaned)
-                    (handler-case (read-from-string cleaned)
-                      (error (c) (list :type :EVENT :payload (list :sensor :syntax-error :code cleaned :error (format nil "~a" c)))))
-                    cleaned))
-              (list :type :LOG :payload (list :text (format nil "Skill '~a' triggered (Deterministic only)" (skill-name active-skill))))))
-        nil)))
-#+end_src
-
-** Deterministic Verification
-Once a proposal is generated, it MUST pass through the deterministic gates. Every skill can register a gate that inspects and potentially modifies or blocks the proposed action.
-
-#+begin_src lisp :tangle ../src/reason.lisp
-(defun deterministic-verify (proposed-action context)
-  "Iterates through all skill deterministic-gates sorted by priority."
-  (let ((current-action proposed-action)
-        (skills nil))
-    ;; 1. Collect and sort active gates
-    (maphash (lambda (name skill) (declare (ignore name)) (when (skill-deterministic-fn skill) (push skill skills))) *skills-registry*)
-    (setf skills (sort skills #'> :key #'skill-priority))
-    
-    ;; 2. Execute gates sequentially if their trigger allows
-    (dolist (skill skills)
-      (let ((trigger (skill-trigger-fn skill))
-            (gate (skill-deterministic-fn skill)))
-        (when (or (null trigger) (ignore-errors (funcall trigger context)))
-          (setf current-action (funcall gate current-action context))
-          ;; If any gate returns a LOG or EVENT, it has intercepted the action.
-          (when (and (listp current-action) (member (getf current-action :type) '(:LOG :EVENT :log :event)))
-            (harness-log "DETERMINISTIC: Intercepted by skill '~a'" (skill-name skill))
-            (return-from deterministic-verify current-action)))))
-    current-action))
-#+end_src
-
-** The Reason Gate
-The entry point for the Reason stage. It orchestrates the transition from probabilistic "thought" to deterministic "verification."
-
-#+begin_src lisp :tangle ../src/reason.lisp
-(defun reason-gate (signal)
-  "Unified Stage: Combines Probabilistic proposals and Deterministic verification."
-  ;; Only process events that haven't been reasoned yet.
-  (unless (eq (getf signal :type) :EVENT) (return-from reason-gate signal))
-  
-  (let ((candidate (think signal)))
-    (if candidate
-        (setf (getf signal :approved-action) (deterministic-verify candidate signal))
-        (setf (getf signal :approved-action) nil))
-    (setf (getf signal :status) :reasoned)
-    signal))
-#+end_src

literate/setup.org

@@ -1,370 +0,0 @@
-#+TITLE: Setup & Onboarding (setup.org)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:setup:onboarding:
-#+STARTUP: content
-
-* Overview: The Zero-to-One Experience
-The *Setup & Onboarding* process ensures that users can boot the ~opencortex~ Lisp Machine with zero friction. We follow the *Appliance Paradigm* for standard users (Docker-first) and provide a *Power User Path* (Baremetal) for those wanting deep native integration.
-
-This file is a Literate Devops document. Tangling it generates the Docker configuration and the unified entrypoint script (~opencortex.sh~).
-
-* 1. The Appliance Paradigm (Docker First)
-The easiest way to run the agent is via Docker. This prevents the user from having to manually manage SBCL, Quicklisp, Python virtual environments, Playwright binaries, and Java (for Signal).
-
-** The Dockerfile
-The container wraps all messy OS dependencies and pre-caches the Lisp environment for rapid booting.
-
-#+begin_src dockerfile :tangle ../Dockerfile
-# OPENCORTEX v1.0 Production Environment
-FROM debian:bookworm-slim
-
-# Prevent interactive prompts during build
-ENV DEBIAN_FRONTEND=noninteractive
-
-# 1. Install System Dependencies
-# - sbcl: The Lisp Runtime
-# - curl/git/unzip: Standard tools for Quicklisp and binaries
-# - default-jre: Required by signal-cli
-# - python3/pip: Required for Playwright bridge
-# - socat: Required for stateful CLI interaction
-RUN apt-get update && apt-get install -y \
-    sbcl \
-    curl \
-    git \
-    unzip \
-    default-jre \
-    libsqlite3-0 \
-    python3 \
-    python3-pip \
-    python3-venv \
-    emacs-nox \
-    socat \
-    && rm -rf /var/lib/apt/lists/*
-
-# 2. Setup Playwright (High-Fidelity Browsing)
-RUN python3 -m venv /opt/venv
-ENV PATH="/opt/venv/bin:$PATH"
-RUN pip install playwright \
-    && playwright install --with-deps chromium
-
-# 3. Install signal-cli (v0.14.0)
-ENV SIGNAL_CLI_VERSION=0.14.0
-RUN curl -L https://github.com/AsamK/signal-cli/releases/download/v${SIGNAL_CLI_VERSION}/signal-cli-${SIGNAL_CLI_VERSION}-Linux.tar.gz | tar xz -C /opt \
-    && ln -s /opt/signal-cli-${SIGNAL_CLI_VERSION}/bin/signal-cli /usr/local/bin/signal-cli
-
-# 4. Install Quicklisp & Pin Distribution
-# Pinned to 2026-04-01 for bit-rot resistance.
-WORKDIR /root
-RUN curl -O https://beta.quicklisp.org/quicklisp.lisp \
-    && sbcl --non-interactive \
-        --load quicklisp.lisp \
-        --eval '(quicklisp-quickstart:install)' \
-        --eval '(ql-dist:install-dist "http://beta.quicklisp.org/dist/quicklisp/2026-04-01/distinfo.txt" :prompt nil :replace t)'
-
-# 5. Configure SBCL to load Quicklisp on startup
-RUN echo '(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))) (when (probe-file quicklisp-init) (load quicklisp-init)))' > /root/.sbclrc
-
-# 6. Setup Application Directory
-WORKDIR /app
-COPY . /app/projects/opencortex
-
-# 7. Pre-cache Lisp Dependencies
-RUN sbcl --non-interactive \
-    --eval '(push #p"/app/projects/opencortex/" asdf:*central-registry*)' \
-    --eval '(ql:quickload :opencortex)'
-
-# 8. Environment & Volumes
-# The host's memex root should be mounted to /memex
-ENV MEMEX_DIR=/memex
-VOLUME ["/memex"]
-
-# Default Ports
-EXPOSE 9105 8080
-
-# Entrypoint
-CMD ["sbcl", "--non-interactive", \
-     "--eval", "(push #p\"/app/projects/opencortex/\" asdf:*central-registry*)", \
-     "--eval", "(ql:quickload :opencortex)", \
-     "--eval", "(opencortex:main)"]
-#+end_src
-
-** Docker Compose
-#+begin_src yaml :tangle ../docker-compose.yml
-services:
-  opencortex:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: opencortex
-    env_file: .env
-    volumes:
-      # Mount the entire memex directory (2 levels up from projects/opencortex)
-      - ../..:/memex
-      # Ensure signal-cli state is preserved
-      - signal-state:/root/.local/share/signal-cli
-    ports:
-      - "${ORG_AGENT_DAEMON_PORT:-9105}:9105"
-      - "${ORG_AGENT_WEB_PORT:-8080}:8080"
-    restart: unless-stopped
-
-volumes:
-  signal-state:
-#+end_src
-
-* 2. The Unified Entrypoint (opencortex.sh)
-We combine the installation script, the daemon launcher, and the CLI chat client into a single, elegant bash script. 
-
-If the agent is running, it connects to the chat. If it's installed but offline, it boots the daemon. If it's not installed at all, it walks the user through the onboarding wizard.
-
-#+begin_src bash :tangle ../opencortex.sh :shebang "#!/bin/bash"
-set -e
-
-PORT=9105
-HOST=${1:-localhost}
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[0;33m'
-NC='\033[0m'
-
-command_exists() { command -v "$1" >/dev/null 2>&1; }
-
-update_opencortex() {
-    echo -e "${BLUE}Updating OpenCortex...${NC}"
-    if [ -d ".git" ]; then
-        echo "Pulling latest changes from repository..."
-        git pull origin main
-    fi
-    if [ -f .env ]; then
-        SKILLS_DIR=$(grep "^SKILLS_DIR=" .env | cut -d"\"" -f2)
-        SKILLS_DIR=${SKILLS_DIR:-$(pwd)/notes}
-        echo "Synchronizing core skills to $SKILLS_DIR..."
-        mkdir -p "$SKILLS_DIR"
-        cp -n skills/*.org "$SKILLS_DIR/" 2>/dev/null || true
-    fi
-    if command_exists docker-compose && [ -f "docker-compose.yml" ]; then
-        echo "Rebuilding Docker image..."
-        docker-compose up -d --build
-    fi
-    echo -e "${GREEN}✓ Update complete.${NC}"
-    exit 0
-}
-
-if [[ "$1" == "--update" ]]; then
-    update_opencortex
-fi
-
-# 1. Try to drop straight into the CLI chat
-if command_exists socat && socat - TCP:$HOST:$PORT,connect-timeout=1 2>/dev/null; then
-    echo -e "${BLUE}Connected to autonomous brain at $HOST:$PORT...${NC}"
-    # Use socat with READLINE for history and arrow-key support.
-    # It establishes a persistent bidirectional connection.
-    socat READLINE,history=$HOME/.org_agent_history TCP:$HOST:$PORT
-    exit 0
-elif command_exists nc && nc -z $HOST $PORT 2>/dev/null; then
-    echo -e "${YELLOW}socat not found. Falling back to nc (no line-editing).${NC}"
-    echo -e "${BLUE}Connected to autonomous brain at $HOST:$PORT...${NC}"
-    while true; do
-        read -p "User: " MESSAGE
-        if [ -z "$MESSAGE" ]; then continue; fi
-        echo "$MESSAGE" | nc -N $HOST $PORT
-    done
-    exit 0
-fi
-
-# 2. Check if we have an existing installation we can boot
-if [ -f "$HOME/.opencortex-path" ]; then
-    INSTALL_DIR=$(cat "$HOME/.opencortex-path")
-    if [ -d "$INSTALL_DIR" ] && [ -f "$INSTALL_DIR/docker-compose.yml" ]; then
-        echo -e "${YELLOW}Daemon is offline. Booting from $INSTALL_DIR...${NC}"
-        cd "$INSTALL_DIR"
-        docker-compose up -d
-        echo "Waiting for brain to initialize..."
-        sleep 5
-        # Re-run to enter chat
-        exec "$0" "$@"
-    fi
-fi
-
-# 3. If we are running this inside a cloned repo, configure and boot
-if [ -f "docker-compose.yml" ] && [ -d "literate" ]; then
-    echo -e "${YELLOW}Local repository detected. Ensuring configuration...${NC}"
-    INSTALL_DIR=$(pwd)
-    echo "$INSTALL_DIR" > "$HOME/.opencortex-path"
-    
-    if [ ! -f .env ]; then
-        cp .env.example .env
-        read -p "What is your name? (default: User): " USER_NAME
-        USER_NAME=${USER_NAME:-User}
-        sed -i "s/MEMEX_USER=.*/MEMEX_USER=\"$USER_NAME\"/g" .env
-
-        read -p "What shall we name your Assistant? (default: Agent): " AGENT_NAME
-        AGENT_NAME=${AGENT_NAME:-Agent}
-        sed -i "s/MEMEX_ASSISTANT=.*/MEMEX_ASSISTANT=\"$AGENT_NAME\"/g" .env
-
-        echo -e "\nSelect your primary neural provider:"
-        echo "1) Google Gemini (Free Tier / Official)"
-        echo "2) OpenRouter (Unified / Paid)"
-        echo "3) Anthropic (Claude / API Key)"
-        echo "4) OpenAI (GPT / API Key)"
-        read -p "Choice [1-4]: " LLM_CHOICE
-
-        case $LLM_CHOICE in
-            2) read -p "Enter OpenRouter API Key: " INPUT; sed -i "s/OPENROUTER_API_KEY=.*/OPENROUTER_API_KEY=\"$INPUT\"/g" .env ;;
-            3) read -p "Enter Anthropic API Key: " INPUT; sed -i "s/ANTHROPIC_API_KEY=.*/ANTHROPIC_API_KEY=\"$INPUT\"/g" .env ;;
-            4) read -p "Enter OpenAI API Key: " INPUT; sed -i "s/OPENAI_API_KEY=.*/OPENAI_API_KEY=\"$INPUT\"/g" .env ;;
-            *) read -p "Enter Gemini API Key: " INPUT; sed -i "s/GEMINI_API_KEY=.*/GEMINI_API_KEY=\"$INPUT\"/g" .env ;;
-        esac
-
-        # Seed Core Skills
-        echo -e "\n${BLUE}Seeding Skills...${NC}"
-        MEMEX_TARGET=$(dirname $(dirname "$INSTALL_DIR"))
-        SKILLS_DIR=$(grep "^SKILLS_DIR=" .env | cut -d"\"" -f2) ; SKILLS_DIR=${SKILLS_DIR:-$MEMEX_TARGET/notes}
-        mkdir -p "$SKILLS_DIR"
-        cp -n skills/*.org "$SKILLS_DIR/" 2>/dev/null || true
-        echo -e "${GREEN}✓ Core skills seeded to $SKILLS_DIR.${NC}"
-    fi
-    
-    docker-compose up -d --build
-    echo "Waiting for brain to initialize..."
-    sleep 5
-    exec "$0" "$@"
-fi
-
-# 4. Zero-to-One Onboarding (No installation found)
-echo -e "${BLUE}==================================================${NC}"
-echo -e "${BLUE} opencortex: Autonomous Intelligence Onboarding     ${NC}"
-echo -e "${BLUE}==================================================${NC}"
-
-# --- OS & Docker Detection ---
-echo -e "\n${BLUE}[1/2] Verifying Environment...${NC}"
-
-install_docker() {
-    echo -e "${YELLOW}Docker is required to run opencortex natively without messy dependencies.${NC}"
-    read -p "Would you like me to attempt to install Docker? [Y/n]: " install_choice
-    install_choice=${install_choice:-Y}
-    if [[ "$install_choice" =~ ^[Yy]$ ]]; then
-        if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-            if command_exists apt-get; then
-                echo "Installing Docker via apt..."
-                sudo apt-get update
-                sudo apt-get install -y docker.io docker-compose
-            elif command_exists dnf; then
-                echo "Installing Docker via dnf..."
-                sudo dnf install -y docker docker-compose
-                sudo systemctl start docker
-                sudo systemctl enable docker
-            else
-                echo -e "${RED}Unsupported package manager. Please install Docker manually.${NC}"
-                exit 1
-            fi
-        elif [[ "$OSTYPE" == "darwin"* ]]; then
-            if command_exists brew; then
-                echo "Installing Docker Desktop via Homebrew..."
-                brew install --cask docker
-                echo -e "${YELLOW}Please start Docker Desktop from your Applications folder, then re-run this script.${NC}"
-                exit 0
-            else
-                echo -e "${RED}Homebrew not found. Please install Docker Desktop for Mac manually.${NC}"
-                exit 1
-            fi
-        else
-            echo -e "${RED}Unsupported OS for automated Docker installation. Please install manually.${NC}"
-            exit 1
-        fi
-    else
-        echo -e "${RED}Docker is required. Aborting.${NC}"
-        exit 1
-    fi
-}
-
-if ! command_exists docker || ! command_exists docker-compose; then
-    install_docker
-else
-    echo -e "${GREEN}✓ Docker and docker-compose detected.${NC}"
-fi
-
-# --- Repository Setup ---
-echo -e "\n${BLUE}[2/2] Downloading Kernel...${NC}"
-MEMEX_DEFAULT="$HOME/memex"
-read -p "Where is your Memex located? (default: $MEMEX_DEFAULT): " MEMEX_TARGET
-MEMEX_TARGET=${MEMEX_TARGET:-$MEMEX_DEFAULT}
-
-mkdir -p "$MEMEX_TARGET/projects"
-cd "$MEMEX_TARGET/projects"
-
-if [ ! -d "opencortex" ]; then
-    echo "Cloning opencortex..."
-    git clone https://github.com/gharbeia/opencortex.git
-    cd opencortex
-else
-    echo -e "${GREEN}✓ Repository already exists.${NC}"
-    cd opencortex
-    git pull origin main
-fi
-
-mkdir -p "$HOME/.local/bin"
-ln -sf "$(pwd)/opencortex.sh" "$HOME/.local/bin/opencortex"
-echo -e "${GREEN}✓ Installed 'opencortex' command to ~/.local/bin${NC}"
-
-# Ensure proper ownership if sudo was used for apt
-if [ -n "$SUDO_USER" ]; then
-    chown -R "$SUDO_USER" "$MEMEX_TARGET/projects/opencortex"
-fi
-
-# Execute the newly cloned script to run configuration (Step 3)
-exec ./opencortex.sh
-#+end_src
-
-* 3. The Power-User Path (Baremetal Onboarding)
-For users who want to run the Lisp Machine natively on their host OS (typically Emacs users who want the agent to directly manipulate their local =.emacs.d=), we provide the baremetal setup script. This script verifies the host has SBCL and Quicklisp installed, and configures the paths natively.
-
-#+begin_src bash :tangle ../scripts/onboard-baremetal.sh :shebang "#!/bin/bash"
-set -e
-RED='\033[0;31m'; GREEN='\033[0;32m'; BLUE='\033[0;34m'; NC='\033[0m'
-
-echo -e "${BLUE}=== opencortex: Baremetal Power-User Setup ===${NC}"
-
-if ! command -v sbcl >/dev/null 2>&1; then
-    echo -e "${RED}✗ SBCL not found. Please install it first.${NC}"
-    exit 1
-fi
-
-if [ ! -d "$HOME/quicklisp" ] && [ ! -d "$HOME/.quicklisp" ]; then
-    echo -e "${RED}✗ Quicklisp not found. Please install Quicklisp.${NC}"
-    exit 1
-fi
-
-if [ ! -f .env ]; then cp .env.example .env; fi
-
-read -p "What is your name? (default: User): " USER_NAME
-USER_NAME=${USER_NAME:-User}
-sed -i "s/MEMEX_USER=.*/MEMEX_USER=\"$USER_NAME\"/g" .env
-
-read -p "What shall we name your Assistant? (default: Agent): " AGENT_NAME
-AGENT_NAME=${AGENT_NAME:-Agent}
-sed -i "s/MEMEX_ASSISTANT=.*/MEMEX_ASSISTANT=\"$AGENT_NAME\"/g" .env
-
-echo "Select primary neural provider:"
-echo "1) Gemini"; echo "2) OpenRouter"; echo "3) Anthropic"; echo "4) OpenAI"
-read -p "Choice [1-4]: " LLM_CHOICE
-case $LLM_CHOICE in
-    2) read -p "Enter OpenRouter Key: " INPUT; sed -i "s/OPENROUTER_API_KEY=.*/OPENROUTER_API_KEY=\"$INPUT\"/g" .env ;;
-    3) read -p "Enter Anthropic Key: " INPUT; sed -i "s/ANTHROPIC_API_KEY=.*/ANTHROPIC_API_KEY=\"$INPUT\"/g" .env ;;
-    4) read -p "Enter OpenAI Key: " INPUT; sed -i "s/OPENAI_API_KEY=.*/OPENAI_API_KEY=\"$INPUT\"/g" .env ;;
-    *) read -p "Enter Gemini Key: " INPUT; sed -i "s/GEMINI_API_KEY=.*/GEMINI_API_KEY=\"$INPUT\"/g" .env ;;
-esac
-
-# Update baremetal paths based on current directory structure
-PROJECT_ROOT=$(pwd)
-PARENT_DIR=$(dirname "$PROJECT_ROOT")
-sed -i "s|MEMEX_DIR=.*|MEMEX_DIR=\"$PARENT_DIR\"|g" .env
-sed -i "s|ZETTELKASTEN_DIR=.*|ZETTELKASTEN_DIR=\"$PARENT_DIR/notes\"|g" .env
-sed -i "s|SKILLS_DIR=.*|SKILLS_DIR=\"$PARENT_DIR/notes\"|g" .env
-
-mkdir -p "$PARENT_DIR/notes"
-cp -n skills/*.org "$PARENT_DIR/notes/" 2>/dev/null || true
-
-echo -e "${GREEN}Baremetal setup complete. Run 'make run' to start.${NC}"
-#+end_src

literate/skills.org

@@ -1,448 +0,0 @@
-#+TITLE: The Skill Engine (skills.lisp)
-#+AUTHOR: Amr
-#+FILETAGS: :harness:skills:
-#+STARTUP: content
-
-* The Skill Engine (skills.lisp)
-** Architectural Intent: Late-Binding Intelligence
-
-A static, hardcoded architecture is inherently fragile. To build a autonomous agent that can evolve alongside its user, the harness must be a "Thin Shell" that delegates its capabilities to dynamic, hot-reloadable modules known as **Skills**. This is the core of our **Thin Harness / Thick Skill Microkernel Architecture**.
-
-Skills unify the **"Why"** (Literate Org documentation) and the **"How"** (Functional Lisp implementation). This allows the harness to "learn" new behaviors without a full system restart, enabling a continuous evolutionary loop where the agent can eventually inspect and improve its own code.
-
-*** The True Microkernel (Decoupled Core Skills)
-Historically, "core" skills (like State Persistence or Gateways) were statically compiled into the harness for performance. We have fundamentally decoupled this. Now, *all* behavioral skills are pure user-space dynamic modules. 
-
-**** MANDATE: Dynamic Loading (No Tangling)
-Skills are defined as single-file Literate Org notes. Unlike the core harness, **Skills MUST NOT use :tangle headers.** 
-
-Instead of being compiled into static source files, skills are:
-1. **Discovered:** The harness scans the `skills/` directory for `.org` files.
-2. **Parsed:** The harness extracts Lisp code blocks directly from the Org AST.
-3. **Jailed:** Each skill is evaluated inside its own temporary, isolated package namespace.
-4. **Hot-Loaded:** Skills can be added, modified, or removed at runtime without restarting the Lisp image.
-
-This ensures the agent can safely read, write, and repair its own capabilities without breaking the physical file structure. If a user wishes to swap the IPFS persistence skill for an AWS S3 one, they simply swap the `.org` file; no kernel recompilation is required.
-
-*** Dormant Verification (Tests)
-Because skills are no longer statically compiled into the core `opencortex` ASDF system, their associated `FiveAM` test blocks are currently dormant during a standard static build. The tests still exist within the literate `.org` files as verifiable documentation, but executing them requires either dynamic evaluation at runtime or a dedicated test-loader skill.
-
-*** 1. The Package Jailing Principle
-Every skill is evaluated within its own dedicated Common Lisp package (namespace). This "Jailing" prevents symbol collisions between disparate skills and ensures that a bug in one module cannot easily corrupt the internal state of another.
-
-*** 2. Deterministic Load Ordering
-Skills often depend on one another. The harness implements a deterministic topological sorting algorithm to ensure that dependencies are loaded before the skills that require them.
-
-** Skill Architecture
-#+begin_src mermaid
-flowchart TD
-    Registry[Skills Registry] --> S1[Skill: System Policy]
-    Registry --> S2[Skill: LLM Gateway]
-    Registry --> S3[Skill: Token Accountant]
-    S2 -- Depends On --> S1
-    S3 -- Depends On --> S2
-    
-    subgraph Jailing[Package Jailing]
-        P1[Package: OPENCORTEX.SKILLS.S1]
-        P2[Package: OPENCORTEX.SKILLS.S2]
-        P3[Package: OPENCORTEX.SKILLS.S3]
-    end
-    
-    S1 --> P1
-    S2 --> P2
-    S3 --> P3
-#+end_src
-
-** Package Context
-We begin by ensuring we are in the correct isolated harness namespace.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(in-package :opencortex)
-#+end_src
-
-** Skill Metadata (defstruct skill)
-The core data structure representing an agent capability. It includes the trigger condition, the probabilistic prompt generator, and the deterministic safety gate.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defstruct skill name priority dependencies trigger-fn probabilistic-prompt deterministic-fn)
-#+end_src
-
-** Skill Catalog Tracking
-The harness maintains a stateful tracking table for all skill files discovered in the environment (~notes/org-skill-*.org~).
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defvar *skill-catalog* (make-hash-table :test 'equal)
-  "A stateful tracking table for all skill files discovered in the environment.")
-
-(defstruct skill-entry 
-  filename 
-  (status :discovered) ;; :discovered, :loading, :ready, :failed
-  error-log
-  (load-time 0))
-#+end_src
-
-** Skill Selection (find-triggered-skill)
-The primary dispatcher for the Probabilistic Engine. It iterates through the registry to find the highest-priority skill whose trigger function matches the current cognitive context.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun find-triggered-skill (context)
-  "Returns the highest priority skill whose trigger condition matches the context."
-  (let ((triggered nil))
-    (maphash (lambda (name skill) 
-               (declare (ignore name)) 
-               (when (ignore-errors (funcall (skill-trigger-fn skill) context)) 
-                 (push skill triggered))) 
-             *skills-registry*)
-    (first (sort triggered #'> :key #'skill-priority))))
-#+end_src
-
-** Skill Definition Macro (defskill)
-The interface used within Org files to register new capabilities. Note that dependencies are explicitly quoted to prevent premature evaluation during the macro expansion phase.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defmacro defskill (name &key priority dependencies trigger probabilistic deterministic)
-  "Registers a new skill into the global registry."
-  `(setf (gethash (string-downcase (string ,name)) *skills-registry*)
-         (make-skill :name (string-downcase (string ,name)) 
-                     :priority (or ,priority 10) 
-                     :dependencies ',dependencies
-                     :trigger-fn ,trigger 
-                     :probabilistic-prompt ,probabilistic 
-                     :deterministic-fn ,deterministic)))
-#+end_src
-
-** Dependency Resolution (resolve-skill-dependencies)
-Recursively flattens the dependency graph for a given skill. This is used during hot-unloading to ensure that dependent skills are also refreshed.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun resolve-skill-dependencies (skill-name)
-  "Recursively resolves dependencies for a given skill name."
-  (let ((resolved nil) (seen nil))
-    (labels ((visit (name) 
-               (unless (member name seen :test #'equal) 
-                 (push name seen)
-                 (let ((skill (gethash (string-downcase (string name)) *skills-registry*)))
-                   (when skill 
-                     (dolist (dep (skill-dependencies skill)) 
-                       (visit dep))))
-                 (push name resolved))))
-      (visit skill-name) 
-      (nreverse resolved))))
-#+end_src
-
-** Metadata Parsing (parse-skill-metadata)
-A robust, low-level scanner that extracts `#+DEPENDS_ON:` and `:ID:` tags from an Org file. This allows the harness to calculate the load order without needing to parse the full Org AST, which would create a boot-time circularity.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun parse-skill-metadata (filepath)
-  "Extracts ID and DEPENDS_ON tags using robust regex scanning."
-  (let ((dependencies nil)
-        (id nil)
-        (content (uiop:read-file-string filepath)))
-    ;; Extract ID
-    (multiple-value-bind (match regs)
-        (ppcre:scan-to-strings "(?im:^:ID:\\s*([^\\s\\r\\n]+))" content)
-      (when match (setf id (aref regs 0))))
-    ;; Extract all DEPENDS_ON lines
-    (ppcre:do-register-groups (deps-string)
-        ("(?im:^#\\+DEPENDS_ON:\\s*(.*))" content)
-      (let ((deps (ppcre:split "\\s+" (string-trim " " deps-string))))
-        (setf dependencies (append dependencies (mapcar (lambda (s) (string-trim "[] " s)) deps)))))
-    (values id (remove-if (lambda (s) (= 0 (length s))) dependencies))))
-#+end_src
-
-** Topological Sorting (topological-sort-skills)
-This is the core algorithm of the boot sequence. It uses a **Depth-First Search (DFS)** to resolve the skill dependency graph. 
-
-It performs three critical roles:
-1.  **Load Ordering:** Ensures that "foundational" skills (like the LLM Gateway) are loaded before high-level "behavioral" skills.
-2.  **ID Resolution:** Correct maps Org `:ID:` properties to filepaths.
-3.  **Cycle Detection:** It uses a recursion stack to detect circular dependencies (e.g., A depends on B, B depends on A) and errors out safely before the Lisp image hangs.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun topological-sort-skills (skills-dir)
-  "Returns a list of skill filepaths sorted by dependency (dependencies first)."
-  (let ((files (uiop:directory-files skills-dir "org-skill-*.org"))
-        (adj (make-hash-table :test 'equal))
-        (name-to-file (make-hash-table :test 'equal))
-        (id-to-file (make-hash-table :test 'equal))
-        (result nil)
-        (visited (make-hash-table :test 'equal))
-        (stack (make-hash-table :test 'equal)))
-    (dolist (file files)
-      (let ((filename (pathname-name file)))
-        (multiple-value-bind (id deps) (parse-skill-metadata file)
-          (setf (gethash (string-downcase filename) name-to-file) file)
-          (when id (setf (gethash (string-downcase id) id-to-file) file))
-          (setf (gethash (string-downcase filename) adj) deps))))
-    (labels ((visit (file)
-               (let* ((filename (pathname-name file))
-                      (node-key (string-downcase filename)))
-                 (unless (gethash node-key visited)
-                   (setf (gethash node-key stack) t)
-                   (dolist (dep (gethash node-key adj))
-                     (let* ((is-id-p (uiop:string-prefix-p "id:" (string-downcase dep)))
-                            (dep-key (string-downcase (if is-id-p (subseq dep 3) dep)))
-                            (dep-file (if is-id-p 
-                                          (gethash dep-key id-to-file)
-                                          (or (gethash dep-key id-to-file)
-                                              (gethash dep-key name-to-file)))))
-                       (when dep-file
-                         (let ((dep-filename (pathname-name dep-file)))
-                           (if (gethash (string-downcase dep-filename) stack)
-                               (error "Circular dependency detected: ~a -> ~a" filename dep-filename)
-                               (visit dep-file))))))
-                   (setf (gethash node-key stack) nil)
-                   (setf (gethash node-key visited) t)
-                   (push file result)))))
-      (let ((filenames (sort (mapcar #'pathname-name files) #'string<)))
-        (dolist (name filenames)
-          (let ((file (gethash (string-downcase name) name-to-file)))
-            (when file (visit file)))))
-      (nreverse result))))
-#+end_src
-
-** Syntax Validation (validate-lisp-syntax)
-A pre-flight safety check. Before evaluating any code from an Org file, the harness attempts to ~read~ the entire string. If the reader encounters a syntax error (like an unclosed parenthesis), the load is aborted before the Lisp image can crash.
-
-#+begin_src lisp :tangle ../src/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)))))
-#+end_src
-
-** Jailed Loading (load-skill-from-org)
-The core "hot-loading" mechanism. It extracts Lisp blocks from an Org file and evaluates them within a "Jail" (an isolated package).
-
-*** The Jailing Algorithm:
-1.  **Isolation:** It generates a package name based on the filename (e.g., ~OPENCORTEX.SKILLS.CORE-LOGIC~).
-2.  **Namespace Protection:** It inherits external symbols from the ~OPENCORTEX~ package, allowing the skill to use the harness API, but keeps its internal helper functions local.
-3.  **Block Filtering:** It explicitly ignores blocks that contain ~:tangle~, ensuring that harness-level code (which is already in ~src/~) is not accidentally re-evaluated as skill logic.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun load-skill-from-org (filepath)
-  "Parses and evaluates Lisp blocks from an Org file into a jailed package."
-  (let* ((skill-base-name (pathname-name filepath))
-         (entry (or (gethash skill-base-name *skill-catalog*) (make-skill-entry :filename skill-base-name))))
-    (setf (skill-entry-status entry) :loading)
-    (setf (gethash skill-base-name *skill-catalog*) entry)
-    
-    (handler-case
-        (let* ((content (uiop:read-file-string filepath)) 
-               (lines (uiop:split-string content :separator '(#\Newline)))
-               (in-lisp-block nil) 
-               (lisp-code "") 
-               (pkg-name (intern (string-upcase (format nil "OPENCORTEX.SKILLS.~a" skill-base-name)) :keyword)))
-          
-          (dolist (line lines)
-            (let ((clean-line (string-trim '(#\Space #\Tab #\Return) line)))
-              (cond ((uiop:string-prefix-p "#+begin_src lisp" (string-downcase clean-line))
-                     ;; Only load blocks that are NOT tangled to src/ or elsewhere
-                     (if (search ":tangle" (string-downcase clean-line))
-                         (setf in-lisp-block nil)
-                         (setf in-lisp-block t)))
-                    ((uiop:string-prefix-p "#+end_src" (string-downcase clean-line))
-                     (setf in-lisp-block nil))
-                    (in-lisp-block 
-                     (unless (or (uiop:string-prefix-p ":PROPERTIES:" (string-upcase clean-line))
-                                 (uiop:string-prefix-p ":END:" (string-upcase clean-line)))
-                       (setf lisp-code (concatenate 'string lisp-code line (string #\Newline))))))))
-          
-          (if (= (length lisp-code) 0)
-              (progn (setf (skill-entry-status entry) :ready) t) ;; Valid empty skill
-              (progn
-                ;; PRE-FLIGHT: Syntax Validation
-                (multiple-value-bind (valid-p err) (validate-lisp-syntax lisp-code)
-                  (unless valid-p
-                    (error "Syntax Error: ~a" err)))
-                
-                (harness-log "HARNESS: Jailing skill '~a' in package ~a" skill-base-name pkg-name)
-                (unless (find-package pkg-name)
-                  (let ((new-pkg (make-package pkg-name :use '(:cl))))
-                    (do-external-symbols (sym (find-package :opencortex)) (shadowing-import sym new-pkg))))
-                
-                (let ((*read-eval* nil) (*package* (find-package pkg-name)))
-                  (eval (read-from-string (format nil "(progn ~a)" lisp-code))))
-                
-                (setf (skill-entry-status entry) :ready)
-                t)))
-      (error (c)
-        (let ((msg (format nil "~a" c)))
-          (harness-log "LOADER ERROR in skill '~a': ~a" skill-base-name msg)
-          (setf (skill-entry-status entry) :failed)
-          (setf (skill-entry-error-log entry) msg)
-          nil)))))
-#+end_src
-
-** Safe Loading with Timeout (load-skill-with-timeout)
-Wraps the skill loader in a thread with a hard timeout to prevent a single malformed skill from hanging the entire boot sequence.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun load-skill-with-timeout (filepath timeout-seconds)
-  "Loads a skill Org file with a hard execution timeout."
-  (let* ((finished nil)
-         (thread (bt:make-thread (lambda () 
-                                   (if (load-skill-from-org filepath)
-                                       (setf finished t)
-                                       (setf finished :error)))
-                                 :name (format nil "loader-~a" (pathname-name filepath))))
-         (start-time (get-internal-real-time))
-         (timeout-units (truncate (* timeout-seconds internal-time-units-per-second))))
-    (loop 
-      (when (eq finished t) (return :success))
-      (when (eq finished :error) (return :error))
-      (unless (bt:thread-alive-p thread) (return :error))
-      (when (> (- (get-internal-real-time) start-time) timeout-units)
-        (harness-log "HARNESS: Timing out skill ~a..." (pathname-name filepath))
-        #+sbcl (sb-thread:terminate-thread thread)
-        #-sbcl (bt:destroy-thread thread)
-        (return :timeout))
-      (sleep 0.05))))
-#+end_src
-
-** Initializing All Skills (initialize-all-skills)
-The `initialize-all-skills` function is the unified orchestrator for the system boot sequence. It enforces the **Verification Lock**:
-1. **Mandatory Check:** It reads the `MANDATORY_SKILLS` environment variable and ensures every required skill exists in the source directory.
-2. **Topological Boot:** It resolves inter-skill dependencies to ensure policies and actuators are loaded in the correct order.
-3. **Timed Loading:** Every skill is loaded with a 5-second timeout.
-4. **Boot Halt:** If a *mandatory* skill fails to load (e.g., due to a syntax error), the entire system halts with a `BOOT FAILURE` to prevent an unaligned or unsecure state.
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun initialize-all-skills ()
-  "Scans the directory defined by SKILLS_DIR and hot-loads skills using topological order."
-  (let* ((env-path (uiop:getenv "SKILLS_DIR"))
-         (skills-dir-str (or env-path (namestring (merge-pathnames "notes/" (user-homedir-pathname)))))
-         (resolved-path (context-resolve-path skills-dir-str))
-         (skills-dir (if resolved-path (uiop:ensure-directory-pathname resolved-path) nil)))
-    
-    (unless (and skills-dir (uiop:directory-exists-p skills-dir))
-      (harness-log "HARNESS ERROR: Skills directory not found: ~a" skills-dir-str)
-      (return-from initialize-all-skills nil))
-
-    (let ((sorted-files (topological-sort-skills skills-dir)))
-      ;; MANDATE: Configurable mandatory skills must be present for a safe boot
-      (let* ((mandatory-env (uiop:getenv "MANDATORY_SKILLS"))
-             (mandatory-skills (if mandatory-env 
-                                   (mapcar (lambda (s) (string-trim '(#\Space) s)) 
-                                           (uiop:split-string mandatory-env :separator '(#\,)))
-                                   '("org-skill-policy" "org-skill-bouncer"))))
-        (dolist (req mandatory-skills)
-          (unless (member req sorted-files :key #'pathname-name :test #'string-equal)
-            (error "BOOT FAILURE: Mandatory skill '~a' not found in skills directory." req)))
-      
-        (harness-log "==================================================")
-        (harness-log " LOADER: Initializing ~a skills..." (length sorted-files))
-      
-        (dolist (file sorted-files)
-          (let* ((skill-name (pathname-name file))
-                 (is-mandatory (member skill-name mandatory-skills :test #'string-equal)))
-            (harness-log " LOADER: Loading ~a..." skill-name)
-            (let ((status (load-skill-with-timeout file 5)))
-              (unless (eq status :success)
-                (if is-mandatory
-                    (error "BOOT FAILURE: Mandatory skill '~a' failed to load (Status: ~a)." skill-name status)
-                    (harness-log "LOADER WARNING: Skill '~a' failed to load." skill-name))))))
-      
-        ;; Final Summary
-        (let ((ready 0) (failed 0))
-          (maphash (lambda (k v) 
-                     (declare (ignore k))
-                     (if (eq (skill-entry-status v) :ready) (incf ready) (incf failed)))
-                   *skill-catalog*)
-          (harness-log " LOADER: Boot Complete. [Ready: ~a] [Failed: ~a]" ready failed)
-          (harness-log "==================================================")
-          (values ready failed))))))
-#+end_src
-
-** Toolbelt Prompt Generation (generate-tool-belt-prompt)
-Every cognitive tool registered by a skill is automatically documented and injected into the LLM system prompt. This ensures that the agent is always aware of its current physical capabilities.
-
-#+begin_src mermaid
-flowchart LR
-    Registry[(Tool Registry)] --> Generator[Prompt Generator]
-    Generator --> Prompt[Final System Prompt]
-    subgraph Actuators
-        ToolA[Shell]
-        ToolB[Emacs]
-        ToolC[Grep]
-    end
-    ToolA --> Registry
-    ToolB --> Registry
-    ToolC --> Registry
-#+end_src
-
-#+begin_src lisp :tangle ../src/skills.lisp
-(defun generate-tool-belt-prompt ()
-  "Aggregates all registered cognitive tools into a descriptive prompt."
-  (let ((output (format nil "AVAILABLE TOOLS:
-You can call tools by returning a Lisp plist: (:target :tool :action :call :tool <name> :args (...))
-
-EXAMPLES:
-(:target :tool :action :call :tool \"eval\" :args (:code \"(+ 1 1)\"))
-(:target :tool :action :call :tool \"grep-search\" :args (:pattern \"autonomousty\"))
-(:target :tool :action :call :tool \"shell\" :args (:cmd \"ls -la\"))
-
----
-")))
-    (maphash (lambda (name tool)
-               (setf output (concatenate 'string output
-                                         (format nil "- ~a: ~a~%  Parameters: ~s~%~%"
-                                                 name
-                                                 (cognitive-tool-description tool)
-                                                 (cognitive-tool-parameters tool)))))
-             *cognitive-tools*)
-    output))
-#+end_src
-
-** The Default Tool Belt
-The harness provides a baseline set of cognitive tools that enable core system interaction.
-
-*** The Eval Tool (Internal Inspection)
-#+begin_src lisp :tangle ../src/skills.lisp
-(def-cognitive-tool :eval "Evaluates raw Common Lisp code in the harness image. Use this for complex calculations or internal state inspection."
-  ((:code :type :string :description "The Lisp code to evaluate"))
-  :guard (lambda (args context)
-           (declare (ignore context))
-           (let ((code (getf args :code)))
-             (let ((harness-pkg (find-package :opencortex.skills.org-skill-lisp-validator)))
-               (if harness-pkg 
-                   (uiop:symbol-call :opencortex.skills.org-skill-lisp-validator :lisp-validator-validate code)
-                   t))))
-  :body (lambda (args)
-          (let ((code (getf args :code)))
-            (handler-case (let ((result (eval (read-from-string code))))
-                            (format nil "~s" result))
-              (error (c) (format nil "ERROR: ~a" c))))))
-#+end_src
-
-*** The Grep Tool (File Discovery)
-#+begin_src lisp :tangle ../src/skills.lisp
-(def-cognitive-tool :grep-search "Searches for a pattern in the project files."
-  ((:pattern :type :string :description "The regex pattern to search for")
-   (:dir :type :string :description "Directory to search in (default is project root)"))
-  :body (lambda (args)
-          (let ((pattern (getf args :pattern))
-                (dir (or (getf args :dir) (uiop:getenv "MEMEX_DIR"))))
-            (uiop:run-program (list "grep" "-r" "-n" "--exclude-dir=node_modules" pattern dir) 
-                              :output :string :ignore-error-status t))))
-#+end_src
-
-*** The Shell Tool (Machine Actuation)
-#+begin_src lisp :tangle ../src/skills.lisp
-(def-cognitive-tool :shell "Executes a shell command on the local machine. Use this for file operations, system checks, or running tests."
-  ((:cmd :type :string :description "The full bash command to execute"))
-  :guard (lambda (args context)
-           (declare (ignore context))
-           (let ((cmd (getf args :cmd)))
-             (not (or (search "rm -rf /" cmd) (search ":(){ :|:& };:" cmd)))))
-  :body (lambda (args)
-          (let ((cmd (getf args :cmd)))
-            (multiple-value-bind (out err code)
-                (uiop:run-program (list "bash" "-c" cmd) :output :string :error-output :string :ignore-error-status t)
-              (format nil "EXIT-CODE: ~a~%~%STDOUT:~%~a~%~%STDERR:~%~a" code out err)))))
-#+end_src

opencortex.asd

@@ -1,39 +1,38 @@
 (defsystem :opencortex
   :name "opencortex"
-  :author "Amr"
-  :version "0.1.0"
+  :author "Amr Gharbeia"
+  :version "0.2.0"
   :license "AGPLv3"
-  :description "The Probabilistic-Deterministic Lisp Machine Harness"
+  :description "The Probabilistic-Deterministic Lisp Machine"
   :depends-on (:usocket :bordeaux-threads :dexador :uiop :cl-dotenv :cl-ppcre :hunchentoot :ironclad :str :cl-json :uuid)
   :serial t
-  :components ((:file "src/package")
-               (:file "src/skills")
-               (:file "src/policy")
-               (:file "src/communication-validator")
-               (:file "src/communication")
-               (:file "src/memory")
-               (:file "src/context")
-               (:file "src/probabilistic")
-               (:file "src/perceive")
-               (:file "src/reason")
-               (:file "src/act")
-               (:file "src/loop"))
-  :build-operation "program-op"
-  :build-pathname "opencortex-server"
-  :entry-point "opencortex:main")
+  :components ((:file "harness/package")
+               (:file "harness/skills")
+               (:file "harness/communication")
+               (:file "harness/communication-validator")
+               (:file "harness/memory")
+               (:file "harness/context")
+               (:file "harness/perceive")
+               (:file "harness/reason")
+               (:file "harness/act")
+               (:file "harness/doctor")
+               (:file "harness/loop")))
 
 (defsystem :opencortex/tests
   :depends-on (:opencortex :fiveam)
-  :components ((:file "tests/communication-tests")
-               (:file "tests/pipeline-tests")
-               (:file "tests/act-tests")
+  :components ((:file "tests/pipeline-act-tests")
                (:file "tests/boot-sequence-tests")
+               (:file "tests/communication-tests")
+               (:file "tests/immune-system-tests")
                (:file "tests/memory-tests")
-               (:file "tests/immune-system-tests"))
-  :perform (test-op (o s) 
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :communication-protocol-suite :opencortex-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :pipeline-suite :opencortex-pipeline-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :safety-suite :opencortex-safety-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :boot-suite :opencortex-boot-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :memory-suite :opencortex-memory-tests))
-             (uiop:symbol-call :fiveam :run! (uiop:find-symbol* :immune-suite :opencortex-immune-system-tests))))
+               (:file "tests/pipeline-perceive-tests")
+               (:file "tests/pipeline-reason-tests")
+               (:file "tests/peripheral-vision-tests")
+               (:file "tests/tui-tests")
+               (:file "tests/utils-org-tests")
+               (:file "tests/utils-lisp-tests")
+               (:file "tests/llm-gateway-tests")))
+
+(defsystem :opencortex/tui
+  :depends-on (:opencortex :croatoan :usocket :bordeaux-threads)
+  :components ((:file "harness/tui-client")))

opencortex.sh

@@ -2,79 +2,468 @@
 set -e
 
 PORT=9105
-HOST=${1:-localhost}
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-BLUE='\033[0;34m'
-YELLOW='\033[0;33m'
-NC='\033[0m'
+HOST="localhost"
+RED='\033[0;31m'; GREEN='\033[0;32m'; BLUE='\033[0;34m'; YELLOW='\033[0;33m'; NC='\033[0m'
 
 command_exists() { command -v "$1" >/dev/null 2>&1; }
 
-# --- Bootstrap Mode ---
-bootstrap_opencortex() {
-    echo -e "${BLUE}=== OpenCortex: Zero-to-One Bootstrapper ===${NC}"
-    if [ -d ".git" ]; then
-        echo "Detected existing repository. Switching to local mode..."
-        return
+# --- XDG PATH RESOLUTION ---
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do
+    DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+    SOURCE="$(readlink "$SOURCE")"
+    [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
+done
+export SCRIPT_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+export OC_CONFIG_DIR="$(realpath -m "${XDG_CONFIG_HOME:-$HOME/.config}/opencortex")"
+export OC_DATA_DIR="$(realpath -m "${XDG_DATA_HOME:-$HOME/.local/share}/opencortex")"
+export OC_STATE_DIR="$(realpath -m "${XDG_STATE_HOME:-$HOME/.local/state}/opencortex")"
+export OC_BIN_DIR="$(realpath -m "${XDG_BIN_HOME:-$HOME/.local/bin}")"
+export MEMEX_DIR="${MEMEX_DIR:-$HOME/memex}"
+
+if [ -f "$OC_CONFIG_DIR/.env" ]; then
+    set -a; source "$OC_CONFIG_DIR/.env"; set +a
+fi
+
+# --- DISTRO DETECTION ---
+detect_distro() {
+    if [ -f /etc/os-release ]; then
+        . /etc/os-release
+        case "$ID" in
+            debian|ubuntu|linuxmint|pop|elementary|zorin) echo "debian" ;;
+            fedora|rhel|centos|rocky|almalinux) echo "fedora" ;;
+            *) echo "unknown" ;;
+        esac
+    elif command_exists apt-get; then echo "debian"
+    elif command_exists dnf; then echo "fedora"
+    else echo "unknown"; fi
+}
+
+distro_install() {
+    local distro=$(detect_distro); shift
+    case "$distro" in
+        debian) sudo apt-get update && sudo apt-get install -y "$@" ;;
+        fedora) sudo dnf install -y "$@" ;;
+        *) echo "Unsupported distro. Install manually: sbcl emacs git curl socat"; return 1 ;;
+    esac
+}
+
+# --- DEPENDENCY CHECK ---
+check_dependencies() {
+    local missing=()
+    for dep in sbcl git curl socat nc; do
+        if ! command_exists "$dep"; then missing+=("$dep"); fi
+    done
+    if ! command_exists emacs; then missing+=("emacs-nox"); fi
+    if [ ${#missing[@]} -gt 0 ]; then
+        echo -e "${YELLOW}--- Installing missing dependencies: ${missing[*]} ---${NC}"
+        local distro=$(detect_distro)
+        case "$distro" in
+            debian)
+                distro_install "${missing[@]}" libssl-dev libncurses-dev libffi-dev zlib1g-dev libsqlite3-dev 2>/dev/null || true
+                if ! command_exists rlwrap; then distro_install rlwrap 2>/dev/null || true; fi
+                if ! command_exists nc; then distro_install netcat-openbsd 2>/dev/null || true; fi
+                ;;
+            fedora)
+                distro_install "${missing[@]}" openssl-devel ncurses-devel libffi-devel zlib-devel sqlite-devel 2>/dev/null || true
+                if ! command_exists rlwrap; then distro_install rlwrap 2>/dev/null || true; fi
+                if ! command_exists nc; then distro_install nmap-ncat 2>/dev/null || true; fi
+                ;;
+        esac
+    fi
+}
+
+# --- SETUP ---
+setup_system() {
+    NON_INTERACTIVE=false; WITH_FIREWALL=false
+    for arg in "$@"; do
+        case "$arg" in
+            --non-interactive) NON_INTERACTIVE=true ;;
+            --with-firewall) WITH_FIREWALL=true ;;
+        esac
+    done
+
+    echo -e "${BLUE}=== OpenCortex: Configure ===${NC}"
+    mkdir -p "$OC_CONFIG_DIR" "$OC_DATA_DIR" "$OC_STATE_DIR" "$OC_BIN_DIR"
+    mkdir -p "$OC_DATA_DIR/harness" "$OC_DATA_DIR/tests" "$OC_DATA_DIR/skills"
+
+    check_dependencies
+
+    if [ ! -d "$HOME/quicklisp" ]; then
+        echo -e "${YELLOW}--- Installing Quicklisp ---${NC}"
+        curl -O https://beta.quicklisp.org/quicklisp.lisp
+        sbcl --non-interactive --load quicklisp.lisp \
+             --eval "(quicklisp-quickstart:install)" \
+             --eval "(ql-util:without-prompting (ql:add-to-init-file))"
+        rm quicklisp.lisp
     fi
 
-    TARGET_DIR="opencortex"
-    if [ -d "$TARGET_DIR" ]; then
-        if [ -d "$TARGET_DIR/.git" ]; then
-            echo -e "${YELLOW}! Using existing repository in '$TARGET_DIR'...${NC}"
-        else
-            echo -e "${RED}! Directory '$TARGET_DIR' exists. Using it as-is...${NC}"
+    echo -e "${YELLOW}--- Deploying Engine to $OC_DATA_DIR ---${NC}"
+    cp "$SCRIPT_DIR/opencortex.asd" "$OC_DATA_DIR/"
+    mkdir -p "$OC_DATA_DIR/harness" "$OC_DATA_DIR/tests" "$OC_DATA_DIR/skills"
+    export INSTALL_DIR="$OC_DATA_DIR"
+
+    cp "$SCRIPT_DIR/harness"/*.org "$OC_DATA_DIR/harness/"
+    (cd "$OC_DATA_DIR/harness" && emacs -Q --batch \
+        --eval "(require 'org)" \
+        --eval "(setq org-confirm-babel-evaluate nil)" \
+        --eval "(org-babel-tangle-file \"manifest.org\")") >/dev/null 2>&1 || true
+    for f in "$OC_DATA_DIR/harness"/*.org; do
+        fname=$(basename "$f" .org)
+        [ "$fname" = "manifest" ] && continue
+        echo "Tangling harness/$fname.org..."
+        (cd "$OC_DATA_DIR/harness" && emacs -Q --batch \
+            --eval "(require 'org)" \
+            --eval "(setq org-confirm-babel-evaluate nil)" \
+            --eval "(org-babel-tangle-file \"${fname}.org\")") >/dev/null 2>&1 || true
+    done
+    find "$OC_DATA_DIR/harness" -name "*-tests.lisp" -exec mv {} "$OC_DATA_DIR/tests/" \; 2>/dev/null || true
+    rm -f "$OC_DATA_DIR/harness"/*.org
+
+    for f in "$SCRIPT_DIR/skills"/*.org; do
+        fname=$(basename "$f" .org)
+        echo "Tangling skills/$fname.org..."
+        cp "$f" "$OC_DATA_DIR/skills/"
+        (cd "$OC_DATA_DIR/skills" && emacs -Q --batch \
+            --eval "(require 'org)" \
+            --eval "(setq org-confirm-babel-evaluate nil)" \
+            --eval "(org-babel-tangle-file \"${fname}.org\")") >/dev/null 2>&1 || true
+        rm -f "$OC_DATA_DIR/skills/$fname.org"
+    done
+    find "$OC_DATA_DIR/skills" -name "*-tests.lisp" -exec mv {} "$OC_DATA_DIR/tests/" \; 2>/dev/null || true
+    [ -f "$OC_DATA_DIR/run-all-tests.lisp" ] && mv "$OC_DATA_DIR/run-all-tests.lisp" "$OC_DATA_DIR/harness/"
+    rm -f "$OC_DATA_DIR/harness"/*.org "$OC_DATA_DIR/skills"/*.org
+
+    ln -sf "$SCRIPT_DIR/opencortex.sh" "$OC_BIN_DIR/opencortex"
+
+    if [ "$WITH_FIREWALL" = true ]; then
+        case $(detect_distro) in
+            debian) sudo ufw allow 9105/tcp 2>/dev/null && echo "✓ UFW: port 9105 opened" || true ;;
+            fedora) sudo firewall-cmd --add-port=9105/tcp --permanent 2>/dev/null && sudo firewall-cmd --reload 2>/dev/null && echo "✓ firewalld: port 9105 opened" || true ;;
+        esac
+    fi
+
+    if [ "$NON_INTERACTIVE" = true ]; then
+        echo "Configure complete."
+        exit 0
+    fi
+
+    echo -e "${YELLOW}--- Launching Setup Wizard ---${NC}"
+    exec sbcl --non-interactive \
+        --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+        --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+        --eval '(ql:quickload :opencortex)' \
+        --eval '(opencortex:initialize-all-skills)' \
+        --eval '(funcall (find-symbol "RUN-SETUP-WIZARD" :opencortex))'
+}
+
+# --- DOCTOR REPAIR ---
+doctor_repair() {
+    echo -e "${BLUE}=== OpenCortex: Repair Mode ===${NC}"
+    check_dependencies
+    mkdir -p "$OC_CONFIG_DIR" "$OC_DATA_DIR" "$OC_STATE_DIR" "$OC_BIN_DIR"
+    mkdir -p "$OC_DATA_DIR/harness" "$OC_DATA_DIR/tests" "$OC_DATA_DIR/skills"
+    for f in "$SCRIPT_DIR/harness"/*.org; do
+        [ -f "$f" ] || continue
+        fname=$(basename "$f" .org)
+        echo "  Checking harness/$fname..."
+        if ! sbcl --non-interactive \
+            --eval "(load \"$OC_DATA_DIR/harness/${fname}.lisp\")" \
+            --eval "(format t \"OK~%\")" 2>/dev/null | grep -q "OK"; then
+            echo "    Re-tangling $fname.org..."
+            (cd "$OC_DATA_DIR/harness" && emacs -Q --batch \
+                --eval "(require 'org)" \
+                --eval "(setq org-confirm-babel-evaluate nil)" \
+                --eval "(org-babel-tangle-file \"$f\")") >/dev/null 2>&1 || true
         fi
-    else
-        echo -e "${BLUE}Cloning repository into $TARGET_DIR...${NC}"
-        git clone http://10.10.10.201:3001/amr/opencortex.git "$TARGET_DIR"
-    fi
-    
-    cd "$TARGET_DIR"
-    git submodule update --init --recursive
-    
-    echo -e "${GREEN}✓ Repository prepared. Handing off to local setup...${NC}"
-    # Reconnect stdin to the TTY for the next script, or use /dev/null to avoid hang
-    if [ -t 0 ]; then
-        exec ./scripts/onboard-baremetal.sh
-    else
-        exec ./scripts/onboard-baremetal.sh < /dev/tty 2>/dev/null || exec ./scripts/onboard-baremetal.sh < /dev/null
-    fi
+    done
+    for f in "$SCRIPT_DIR/skills"/*.org; do
+        [ -f "$f" ] || continue
+        fname=$(basename "$f" .org)
+        echo "  Checking skill/$fname..."
+        if ! sbcl --non-interactive \
+            --eval "(load \"$OC_DATA_DIR/skills/${fname}.lisp\")" \
+            --eval "(format t \"OK~%\")" 2>/dev/null | grep -q "OK"; then
+            echo "    Re-tangling $fname.org..."
+            cp "$f" "$OC_DATA_DIR/skills/"
+            (cd "$OC_DATA_DIR/skills" && emacs -Q --batch \
+                --eval "(require 'org)" \
+                --eval "(setq org-confirm-babel-evaluate nil)" \
+                --eval "(org-babel-tangle-file \"${fname}.org\")") >/dev/null 2>&1 || true
+            rm -f "$OC_DATA_DIR/skills/$fname.org"
+        fi
+    done
+    rm -f "$OC_DATA_DIR/harness"/*.org "$OC_DATA_DIR/skills"/*.org 2>/dev/null || true
+    echo -e "${GREEN}--- Repair Complete ---${NC}"
 }
 
-if [ ! -d ".git" ]; then
-    bootstrap_opencortex
-fi
-
-update_opencortex() {
-    echo -e "${BLUE}Updating OpenCortex...${NC}"
-    if [ -d ".git" ]; then
-        git pull origin main
+# --- INSTALL SKILL ---
+install_skill() {
+    local SKILL_NAME=$1
+    if [ -z "$SKILL_NAME" ]; then
+        echo "Usage: opencortex install skill <skill-name>"
+        echo "  Installs a skill from opencortex-contrib"
+        echo ""
+        echo "Available skills:"
+        if [ -d "$MEMEX_DIR/projects/opencortex-contrib/skills" ]; then
+            ls "$MEMEX_DIR/projects/opencortex-contrib/skills"/*.org 2>/dev/null | xargs -I{} basename {} .org | sed 's/org-skill-//' | sort | uniq
+        else
+            echo "  (clone opencortex-contrib to ~/memex/projects/ first)"
+        fi
+        exit 1
     fi
-    echo -e "${GREEN}✓ Update complete.${NC}"
-    exit 0
+    local SKILL_FILE="org-skill-${SKILL_NAME}.org"
+    local SOURCE_DIR="$MEMEX_DIR/projects/opencortex-contrib/skills"
+    local TARGET_DIR="$OC_DATA_DIR/skills"
+    if [ ! -d "$SOURCE_DIR" ]; then
+        echo "Error: Contrib skills not found at $SOURCE_DIR"
+        echo "Run: git clone https://github.com/amrgharbeia/opencortex-contrib.git \$MEMEX_DIR/projects/opencortex-contrib"
+        exit 1
+    fi
+    if [ ! -f "$SOURCE_DIR/$SKILL_FILE" ]; then
+        echo "Error: Skill '$SKILL_NAME' not found"
+        exit 1
+    fi
+    mkdir -p "$TARGET_DIR"
+    cp "$SOURCE_DIR/$SKILL_FILE" "$TARGET_DIR/"
+    (cd "$TARGET_DIR" && emacs -Q --batch \
+        --eval "(require 'org)" \
+        --eval "(setq org-confirm-babel-evaluate nil)" \
+        --eval "(org-babel-tangle-file \"$SKILL_FILE\")") >/dev/null 2>&1 || true
+    rm -f "$TARGET_DIR/$SKILL_FILE"
+    if [ -f "$TARGET_DIR/${SKILL_NAME}-tests.lisp" ]; then
+        mv "$TARGET_DIR/${SKILL_NAME}-tests.lisp" "$OC_DATA_DIR/tests/" 2>/dev/null || true
+    fi
+    echo "Skill '$SKILL_NAME' installed. Restart to activate."
 }
 
-if [[ "$1" == "--update" ]]; then update_opencortex; fi
+# --- INSTALL SERVICE ---
+install_service() {
+    mkdir -p "$HOME/.config/systemd/user"
+    cat > "$HOME/.config/systemd/user/opencortex.service" << 'SERVICEEOF'
+[Unit]
+Description=OpenCortex Daemon
+After=network.target
 
-# 1. Try to drop straight into the CLI chat
-if command_exists socat && socat - TCP:$HOST:$PORT,connect-timeout=1 2>/dev/null; then
-    echo -e "${BLUE}Connected to autonomous brain at $HOST:$PORT...${NC}"
-    socat READLINE,history=$HOME/.org_agent_history TCP:$HOST:$PORT
-    exit 0
-fi
+[Service]
+Type=simple
+ExecStart=%h/projects/opencortex/opencortex.sh daemon
+Restart=on-failure
+RestartSec=10
+WorkingDirectory=%h/projects/opencortex
 
-# 2. Local repository detection and launch
-if [ -f "opencortex.asd" ] || [ -d "literate" ]; then
-    if [ ! -f .env ]; then
-        ./scripts/onboard-baremetal.sh
+[Install]
+WantedBy=default.target
+SERVICEEOF
+    systemctl --user daemon-reload
+    systemctl --user enable opencortex.service
+    systemctl --user start opencortex.service
+    echo -e "${GREEN}✓ opencortex.service installed and started${NC}"
+    echo "  Status: systemctl --user status opencortex.service"
+    echo "  Logs:   journalctl --user -u opencortex.service -f"
+}
+
+uninstall_service() {
+    systemctl --user stop opencortex.service 2>/dev/null || true
+    systemctl --user disable opencortex.service 2>/dev/null || true
+    rm -f "$HOME/.config/systemd/user/opencortex.service"
+    systemctl --user daemon-reload
+    echo -e "${GREEN}✓ opencortex.service removed${NC}"
+}
+
+# --- BACKUP ---
+backup() {
+    local dest="${1:-$HOME/opencortex-backup-$(date +%Y%m%d-%H%M%S).tar.gz}"
+    if [ -f "$dest" ]; then echo "Error: $dest exists"; exit 1; fi
+    echo "Backing up to $dest..."
+    tar -czf "$dest" \
+        "$OC_CONFIG_DIR" "$OC_DATA_DIR" \
+        "$MEMEX_DIR/gtd.org" "$MEMEX_DIR/projects/opencortex" \
+        2>/dev/null || true
+    echo -e "${GREEN}✓ Backed up to $dest${NC}"
+}
+
+restore() {
+    local src="$1"
+    if [ -z "$src" ] || [ ! -f "$src" ]; then
+        echo "Usage: opencortex restore <backup-file>"
+        exit 1
     fi
-    
-    echo -e "${BLUE}Starting OpenCortex via SBCL...${NC}"
-    sbcl --non-interactive \
-         --eval "(load \"~/quicklisp/setup.lisp\")" \
-         --eval "(ql:quickload :opencortex)" \
-         --eval "(opencortex:main)"
-fi
+    echo "Restoring from $src..."
+    tar -xzf "$src" -C /
+    echo -e "${GREEN}✓ Restored. Run 'opencortex doctor' to verify.${NC}"
+}
+
+# --- HELP ---
+help() {
+    echo ""
+    echo "OpenCortex — Your Autonomous, Plain-Text Life Assistant"
+    echo ""
+    echo "Usage: opencortex.sh <command> [options]"
+    echo ""
+    echo "System:"
+    echo "  configure [--non-interactive] [--with-firewall]    Install or reconfigure the system"
+    echo "  setup                                               Alias for configure"
+    echo "  doctor [--fix] [--watch]                            System health check"
+    echo ""
+    echo "Running:"
+    echo "  daemon                                              Start background daemon"
+    echo "  tui                                                 Launch terminal UI"
+    echo "  gateway {link|unlink|list} <platform> <token>       Manage chat gateways"
+    echo ""
+    echo "Skills:"
+    echo "  install skill <name>                                Install a skill from contrib"
+    echo "  install service                                     Install systemd service (auto-start)"
+    echo "  uninstall service                                   Remove systemd service"
+    echo ""
+    echo "Data:"
+    echo "  backup [path]                                       Backup config, data, memex"
+    echo "  restore <path>                                      Restore from a backup"
+    echo ""
+    echo "Quick start:"
+    echo "  curl -fsSL https://raw.githubusercontent.com/amrgharbeia/opencortex/main/opencortex.sh | bash -s configure"
+    echo ""
+}
+
+# --- COMMAND ROUTER ---
+COMMAND=$1; [ -z "$COMMAND" ] && COMMAND="help"
+shift || true
+
+case "$COMMAND" in
+    configure|setup)
+        check_dependencies
+        if [ "$1" = "--add-provider" ]; then
+            sbcl --non-interactive \
+                --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+                --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+                --eval '(ql:quickload :opencortex)' \
+                --eval '(opencortex:initialize-all-skills)' \
+                --eval '(funcall (find-symbol "SETUP-ADD-PROVIDER" :opencortex))'
+        elif [ "$1" = "--link" ]; then
+            exec "$0" gateway link "$2" "$3"
+        else
+            setup_system "$@"
+        fi
+        ;;
+    doctor)
+        check_dependencies
+        if [ "$1" = "--watch" ]; then
+            while true; do
+                echo "--- $(date '+%Y-%m-%d %H:%M:%S') ---"
+                sbcl --non-interactive \
+                    --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+                    --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+                    --eval '(ql:quickload :opencortex)' \
+                    --eval '(opencortex:initialize-all-skills)' \
+                    --eval '(funcall (find-symbol "DOCTOR-RUN-ALL" :opencortex))' 2>&1 | grep -E "(HEALTH|OK|FAIL|WARN|SYSTEM|===)" || true
+                sleep 60
+            done
+        elif [ "$1" = "--fix" ]; then
+            if [ ! -f "$OC_DATA_DIR/harness/package.lisp" ] || [ ! -f "$OC_DATA_DIR/harness/skills.lisp" ]; then
+                setup_system "$@"
+            else
+                doctor_repair
+            fi
+        else
+            exec sbcl --non-interactive \
+                --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+                --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+                --eval '(ql:quickload :opencortex)' \
+                --eval '(opencortex:initialize-all-skills)' \
+                --eval '(funcall (find-symbol "DOCTOR-MAIN" :opencortex))'
+        fi
+        ;;
+    daemon)
+        check_dependencies
+        echo "Starting daemon in background..."
+        nohup sbcl --non-interactive \
+            --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+            --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+            --eval "(ql:quickload '(:opencortex :croatoan))" \
+            --eval '(opencortex:main)' \
+            > "$OC_STATE_DIR/daemon.log" 2>&1 &
+        echo "Waiting for port 9105..."
+        for i in $(seq 1 20); do
+            if ss -tln 2>/dev/null | grep -q 9105 || netstat -tln 2>/dev/null | grep -q 9105; then
+                echo "✓ Daemon ready on port 9105"; exit 0
+            fi
+            sleep 1
+        done
+        echo "✗ Daemon failed to start. Check $OC_STATE_DIR/daemon.log"; exit 1
+        ;;
+    tui)
+        check_dependencies
+        if ! ss -tln 2>/dev/null | grep -q 9105 && ! netstat -tln 2>/dev/null | grep -q 9105; then
+            echo "Starting daemon first..."
+            $0 daemon
+        fi
+        sbcl \
+            --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+            --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+            --eval '(ql:quickload :opencortex/tui)' \
+            --eval '(opencortex.tui:main)' || {
+            echo "TUI error. Run 'opencortex doctor --fix'"; exit 1
+        }
+        ;;
+    gateway)
+        SUBCMD=$1; PLATFORM=$2; TOKEN=$3
+        check_dependencies
+        case "$SUBCMD" in
+            list)
+                exec sbcl --non-interactive \
+                    --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+                    --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+                    --eval '(ql:quickload :opencortex)' \
+                    --eval '(opencortex:initialize-all-skills)' \
+                    --eval '(funcall (find-symbol "GATEWAY-LIST-PRINT" (find-package "OPENCORTEX.SKILLS.ORG-SKILL-GATEWAY-MANAGER")))'
+                ;;
+            link)
+                [ -z "$PLATFORM" ] || [ -z "$TOKEN" ] && echo "Usage: opencortex gateway link <platform> <token>" && exit 1
+                exec sbcl --non-interactive \
+                    --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+                    --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+                    --eval '(ql:quickload :opencortex)' \
+                    --eval '(opencortex:initialize-all-skills)' \
+                    --eval "(funcall (find-symbol \"GATEWAY-LINK\" (find-package \"OPENCORTEX.SKILLS.ORG-SKILL-GATEWAY-MANAGER\")) \"$PLATFORM\" \"$TOKEN\")"
+                ;;
+            unlink)
+                [ -z "$PLATFORM" ] && echo "Usage: opencortex gateway unlink <platform>" && exit 1
+                exec sbcl --non-interactive \
+                    --eval '(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))' \
+                    --eval "(push (truename \"$OC_DATA_DIR/\") asdf:*central-registry*)" \
+                    --eval '(ql:quickload :opencortex)' \
+                    --eval '(opencortex:initialize-all-skills)' \
+                    --eval "(funcall (find-symbol \"GATEWAY-UNLINK\" (find-package \"OPENCORTEX.SKILLS.ORG-SKILL-GATEWAY-MANAGER\")) \"$PLATFORM\")"
+                ;;
+            *) echo "Usage: opencortex gateway {list|link|unlink}"; exit 1 ;;
+        esac
+        ;;
+    install)
+        case "$1" in
+            skill) shift; install_skill "$@" ;;
+            service) install_service ;;
+            *) echo "Usage: opencortex install {skill|service}" >&2; exit 1 ;;
+        esac
+        ;;
+    uninstall)
+        case "$1" in
+            service) uninstall_service ;;
+            *) echo "Usage: opencortex uninstall {service}" >&2; exit 1 ;;
+        esac
+        ;;
+    backup)
+        backup "$1"
+        ;;
+    restore)
+        restore "$1"
+        ;;
+    help|--help|-h)
+        help
+        ;;
+    *)
+        echo "Unknown command: $COMMAND"
+        help
+        exit 1
+        ;;
+esac

run-tests.lisp

@@ -0,0 +1,35 @@
+(load (merge-pathnames "quicklisp/setup.lisp" (user-homedir-pathname)))
+
+(let ((oc-dir (or (uiop:getenv "OC_DATA_DIR")
+                  (namestring (truename "./")))))
+  (push (uiop:ensure-directory-pathname oc-dir) asdf:*central-registry*)
+  (setf (uiop:getenv "OC_DATA_DIR") oc-dir))
+
+(ql:quickload '(:fiveam :opencortex :opencortex/tui :opencortex/tests) :silent t)
+
+(format t "~%=== Initializing Skills BEFORE running tests ===~%")
+(opencortex:initialize-all-skills)
+
+(format t "~%=== Running ALL Test Suites ===~%")
+
+(dolist (suite-spec '(("OPENCORTEX-BOOT-TESTS" "BOOT-SUITE")
+                      ("OPENCORTEX-COMMUNICATION-TESTS" "COMMUNICATION-PROTOCOL-SUITE")
+                      ("OPENCORTEX-DOCTOR-TESTS" "DOCTOR-SUITE")
+                      ("OPENCORTEX-IMMUNE-SYSTEM-TESTS" "IMMUNE-SUITE")
+                      ("OPENCORTEX-LLM-GATEWAY-TESTS" "LLM-GATEWAY-SUITE")
+                      ("OPENCORTEX-MEMORY-TESTS" "MEMORY-SUITE")
+                      ("OPENCORTEX-PERIPHERAL-VISION-TESTS" "VISION-SUITE")
+                      ("OPENCORTEX-PIPELINE-ACT-TESTS" "PIPELINE-ACT-SUITE")
+                      ("OPENCORTEX-PIPELINE-PERCEIVE-TESTS" "PIPELINE-PERCEIVE-SUITE")
+                      ("OPENCORTEX-PIPELINE-REASON-TESTS" "PIPELINE-REASON-SUITE")
+                      ("OPENCORTEX-TUI-TESTS" "TUI-SUITE")
+                      ("OPENCORTEX-UTILS-LISP-TESTS" "UTILS-LISP-SUITE")
+                      ("OPENCORTEX-UTILS-ORG-TESTS" "UTILS-ORG-SUITE")))
+  (let ((pkg (find-package (first suite-spec))))
+    (when pkg
+      (let ((suite-sym (find-symbol (second suite-spec) pkg)))
+        (when suite-sym
+          (format t "~&--- Suite: ~A ---~%" (first suite-spec))
+          (fiveam:run! suite-sym))))))
+
+(format t "~%=== ALL TESTS COMPLETE ===~%")

scripts/browser-bridge.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import json
-import base64
-from playwright.sync_api import sync_playwright
-
-def run_bridge():
-    # Read command from stdin
-    try:
-        raw_input = sys.stdin.read()
-        if not raw_input:
-            print(json.dumps({"status": "error", "message": "No input provided"}))
-            return
-        
-        args = json.loads(raw_input)
-    except Exception as e:
-        print(json.dumps({"status": "error", "message": f"Invalid JSON input: {str(e)}"}))
-        return
-
-    url = args.get("url")
-    action = args.get("action", "extract_text")
-    selector = args.get("selector", "body")
-
-    if not url:
-        print(json.dumps({"status": "error", "message": "No URL provided"}))
-        return
-
-    try:
-        with sync_playwright() as p:
-            browser = p.chromium.launch(headless=True)
-            page = browser.new_page()
-            
-            # Navigate and wait for network to be idle
-            page.goto(url, wait_until="networkidle")
-
-            result = {"status": "success", "url": url}
-
-            if action == "extract_text":
-                result["content"] = page.inner_text(selector)
-            elif action == "screenshot":
-                screenshot_bytes = page.screenshot()
-                result["screenshot_base64"] = base64.b64encode(screenshot_bytes).decode("utf-8")
-            else:
-                result["status"] = "error"
-                result["message"] = f"Unknown action: {action}"
-
-            browser.close()
-            print(json.dumps(result))
-
-    except Exception as e:
-        print(json.dumps({"status": "error", "message": f"Playwright Error: {str(e)}"}))
-
-if __name__ == "__main__":
-    run_bridge()

scripts/onboard-baremetal.sh

@@ -1,112 +0,0 @@
-#!/bin/bash
-# OpenCortex Final-Mile Installer
-RED='\033[0;31m'; GREEN='\033[0;32m'; BLUE='\033[0;34m'; YELLOW='\033[0;33m'; NC='\033[0m'
-
-echo -e "${BLUE}=== OpenCortex: Baremetal Power-User Setup ===${NC}"
-
-# Robust Non-Blocking Prompt
-prompt_user() {
-    local prompt="$1"
-    local default="$2"
-    local var_name="$3"
-    local result=""
-    
-    echo -n -e "${YELLOW}$prompt (default: $default): ${NC}" >&2
-    
-    # Try reading with a short timeout. Use defaults if piped/no-tty.
-    if read -t 5 result; then
-        :
-    else
-        result="$default"
-        echo -e "${BLUE} [Auto-Selected: $default]${NC}" >&2
-    fi
-    
-    val=${result:-$default}
-    eval "$var_name=\"$val\""
-}
-
-# 1. Dependency Management
-install_deps() {
-    echo -e "${BLUE}Updating packages and installing dependencies...${NC}"
-    if command -v apt-get >/dev/null; then
-        sudo apt-get update && sudo apt-get install -y sbcl emacs git curl socat
-    elif command -v pacman >/dev/null; then
-        sudo pacman -S --noconfirm sbcl emacs git curl socat
-    else
-        echo -e "${RED}✗ Unknown package manager. Please install dependencies manually.${NC}"
-    fi
-}
-
-if ! command -v sbcl >/dev/null 2>&1 || ! command -v emacs >/dev/null 2>&1; then
-    echo -e "${YELLOW}! Missing dependencies (SBCL/Emacs).${NC}"
-    prompt_user "Should I attempt to install them for you? [Y/n]" "y" "DO_INSTALL"
-    if [[ "$DO_INSTALL" =~ ^[Yy]$ ]]; then
-        install_deps
-    fi
-fi
-
-# 2. Quicklisp Installation
-if [ ! -d "$HOME/quicklisp" ] && [ ! -d "$HOME/.quicklisp" ]; then
-    echo -e "${YELLOW}! Quicklisp not found.${NC}"
-    prompt_user "Install Quicklisp now? [Y/n]" "y" "DO_QL"
-    if [[ "$DO_QL" =~ ^[Yy]$ ]]; then
-        curl -O https://beta.quicklisp.org/quicklisp.lisp
-        sbcl --non-interactive --load quicklisp.lisp \
-             --eval "(quicklisp-quickstart:install)" \
-             --eval "(ql-util:without-prompting (ql:add-to-init-file))"
-        rm quicklisp.lisp
-        echo -e "${GREEN}✓ Quicklisp installed.${NC}"
-    fi
-fi
-
-# 3. Literate Tangling (The Transparent Version)
-echo -e "${BLUE}Tangling Literate Org files into source code...${NC}"
-mkdir -p src
-for f in literate/*.org; do
-    echo -e "  - Tangling $f..."
-    emacs --batch --eval "(require 'org)" --eval "(org-babel-tangle-file \"$f\")" >/dev/null 2>&1 || echo -e "${RED}    ! Warning: Tangle issue in $f${NC}"
-done
-
-if [ ! -f "src/package.lisp" ]; then
-    echo -e "${RED}✗ Tangling failed. Essential files missing in src/.${NC}"
-    exit 1
-fi
-echo -e "${GREEN}✓ Core tangled successfully.${NC}"
-
-# 4. Environment Configuration
-echo -e "\n${BLUE}Configuring your environment...${NC}"
-if [ ! -f .env ]; then cp .env.example .env; fi
-
-prompt_user "What is your name?" "User" "USER_NAME"
-sed -i "s/MEMEX_USER=.*/MEMEX_USER=\"$USER_NAME\"/g" .env
-
-prompt_user "What shall we name your Assistant?" "OpenCortex" "AGENT_NAME"
-sed -i "s/MEMEX_ASSISTANT=.*/MEMEX_ASSISTANT=\"$AGENT_NAME\"/g" .env
-
-echo -e "\nSelect neural provider (1:Gemini, 2:OpenRouter, 3:Anthropic, 4:OpenAI)"
-prompt_user "Choice" "1" "LLM_CHOICE"
-
-case $LLM_CHOICE in
-    2) prompt_user "Enter OpenRouter Key" "" "INPUT"; sed -i "s/OPENROUTER_API_KEY=.*/OPENROUTER_API_KEY=\"$INPUT\"/g" .env ;;
-    3) prompt_user "Enter Anthropic Key" "" "INPUT"; sed -i "s/ANTHROPIC_API_KEY=.*/ANTHROPIC_API_KEY=\"$INPUT\"/g" .env ;;
-    4) prompt_user "Enter OpenAI Key" "" "INPUT"; sed -i "s/OPENAI_API_KEY=.*/OPENAI_API_KEY=\"$INPUT\"/g" .env ;;
-    *) prompt_user "Enter Gemini Key" "" "INPUT"; sed -i "s/GEMINI_API_KEY=.*/GEMINI_API_KEY=\"$INPUT\"/g" .env ;;
-esac
-
-# 5. Path Alignment
-PROJECT_ROOT=$(pwd)
-PARENT_DIR=$(dirname "$PROJECT_ROOT")
-sed -i "s|MEMEX_DIR=.*|MEMEX_DIR=\"$PARENT_DIR\"|g" .env
-sed -i "s|ZETTELKASTEN_DIR=.*|ZETTELKASTEN_DIR=\"$PARENT_DIR/notes\"|g" .env
-sed -i "s|SKILLS_DIR=.*|SKILLS_DIR=\"$PROJECT_ROOT/skills\"|g" .env
-
-mkdir -p "$PARENT_DIR/notes"
-echo -e "${GREEN}✓ Configuration complete.${NC}"
-
-# 6. Final Instructions
-echo -e "\n${GREEN}==============================================${NC}"
-echo -e "${GREEN}    OpenCortex Installation Complete!        ${NC}"
-echo -e "${GREEN}==============================================${NC}"
-echo -e "Your brain is ready to boot."
-echo -e "\nTo start the session: ${YELLOW}./opencortex.sh${NC}"
-echo -e "To add API keys later, edit: ${YELLOW}$(pwd)/.env${NC}\n"

scripts/opencortex-chat.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-# opencortex-chat: The terminal mouthpiece for the Autonomous Brain.
-PORT=9105
-HOST=${1:-localhost}
-
-# Check for socat (preferred)
-if command -v socat >/dev/null 2>&1; then
-    # Use socat with READLINE for history and arrow-key support.
-    # It establishes a persistent bidirectional connection.
-    socat READLINE,history=$HOME/.org_agent_history TCP:$HOST:$PORT
-else
-    # Fallback to nc (netcat) for a single-shot connection if socat is missing.
-    # Note: This is less robust for agents with long-thinking times.
-    echo "WARNING: socat not found. Falling back to nc (no line-editing support)."
-    while true; do
-        read -p "User: " MESSAGE
-        if [ -z "$MESSAGE" ]; then continue; fi
-        echo "$MESSAGE" | nc -N $HOST $PORT
-    done
-fi

scripts/org-agent-chat.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-# opencortex-chat: The terminal mouthpiece for the Autonomous Brain.
-PORT=9105
-HOST=${1:-localhost}
-
-# Check for socat (preferred)
-if command -v socat >/dev/null 2>&1; then
-    # Use socat with READLINE for history and arrow-key support.
-    # It establishes a persistent bidirectional connection.
-    socat READLINE,history=$HOME/.org_agent_history TCP:$HOST:$PORT
-else
-    # Fallback to nc (netcat) for a single-shot connection if socat is missing.
-    # Note: This is less robust for agents with long-thinking times.
-    echo "WARNING: socat not found. Falling back to nc (no line-editing support)."
-    while true; do
-        read -p "User: " MESSAGE
-        if [ -z "$MESSAGE" ]; then continue; fi
-        echo "$MESSAGE" | nc -N $HOST $PORT
-    done
-fi

skills/org-skill-bouncer.org

@@ -1,29 +1,131 @@
-:PROPERTIES:
-:ID:       bouncer-agent-skill
-:CREATED:  [2026-04-11 Sat 15:20]
-:EDITED:   [2026-04-13 Mon 18:35]
-:END:
-#+TITLE: SKILL: Deterministic Engine Bouncer (Authorization Gate)
-#+STARTUP: content
+#+TITLE: SKILL: Bouncer (org-skill-bouncer.org)
+#+AUTHOR: Agent
 #+FILETAGS: :system:bouncer:authorization:autonomy:
+#+PROPERTY: header-args:lisp :tangle org-skill-bouncer.lisp
 
 * Overview
-The *Deterministic Engine Bouncer* is the authorization gate for high-risk actions. It serializes intercepted actions into Org nodes ("Flight Plans") and re-injects them once manually approved by the Autonomous.
+The *Bouncer Skill* is the physical security layer of OpenCortex. It enforces operational security checks on all proposed actions.
 
-* Package Context
+* Implementation
+
+** Security Configuration — network whitelist
+Domains that the Bouncer considers safe for outbound connections. Network calls to unlisted domains are blocked or queued for approval.
 #+begin_src lisp
-(in-package :opencortex)
+(defvar *bouncer-network-whitelist*
+  '("api.telegram.org" "matrix.org" "googleapis.com" "openai.com" "anthropic.com")
+  "Domains the Bouncer considers safe for outbound connections.")
 #+end_src
 
-* Deep Packet Inspection (DPI)
-The Bouncer ensures the action is "safe" by inspecting the payload content via Deep Packet Inspection.
+** Privacy filter tags (bouncer-privacy-tags)
+List of tag strings that mark content as private. Content with these tags is filtered from the LLM context window. Configurable via ~PRIVACY_FILTER_TAGS~ env var.
+#+begin_src lisp
+(defvar bouncer-privacy-tags
+  (let ((env (uiop:getenv "PRIVACY_FILTER_TAGS")))
+    (if env
+        (uiop:split-string env :separator '(#\,))
+        '("@personal")))
+  "Tags marking content as private. Set via PRIVACY_FILTER_TAGS.")
+#+end_src
 
-** Secret Exposure Check
-Retrieves all active secrets from the vault and scans the payload for potential leaks.
+** Protected file paths (bouncer-protected-paths)
+Path patterns (with * wildcards) that are blocked from file reads. Covers SSH keys, PEM/PGP files, credentials, tokens, env files, and cloud configs.
+#+begin_src lisp
+(defvar bouncer-protected-paths
+  '(".env" ".env.example" ".env.local" ".env.production"
+    "*credentials*" "*cred*"
+    "*id_rsa*" "*id_dsa*" "*id_ecdsa*" "*id_ed25519*"
+    "*.pem" "*.key" "*.p12" "*.pfx" "*.asc" "*.gpg" "*.pgp"
+    "secring.*" "pubring.*" "private-keys-v1.d/*"
+    "token*" "*secret*" "*token*"
+    ".netrc" ".git-credentials" "auth.json"
+    ".aws/credentials" ".aws/config"
+    ".kube/config" "kubeconfig"
+    "*.cert" "*.crt" "*.csr"
+    "*password*" "*passwd*")
+  "Path patterns blocked from file reads.")
+#+end_src
 
+** Content exposure patterns (bouncer-exposure-patterns)
+Named regex patterns for scanning content for secret exposure. Each entry is a (name regex) pair. Matches are reported by name so downstream code can act on specific categories.
+#+begin_src lisp
+(defvar bouncer-exposure-patterns
+  '((:pem-key "-----BEGIN +(RSA|DSA|EC|OPENSSH|PGP) +PRIVATE +KEY *-----")
+    (:pgp-key "-----BEGIN +PGP +PRIVATE +KEY +BLOCK-----")
+    (:pgp-public "-----BEGIN +PGP +PUBLIC +KEY +BLOCK-----")
+    (:openai-key "sk-[A-Za-z0-9-]{20,}")
+    (:google-key "AIza[0-9A-Za-z_-]{35}")
+    (:github-token "gh[pousr]_[A-Za-z0-9]{36,}")
+    (:slack-token "xox[baprs]-[A-Za-z0-9-]{24,}")
+    (:env-assignment "[A-Z_]+=[A-Za-z0-9+/=_\\-]{20,}")
+    (:generic-secret "(api|secret|password|token)[ ]*[:=][ ]*[\"']?[A-Za-z0-9_\\-]{16,}"))
+  "Named regex patterns for secret exposure detection.")
+#+end_src
+
+** Shell safety — timeout
+Maximum seconds a shell command is allowed to run before being killed.
+#+begin_src lisp
+(defvar *bouncer-shell-timeout* 30
+  "Maximum seconds for a shell command before timeout.")
+#+end_src
+
+** Shell safety — output limit
+Maximum characters of shell command output to capture. Prevents memory exhaustion from infinite output.
+#+begin_src lisp
+(defvar *bouncer-shell-max-output* 100000
+  "Maximum characters of shell output to capture.")
+#+end_src
+
+** Shell safety — blocked patterns
+Destructive and injection patterns that are blocked in shell commands. Covers ~rm -rf /~, ~dd~, ~mkfs~, ~shred~, backtick injection, and ~$()~ subshell injection.
+#+begin_src lisp
+(defvar *bouncer-shell-blocked-patterns*
+  '((:destructive-rm    "\\brm\\s+-rf\\s+/")
+    (:destructive-dd    "\\bdd\\s+if=")
+    (:destructive-mkfs  "\\bmkfs\\.")
+    (:destructive-format "\\bmformat\\b")
+    (:disk-wipe         "\\bshred\\s+/dev/")
+    (:disk-wipe-b       "\\bwipefs\\s+/dev/")
+    (:injection-backtick "`[^`]+`")
+    (:injection-subshell "\\$\\([^)]+\\)"))
+  "Destructive and injection patterns blocked in shell commands.")
+#+end_src
+
+** Secret Path Check (bouncer-check-secret-path)
+#+begin_src lisp
+(defun bouncer-wildcard-match (pattern path)
+  "Matches PATH against PATTERN where * matches any characters."
+  (let ((regex (cl-ppcre:regex-replace-all
+                "\\*" (cl-ppcre:quote-meta-chars pattern) ".*")))
+    (cl-ppcre:scan regex path)))
+
+(defun bouncer-check-secret-path (filepath)
+  "Returns the matching pattern if FILEPATH matches a protected path, nil otherwise."
+  (when (and filepath (stringp filepath))
+    (some (lambda (pattern)
+            (when (bouncer-wildcard-match pattern filepath)
+              pattern))
+          bouncer-protected-paths)))
+#+end_src
+
+** Content Exposure Scanner (bouncer-scan-exposure)
+#+begin_src lisp
+(defun bouncer-scan-exposure (text)
+  "Scans TEXT for patterns matching known secret formats.
+Returns a list of matched category keywords."
+  (when (and text (stringp text) (> (length text) 0))
+    (let ((matches nil))
+      (dolist (entry bouncer-exposure-patterns)
+        (let ((name (first entry))
+              (regex (second entry)))
+          (when (cl-ppcre:scan regex text)
+            (push name matches))))
+      matches)))
+#+end_src
+
+** Vault Secret Scanning (bouncer-scan-secrets)
 #+begin_src lisp
 (defun bouncer-scan-secrets (text)
-  "Returns the name of the secret found in TEXT, or NIL if clean."
+  "Scans TEXT for known secrets from the vault."
   (when (and text (stringp text))
     (let ((found-secret nil))
       (maphash (lambda (key val)
@@ -34,112 +136,260 @@ Retrieves all active secrets from the vault and scans the payload for potential
       found-secret)))
 #+end_src
 
-** Network Exfiltration Check
-Inspects shell commands for unwhitelisted domains or IP addresses.
+** Privacy Tag Check (bouncer-check-privacy-tags)
+#+begin_src lisp
+(defun bouncer-check-privacy-tags (tags-list)
+  "Returns T if any tag in TAGS-LIST matches a privacy filter tag."
+  (when (and tags-list (listp tags-list))
+    (some (lambda (tag)
+            (some (lambda (private)
+                    (or (string-equal tag private)
+                        (search private tag :test #'string-equal)))
+                  bouncer-privacy-tags))
+          tags-list)))
 
+(defun bouncer-check-text-for-privacy (text)
+  "Scans TEXT for leaked privacy-tagged content."
+  (when (and text (stringp text))
+    (let ((lower (string-downcase text)))
+      (some (lambda (tag)
+              (search (string-downcase tag) lower))
+            bouncer-privacy-tags))))
+#+end_src
+
+** Lisp Validation Gate (bouncer-check-lisp-valid)
+#+begin_src lisp
+(defun bouncer-extract-org-lisp-blocks (content)
+  "Extracts concatenated Lisp code from #+begin_src lisp blocks in an Org string."
+  (when (and content (stringp content))
+    (let ((lines (uiop:split-string content :separator '(#\Newline)))
+          (in-block nil)
+          (code ""))
+      (dolist (line lines)
+        (let ((clean (string-trim '(#\Space #\Tab) line)))
+          (cond
+            ((search "#+begin_src lisp" clean)
+             (setf in-block t))
+            ((search "#+end_src" clean)
+             (setf in-block nil))
+            (in-block
+             (setf code (concatenate 'string code line (string #\Newline)))))))
+      (when (> (length code) 0) code))))
+
+(defun bouncer-check-lisp-valid (filepath content)
+  "Validates Lisp syntax when writing .lisp files or Org files with lisp blocks.
+Returns the validation result plist or nil if not applicable."
+  (when (and content (stringp content) (> (length content) 0))
+    (let ((to-validate
+           (cond
+             ((uiop:string-suffix-p filepath ".lisp") content)
+             ((uiop:string-suffix-p filepath ".org") (bouncer-extract-org-lisp-blocks content))
+             (t nil))))
+      (when to-validate
+        (multiple-value-bind (valid-p err) (ignore-errors
+                                            (let ((*read-eval* nil))
+                                              (with-input-from-string (s (format nil "(progn ~a)" to-validate))
+                                                (loop for form = (read s nil :eof) until (eq form :eof)))
+                                              (values t nil)))
+          (unless valid-p
+            (list :status :error :reason err)))))))
+#+end_src
+
+** REPL Verification Gate (bouncer-check-repl-verified)
+#+begin_src lisp
+(defun bouncer-org-contains-defuns-p (content)
+  "Returns T if the Org content contains any #+begin_src lisp blocks with defuns."
+  (when (and content (stringp content))
+    (search "defun " content :test #'char-equal)))
+
+(defun bouncer-check-repl-verified (action filepath content)
+  "Warns if writing a defun to an Org file without :repl-verified metadata."
+  (let ((repl-verified (getf action :repl-verified)))
+    (when (and filepath
+               (uiop:string-suffix-p filepath ".org")
+               (bouncer-org-contains-defuns-p content)
+               (not repl-verified))
+      (list :type :LOG
+            :payload (list :level :warn
+                           :text (format nil "Lint: Writing defun to ~a without :repl-verified flag. Did you prototype this in the REPL first?" filepath))))))
+#+end_src
+
+** Shell Safety Check (bouncer-check-shell-safety)
+#+begin_src lisp
+(defun bouncer-check-shell-safety (cmd)
+  "Checks a shell command for destructive patterns and injection vectors.
+Returns a list of matched pattern names or nil if safe."
+  (when (and cmd (stringp cmd) (> (length cmd) 0))
+    (let ((matches nil))
+      (dolist (entry *bouncer-shell-blocked-patterns*)
+        (let ((name (first entry))
+              (regex (second entry)))
+          (when (cl-ppcre:scan regex cmd)
+            (push name matches))))
+      matches)))
+#+end_src
+
+** Network Check (bouncer-check-network-exfil)
 #+begin_src lisp
 (defun bouncer-check-network-exfil (cmd)
-  "Returns T if the command appears to target an unwhitelisted external host."
+  "Detects if CMD attempts to contact an unwhitelisted external host."
   (when (and cmd (stringp cmd))
-    ;; Basic check for common data exfiltration tools being used with IPs/URLs
-    (let ((network-whitelist '("api.telegram.org" "matrix.org" "googleapis.com" "openai.com" "anthropic.com")))
-      (when (cl-ppcre:scan "(http|https|ftp)://([\\w\\.-]+)" cmd)
-        (multiple-value-bind (match regs) 
-            (cl-ppcre:scan-to-strings "(http|https|ftp)://([\\w\\.-]+)" cmd)
-          (declare (ignore match))
-          (let ((domain (aref regs 1)))
-            (not (some (lambda (safe) (search safe domain)) network-whitelist))))))))
+    (multiple-value-bind (match regs)
+        (cl-ppcre:scan-to-strings "(http|https|ftp)://([\\w\\.-]+)" cmd)
+      (declare (ignore match))
+      (when regs
+        (let ((domain (aref regs 1)))
+          (not (some (lambda (safe) (search safe domain))
+                    *bouncer-network-whitelist*)))))))
 #+end_src
 
-* Runtime Guard (bouncer-check)
-The primary entry point for all high-impact actions. It blocks or queues actions based on risk vectors.
-
+** Main Security Gate (bouncer-check)
 #+begin_src lisp
 (defun bouncer-check (action context)
-  "The 5-Vector security gate. Blocks or queues actions based on risk."
-  (let* ((target (getf action :target))
-         (payload (getf action :payload))
-         (text (or (getf payload :text) (getf action :text)))
-         ;; Extract cmd from direct shell or tool-mediated shell call
-         (cmd (or (getf payload :cmd)
-                  (when (and (eq target :tool) (equal (getf payload :tool) "shell"))
-                    (getf (getf payload :args) :cmd))))
-         (approved (getf action :approved)))
-    
+  "Security gate for high-risk actions.
+Vectors: lisp validation, secret path, secret content, vault secrets,
+privacy tags, privacy text, shell safety, network exfil, high-impact approval."
+  (declare (ignore context))
+  (let* ((target (proto-get action :target))
+         (payload (proto-get action :payload))
+         (text (or (proto-get payload :text) (proto-get action :text)))
+         (filepath (or (proto-get payload :filepath)
+                       (when (equal (proto-get payload :tool) "read-file")
+                         (proto-get (proto-get payload :args) :filepath))
+                       (when (equal (proto-get payload :tool) "write-file")
+                         (proto-get (proto-get payload :args) :filepath))))
+         (content (when filepath (proto-get (proto-get payload :args) :content)))
+         (cmd (or (proto-get payload :cmd)
+                  (when (and (eq target :tool) (equal (proto-get payload :tool) "shell"))
+                    (proto-get (proto-get payload :args) :cmd))))
+         (approved (proto-get action :approved))
+         (tags (proto-get payload :tags))
+         (lisp-valid (when (and filepath content (not approved))
+                       (bouncer-check-lisp-valid filepath content)))
+         (repl-lint (when (and filepath content (not approved))
+                     (bouncer-check-repl-verified action filepath content))))
     (cond
-      ;; 0. Bypass for already approved actions
       (approved action)
 
-      ;; 1. Secret Exposure Vector (Hard Block)
+       ;; Vector 0: REPL verification lint (warn, don't block)
+      (repl-lint
+       (harness-log "BOUNCER: ~a" (proto-get repl-lint :text))
+       action)
+
+       ;; Vector 1: Lisp syntax validation (block bad lisp writes)
+      ((and lisp-valid (eq (getf lisp-valid :status) :error))
+       (harness-log "LINT VIOLATION: Blocked write — lisp syntax error in ~a: ~a" filepath (getf lisp-valid :reason))
+       (list :type :LOG
+             :payload (list :level :error
+                            :text (format nil "Lisp syntax error in ~a: ~a. The write was blocked. Fix the parenthesis balance and retry." filepath (getf lisp-valid :reason)))))
+
+      ;; Vector 2: File read to a protected secret path
+      ((and filepath (bouncer-check-secret-path filepath))
+       (let ((matched (bouncer-check-secret-path filepath)))
+         (harness-log "SECURITY VIOLATION: Blocked read of protected path '~a' (matched: ~a)" filepath matched)
+         (list :type :LOG
+               :payload (list :level :error
+                              :text (format nil "Action blocked: Attempted read of protected path '~a'" filepath)))))
+
+      ;; Vector 3: Content contains secret patterns
+      ((and text (bouncer-scan-exposure text))
+       (let ((matched (bouncer-scan-exposure text)))
+         (harness-log "SECURITY VIOLATION: Content contains secret patterns: ~a" matched)
+         (list :type :LOG
+               :payload (list :level :error
+                              :text "Action blocked: Content contains potential secret exposure."))))
+
+      ;; Vector 4: Content contains vault secrets
       ((and text (bouncer-scan-secrets text))
        (let ((secret-name (bouncer-scan-secrets text)))
-         (harness-log "SECURITY VIOLATION: Blocked leak of secret ~a" secret-name)
-         `(:type :log :payload (:level :error :text ,(format nil "Action blocked: Potential exposure of ~a" secret-name)))))
+         (harness-log "SECURITY VIOLATION: Blocked potential leak of secret '~a'" secret-name)
+         (list :type :LOG
+               :payload (list :level :error
+                              :text (format nil "Action blocked: Potential exposure of '~a'" secret-name)))))
 
-      ;; 2. Network Exfiltration Vector (Authorization Required)
-      ((and (or (eq target :shell) 
-                (and (eq target :tool) (equal (getf payload :tool) "shell")))
+      ;; Vector 5: Privacy-tagged content in action
+      ((and tags (bouncer-check-privacy-tags tags))
+       (harness-log "PRIVACY VIOLATION: Action contains privacy-tagged content")
+       (list :type :LOG
+             :payload (list :level :warn
+                            :text "Action blocked: Content tagged with privacy filter.")))
+
+      ;; Vector 6: Text leaks privacy tag names
+      ((and text (bouncer-check-text-for-privacy text))
+       (harness-log "PRIVACY WARNING: Text may contain leaked private content")
+       (list :type :LOG
+             :payload (list :level :warn
+                            :text "Action blocked: Text may reference private content.")))
+
+       ;; Vector 7: Shell destructive/injection patterns
+      ((and cmd (bouncer-check-shell-safety cmd))
+       (let ((matched (bouncer-check-shell-safety cmd)))
+         (harness-log "SHELL VIOLATION: Destructive or injection pattern in command: ~a" matched)
+         (list :type :LOG
+               :payload (list :level :error
+                              :text (format nil "Shell command blocked: contains unsafe pattern ~a" matched)))))
+
+      ;; Vector 8: Network exfiltration
+      ((and (or (eq target :shell)
+                (and (eq target :tool) (equal (proto-get payload :tool) "shell")))
             (bouncer-check-network-exfil cmd))
-       (harness-log "SECURITY WARNING: External network call detected. Queuing for approval.")
-       `(:type :EVENT :payload (:sensor :approval-required :action ,action)))
+        (harness-log "SECURITY WARNING: External network call detected. Queuing for approval.")
+        (list :type :EVENT :payload (list :sensor :approval-required :action action)))
 
-      ;; 3. High-Impact Target Vector (Authorization Required)
+      ;; Vector 8: High-impact action approval
       ((or (member target '(:shell))
-           (and (eq target :tool) (member (getf payload :tool) '("shell" "repair-file") :test #'string=))
-           (and (eq target :emacs) (eq (getf payload :action) :eval)))
-       (harness-log "SECURITY: High-impact action ~a requires approval." (or (getf payload :tool) target))
-       `(:type :EVENT :payload (:sensor :approval-required :action ,action)))
-
-      ;; 4. Default Pass
+           (and (eq target :tool) (member (proto-get payload :tool) '("shell" "repair-file") :test #'string=))
+           (and (eq target :emacs) (eq (proto-get payload :action) :eval)))
+       (harness-log "SECURITY: High-impact action requires approval: ~a" (or (proto-get payload :tool) target))
+       (list :type :EVENT :payload (list :sensor :approval-required :action action)))
       (t action))))
+
 #+end_src
 
-* Approval Processing
-The Bouncer periodically scans the Memex for approved "Flight Plans" and re-injects them into the metabolic loop.
-
+** Approval Processing (bouncer-process-approvals)
 #+begin_src lisp
 (defun bouncer-process-approvals ()
-  "Scans the object store for APPROVED flight plans and re-injects their actions."
+  "Scans for APPROVED flight plans and re-injects them."
   (let ((approved-nodes (list-objects-with-attribute :TODO "APPROVED"))
         (found-any nil))
     (dolist (node approved-nodes)
-      (let* ((tags (getf (org-object-attributes node) :TAGS))
-             (action-str (getf (org-object-attributes node) :ACTION)))
+      (let* ((attrs (org-object-attributes node))
+             (tags (getf attrs :TAGS))
+             (action-str (getf attrs :ACTION)))
         (when (and (member "FLIGHT_PLAN" tags :test #'string-equal) action-str)
-          (harness-log "BOUNCER: Found approved flight plan ~a. Re-injecting..." (org-object-id node))
+          (harness-log "BOUNCER: Found approved flight plan '~a'. Re-injecting..." (org-object-id node))
           (let ((action (ignore-errors (read-from-string action-str))))
             (when action
-              ;; Mark as approved to bypass the gate
               (setf (getf action :approved) t)
               (inject-stimulus action)
-              ;; Mark as DONE
               (setf (getf (org-object-attributes node) :TODO) "DONE")
               (setq found-any t))))))
     found-any))
 #+end_src
 
-* Skill Definition
-The Bouncer skill reacts to approval requirements by creating flight plan nodes, and periodically checks for manual approvals via heartbeats.
+** Flight Plan Creation (bouncer-create-flight-plan)
+#+begin_src lisp
+(defun bouncer-create-flight-plan (blocked-action)
+  "Creates a Flight Plan node for manual approval."
+  (let ((id (org-id-new)))
+    (harness-log "BOUNCER: Creating flight plan node '~a'..." id)
+    (list :type :REQUEST :target :emacs
+          :payload (list :action :insert-node :id id
+                         :attributes (list :TITLE "Flight Plan: High-Risk Action"
+                                           :TODO "PLAN" :TAGS '("FLIGHT_PLAN")
+                                           :ACTION (format nil "~s" blocked-action))))))
+#+end_src
 
-** Skill Logic
+** Gate Logic (bouncer-deterministic-gate)
 #+begin_src lisp
 (defun bouncer-deterministic-gate (action context)
-  "Main gate for the bouncer skill."
+  "Main deterministic gate for the Bouncer skill."
   (let* ((payload (getf context :payload))
          (sensor (getf payload :sensor)))
     (case sensor
       (:approval-required
-       (let* ((blocked-action (getf payload :action))
-              (id (org-id-new)))
-         (harness-log "BOUNCER: Creating flight plan node...")
-         ;; Create the node in Emacs (or inbox)
-         (list :type :REQUEST :target :emacs :action :insert-node 
-               :id id :attributes `(:TITLE "Flight Plan: High-Risk Action" 
-                                    :TODO "PLAN" 
-                                    :TAGS ("FLIGHT_PLAN")
-                                    :ACTION ,(format nil "~s" blocked-action)))))
+       (bouncer-create-flight-plan (getf payload :action)))
       (:heartbeat
-       ;; Periodically check for approvals
        (bouncer-process-approvals)
        (if action (bouncer-check action context) action))
       (otherwise
@@ -150,7 +400,6 @@ The Bouncer skill reacts to approval requirements by creating flight plan nodes,
 #+begin_src lisp
 (defskill :skill-bouncer
   :priority 150
-  :trigger (lambda (ctx) t) ;; Bouncer evaluates all actions deterministically
-  :probabilistic nil
+  :trigger (lambda (ctx) (declare (ignore ctx)) t)
   :deterministic #'bouncer-deterministic-gate)
 #+end_src

skills/org-skill-cli-gateway.org

@@ -1,159 +1,26 @@
-:PROPERTIES:
-:ID:       cli-gateway-skill
-:CREATED:  [2026-04-13 Mon 17:00]
-:END:
-#+TITLE: SKILL: CLI Gateway (Universal Literate Note)
-#+STARTUP: content
-#+FILETAGS: :gateway:cli:io:autonomy:
+#+TITLE: SKILL: CLI Gateway (org-skill-cli-gateway.org)
+#+AUTHOR: Agent
+#+FILETAGS: :skill:gateway:cli:
+#+PROPERTY: header-args:lisp :tangle org-skill-cli-gateway.lisp
 
 * Overview
-The *CLI Gateway* is the primary interaction point for the OpenCortex MVP. It provides a lightweight TCP socket server that allows local terminal clients to communicate with the daemon. It ensures a frictionless "First Contact" experience immediately following installation.
+The *CLI Gateway* provides a command-line interface for interacting with the OpenCortex daemon.
 
-* Phase A: Demand (PRD)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
+* Implementation
 
-** 1. Purpose
-Provide a secure, local, and low-latency terminal interface for the OpenCortex.
-
-** 2. Success Criteria
-- [X] *Ingress:* Accept plain-text messages over TCP port 9105.
-- [X] *Normalisation:* Inject messages into the harness as `:chat-message` signals.
-- [X] *Egress:* Implement the `:cli` actuator to route agent responses back to the correct client socket.
-- [X] *Client:* Provide a standalone client script for the user's host machine.
-
-* Phase B: Blueprint (PROTOCOL)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
-
-** 1. Architectural Intent
-The gateway runs a multi-threaded TCP server. Each connection is handled in its own thread. Inbound lines are wrapped in a Signal and processed. The `:cli` actuator retrieves the `:reply-stream` from the signal context to send the response back to the specific connected client.
-
-** 2. Semantic Interfaces
-- Inbound: `(:sensor :chat-message :channel :cli :text "...")`
-- Outbound: `(:type :REQUEST :target :cli :text "...")`
-
-* Phase D: Build (Implementation)
-
-** Package Context
+** CLI Command Handling
 #+begin_src lisp
-(in-package :opencortex)
+(defun cli-process-input (text)
+  "Processes raw text from the command line."
+  (inject-stimulus (list :type :EVENT 
+                         :payload (list :sensor :user-input :text text) 
+                         :meta (list :source :CLI))))
 #+end_src
 
-** State: Server Control
+** Skill Registration
 #+begin_src lisp
-(defvar *cli-server-thread* nil)
-(defvar *cli-server-socket* nil)
-(defvar *cli-port* 9105)
-#+end_src
-
-** Actuator: CLI Response
-The CLI actuator writes the agent's response back to the client's network stream. It applies a simple "Agent: " prefix for clarity.
-
-#+begin_src lisp
-(defun execute-cli-action (action context)
-  "Sends a message back to the connected CLI client via its network stream."
-  (let* ((payload (getf action :payload))
-         (text (or (getf payload :text) (getf action :text)))
-         (stream (getf context :reply-stream)))
-    (handler-case
-        (if (and stream (open-stream-p stream))
-            (progn
-              (format stream "Agent: ~a~%" text)
-              (finish-output stream))
-            (harness-log "CLI ERROR: No active or open reply stream for signal."))
-      (error (c) (harness-log "CLI ACTUATOR ERROR: ~a" c)))))
-#+end_src
-
-** Server: Client Handler
-Handles an individual TCP connection. It reads lines until the connection is closed.
-
-#+begin_src lisp
-(defun handle-cli-client (stream)
-  "Reads lines from a CLI client and injects them as stimuli."
-  (harness-log "CLI: Client connected.")
-  (format stream "--------------------------------------------------~%")
-  (format stream "  Connected to OpenCortex~%")
-  (format stream "--------------------------------------------------~%")
-  (finish-output stream)
-  (handler-case
-      (loop for line = (read-line stream nil nil)
-            while line do
-            (let ((trimmed (string-trim '(#\Space #\Tab #\Newline #\Return) line)))
-              (when (> (length trimmed) 0)
-                (harness-log "CLI: Received input -> ~a" trimmed)
-                (inject-stimulus (list :type :EVENT 
-                                       :payload (list :sensor :chat-message 
-                                                      :channel :cli 
-                                                      :text trimmed))
-                                 :stream stream))))
-    (error (c) (harness-log "CLI CLIENT DISCONNECT: ~a" c)))
-  (harness-log "CLI: Client disconnected."))
-#+end_src
-
-** Server: Main Loop
-Listens for new TCP connections on the configured port.
-
-#+begin_src lisp
-(defun start-cli-gateway (&optional (port *cli-port*))
-  "Starts the TCP listener for local CLI clients."
-  (setf *cli-server-socket* (usocket:socket-listen "0.0.0.0" port :reuse-address t))
-  (setf *cli-server-thread*
-        (bt:make-thread
-         (lambda ()
-           (unwind-protect
-                (loop
-                  (let* ((socket (usocket:socket-accept *cli-server-socket*))
-                         (stream (usocket:socket-stream socket)))
-                    (bt:make-thread (lambda () 
-                                      (unwind-protect (handle-cli-client stream)
-                                        (usocket:socket-close socket)))
-                                    :name "opencortex-cli-client-handler")))
-             (usocket:socket-close *cli-server-socket*)))
-         :name "opencortex-cli-gateway"))
-  (harness-log "CLI: Gateway listening on port ~a" port))
-#+end_src
-
-** Registration
-#+begin_src lisp
-(register-actuator :cli #'execute-cli-action)
-
-(defskill :skill-gateway-cli
-  :priority 200
-  :trigger (lambda (ctx) (declare (ignore ctx)) nil)
-  :probabilistic nil
+(defskill :skill-cli-gateway
+  :priority 100
+  :trigger (lambda (ctx) (eq (getf (getf ctx :meta) :source) :CLI))
   :deterministic (lambda (action ctx) (declare (ignore ctx)) action))
 #+end_src
-
-** Initialization
-#+begin_src lisp
-(start-cli-gateway)
-#+end_src
-
-* Phase E: The Client (Scripts)
-We tangle a lightweight client script that the user can run on their host machine.
-
-** The Bash Client
-#+begin_src bash :tangle ../scripts/opencortex-chat.sh :shebang "#!/bin/bash"
-# opencortex-chat: The terminal mouthpiece for the Autonomous Brain.
-PORT=9105
-HOST=${1:-localhost}
-
-# Check for socat (preferred)
-if command -v socat >/dev/null 2>&1; then
-    # Use socat with READLINE for history and arrow-key support.
-    # It establishes a persistent bidirectional connection.
-    socat READLINE,history=$HOME/.org_agent_history TCP:$HOST:$PORT
-else
-    # Fallback to nc (netcat) for a single-shot connection if socat is missing.
-    # Note: This is less robust for agents with long-thinking times.
-    echo "WARNING: socat not found. Falling back to nc (no line-editing support)."
-    while true; do
-        read -p "User: " MESSAGE
-        if [ -z "$MESSAGE" ]; then continue; fi
-        echo "$MESSAGE" | nc -N $HOST $PORT
-    done
-fi
-#+end_src

skills/org-skill-config-manager.org

@@ -0,0 +1,292 @@
+#+TITLE: SKILL: Config Manager (org-skill-config-manager.org)
+#+AUTHOR: Agent
+#+FILETAGS: :skill:setup:config:
+#+PROPERTY: header-args:lisp :tangle org-skill-config-manager.lisp
+
+* Overview
+The *Config Manager* skill provides the OpenCortex Agent with the capability to manage its own environment variables and provider configurations. It includes an interactive setup wizard for LLM providers, gateways, and system settings.
+
+* Implementation
+
+** Configuration directory (get-oc-config-dir)
+Resolves the XDG config directory for OpenCortex.
+#+begin_src lisp
+(defun get-oc-config-dir ()
+  "Returns the absolute path to the opencortex config directory."
+  (let ((xdg (uiop:getenv "OC_CONFIG_DIR")))
+    (if xdg xdg (namestring (merge-pathnames ".config/opencortex/" (user-homedir-pathname))))))
+#+end_src
+
+** Config file path (get-config-file)
+Returns the path to the ~.env~ file within the config directory.
+#+begin_src lisp
+(defun get-config-file ()
+  "Returns the path to the .env configuration file."
+  (merge-pathnames ".env" (get-oc-config-dir)))
+#+end_src
+
+** Ensure config directory (ensure-config-dir)
+Creates the config directory tree if it does not exist.
+#+begin_src lisp
+(defun ensure-config-dir ()
+  "Creates the configuration directory if it does not exist."
+  (ensure-directories-exist (get-oc-config-dir)))
+#+end_src
+
+** Config File Operations
+#+begin_src lisp
+(defun read-config-file ()
+  "Reads the .env config file and returns an alist of KEY=VALUE pairs."
+  (let ((config-file (get-config-file)))
+    (when (uiop:file-exists-p config-file)
+      (let ((lines (uiop:read-file-lines config-file))
+            (result nil))
+        (dolist (line lines)
+          (when (and line (> (length line) 0)
+                     (not (uiop:string-prefix-p "#" line)))
+            (let ((eq-pos (position #\= line)))
+              (when eq-pos
+                (let ((key (string-trim " " (subseq line 0 eq-pos)))
+                      (value (string-trim " " (subseq line (1+ eq-pos)))))
+                  (push (cons key value) result))))))
+        (nreverse result)))))
+
+(defun write-config-file (config-alist)
+  "Writes the config alist to the .env file."
+  (ensure-config-dir)
+  (let ((config-file (get-config-file)))
+    (with-open-file (stream config-file :direction :output :if-exists :supersede :if-does-not-exist :create)
+      (format stream "# OpenCortex Configuration~%")
+      (format stream "# Generated by opencortex setup~%~%")
+      (dolist (pair config-alist)
+        (format stream "~a=~a~%" (car pair) (cdr pair))))))
+
+(defun get-config-value (key)
+  "Gets a config value by key."
+  (let ((config (read-config-file)))
+    (cdr (assoc key config :test #'string=))))
+
+(defun set-config-value (key value)
+  "Sets a config value and saves to file."
+  (let ((config (read-config-file))
+        (pair (cons key value)))
+    (let ((existing (assoc key config :test #'string=)))
+      (if existing
+          (setf (cdr existing) value)
+          (push pair config))
+      (write-config-file config))))
+#+end_src
+
+** Input Utilities
+#+begin_src lisp
+(defun prompt (prompt-text)
+  "Simple prompt that returns user input as a string."
+  (format t "~a" prompt-text)
+  (finish-output)
+  (read-line))
+
+(defun prompt-yes-no (prompt-text)
+  "Prompts yes/no question. Returns T for yes, nil for no."
+  (let ((response (prompt (format nil "~a [Y/n]: " prompt-text))))
+    (or (string= response "")
+        (string-equal response "Y")
+        (string-equal response "y")
+        (string-equal response "yes"))))
+
+(defun prompt-choice (prompt-text options)
+  "Prompts user to choose from a list of options. Returns the chosen option or nil."
+  (format t "~a~%" prompt-text)
+  (let ((i 1))
+    (dolist (opt options)
+      (format t "  ~a) ~a~%" i opt)
+      (incf i)))
+  (let ((response (prompt "Choice")))
+    (let ((num (ignore-errors (parse-integer response))))
+      (when (and num (<= 1 num) (>= (length options) num))
+        (nth (1- num) options)))))
+#+end_src
+
+** LLM Provider Setup
+#+begin_src lisp
+(defparameter *available-providers*
+  '(("OpenAI" . "OPENAI_API_KEY")
+    ("Anthropic" . "ANTHROPIC_API_KEY")
+    ("OpenRouter" . "OPENROUTER_API_KEY")
+    ("Groq" . "GROQ_API_KEY")
+    ("Gemini" . "GEMINI_API_KEY")
+    ("Ollama (local)" . "OLLAMA_URL")))
+
+(defun setup-llm-providers ()
+  "Interactive wizard for configuring LLM providers."
+  (format t "~%~%")
+  (format t "==================================================~%")
+  (format t " LLM Provider Configuration~%")
+  (format t "==================================================~%~%")
+  
+  (let ((current-providers (loop for (name . key) in *available-providers*
+                                when (get-config-value key)
+                                collect name)))
+    (when current-providers
+      (format t "Current providers: ~{~a~^, ~}~%~%" current-providers))
+    
+    (format t "Available providers:~%")
+    (dolist (p *available-providers*)
+      (format t "  - ~a~%" (car p)))
+    (format t "~%")
+    
+    (when (prompt-yes-no "Configure a new provider?")
+      (let ((chosen (prompt-choice "Select provider:" (mapcar #'car *available-providers*))))
+        (when chosen
+          (let ((env-key (cdr (assoc chosen *available-providers* :test #'string=))))
+            (if (string= chosen "Ollama (local)")
+                (progn
+                  (format t "Enter Ollama URL (e.g., http://localhost:11434): ")
+                  (let ((url (read-line)))
+                    (set-config-value env-key url)
+                    (format t "✓ Ollama configured at ~a~%" url)))
+                (progn
+                  (format t "Enter API key for ~a: " chosen)
+                  (let ((key (read-line)))
+                    (set-config-value env-key key)
+                    (format t "✓ ~a API key saved~%" chosen)))))))))
+  
+  (format t "~%"))
+
+(defun setup-add-provider ()
+  "Entry point for adding a single provider (called from CLI)."
+  (setup-llm-providers))
+#+end_src
+
+** Gateway Setup
+#+begin_src lisp
+(defun setup-gateways ()
+  "Interactive wizard for configuring external gateways."
+  (format t "~%~%")
+  (format t "==================================================~%")
+  (format t " Gateway Configuration~%")
+  (format t "==================================================~%~%")
+  
+  (format t "Available gateways:~%")
+  (format t "  - Slack (https://api.slack.com/)~%")
+  (format t "  - Discord (https://discord.com/developers/)~%")
+  (format t "~%")
+  
+  (when (prompt-yes-no "Configure a gateway?")
+    (let ((chosen (prompt-choice "Select platform:" '("Slack" "Discord"))))
+      (when chosen
+        (let ((token (prompt (format nil "Enter ~a bot token: " chosen))))
+          (if (string= chosen "Slack")
+              (set-config-value "SLACK_TOKEN" token)
+              (set-config-value "DISCORD_TOKEN" token))
+          (format t "✓ ~a gateway configured~%" chosen)))))
+  
+  (format t "~%"))
+#+end_src
+
+** Skill Management
+#+begin_src lisp
+(defun setup-skills ()
+  "Interactive wizard for enabling/disabling skills."
+  (format t "~%~%")
+  (format t "==================================================~%")
+  (format t " Skill Management~%")
+  (format t "==================================================~%~%")
+  
+  (format t "Note: Skill management is not yet implemented.~%")
+  (format t "Skills are automatically loaded from ~a~%" (or (uiop:getenv "OC_DATA_DIR") "~/.local/share/opencortex"))
+  (format t "~%"))
+#+end_src
+
+** Memory Settings
+#+begin_src lisp
+(defun setup-memory ()
+  "Interactive wizard for memory settings."
+  (format t "~%~%")
+  (format t "==================================================~%")
+  (format t " Memory Settings~%")
+  (format t "==================================================~%~%")
+  
+  (let ((auto-save (prompt "Auto-save interval in seconds [300]:")))
+    (when (and auto-save (> (length auto-save) 0))
+      (set-config-value "MEMORY_AUTO_SAVE_INTERVAL" auto-save)))
+  
+  (let ((history (prompt "History retention in lines [1000]:")))
+    (when (and history (> (length history) 0))
+      (set-config-value "MEMORY_HISTORY_RETENTION" history)))
+  
+  (format t "✓ Memory settings saved~%")
+  (format t "~%"))
+#+end_src
+
+** Network Settings
+#+begin_src lisp
+(defun setup-network ()
+  "Interactive wizard for network settings."
+  (format t "~%~%")
+  (format t "==================================================~%")
+  (format t " Network Settings~%")
+  (format t "==================================================~%~%")
+  
+  (let ((timeout (prompt "Request timeout in seconds [30]:")))
+    (when (and timeout (> (length timeout) 0))
+      (set-config-value "REQUEST_TIMEOUT" timeout)))
+  
+  (let ((proxy (prompt "Proxy URL (leave empty for none) []:")))
+    (when (and proxy (> (length proxy) 0))
+      (set-config-value "HTTP_PROXY" proxy)))
+  
+  (format t "✓ Network settings saved~%")
+  (format t "~%"))
+#+end_src
+
+** Main Setup Wizard
+#+begin_src lisp
+(defun run-setup-wizard ()
+  "Main entry point for the interactive setup wizard."
+  (format t "~%~%")
+  (format t "╔═══════════════════════════════════════════════════╗~%")
+  (format t "║         OpenCortex Setup Wizard                   ║~%")
+  (format t "╚═══════════════════════════════════════════════════╝~%")
+  (format t "~%")
+  (format t "This wizard will help you configure:~%")
+  (format t "  1. LLM Providers (OpenAI, Anthropic, etc.)~%")
+  (format t "  2. Gateway Links (Slack, Discord)~%")
+  (format t "  3. Memory Settings~%")
+  (format t "  4. Network Settings~%")
+  (format t "~%")
+  
+  (ensure-config-dir)
+  
+  ;; Step 1: LLM Providers
+  (when (prompt-yes-no "Configure LLM providers?")
+    (setup-llm-providers))
+  
+  ;; Step 2: Gateways
+  (when (prompt-yes-no "Configure gateways?")
+    (setup-gateways))
+  
+  ;; Step 3: Memory
+  (when (prompt-yes-no "Configure memory settings?")
+    (setup-memory))
+  
+  ;; Step 4: Network
+  (when (prompt-yes-no "Configure network settings?")
+    (setup-network))
+  
+  ;; Summary
+  (format t "==================================================~%")
+  (format t " Setup Complete!~%")
+  (format t "==================================================~%")
+  (format t "~%")
+  (format t "Configuration saved to: ~a~%" (get-config-file))
+  (format t "~%")
+  (format t "To verify your setup, run: opencortex doctor~%")
+  (format t "~%"))
+#+end_src
+
+** Skill Registration
+#+begin_src lisp
+(defskill :skill-config-manager
+  :priority 100
+  :trigger (lambda (ctx) (declare (ignore ctx)) nil))
+#+end_src

skills/org-skill-credentials-vault.org

@@ -1,178 +1,44 @@
-:PROPERTIES:
-:ID:       credentials-vault-skill
-:CREATED:  [2026-04-09 Thu]
-:END:
-#+TITLE: SKILL: Credentials Vault (Universal Literate Note)
-#+STARTUP: content
-#+FILETAGS: :auth:security:infrastructure:autonomy:
-#+DEPENDS_ON: id:state-persistence-skill
+#+TITLE: SKILL: Credentials Vault (org-skill-credentials-vault.org)
+#+AUTHOR: Agent
+#+FILETAGS: :system:security:vault:
+#+PROPERTY: header-args:lisp :tangle org-skill-credentials-vault.lisp
 
 * Overview
-The *Credentials Vault* is the high-security enclave for the OpenCortex. It centralizes the management of LLM API keys, OAuth sessions, and browser cookies. By consolidating these into a single vault, we ensure that sensitive tokens are handled with uniform masking, validation, and Merkle-integrated persistence.
+The *Credentials Vault* provides secure in-memory storage for sensitive API keys and session tokens.
 
-* Phase A: Demand (PRD)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
-
-** 1. Purpose
-Securely manage all authentication tokens required for the opencortex to operate.
-
-** 2. User Needs
-- *Unified Storage:* Single interface for API keys and Session Cookies.
-- *Masked Logging:* Ensure credentials never appear in plaintext in `harness-log`.
-- *Guided Onboarding:* Retain and improve the Google/Gemini cookie handshake.
-- *Persistence:* Securely save credentials to the Memory via Merkle-Tree snapshots.
-
-* Phase B: Blueprint (PROTOCOL)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
-
-** 1. Architectural Intent
-The vault provides a secure lookup table in RAM, backed by the persistent Memory. Access is restricted to internal kernel requests and explicitly authorized deterministic gates.
-
-** 2. Semantic Interfaces
-#+begin_src lisp
-(defun vault-get-secret (provider &key type)
-  "Retrieves a secret (api-key or session) for a provider.")
-
-(defun vault-set-secret (provider secret &key type)
-  "Securely stores a secret and triggers a Merkle snapshot.")
-#+end_src
-
-* Phase C: Success (QUALITY)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
-
-** 1. Success Criteria
-- [ ] *No Plaintext Leaks:* Log output must use `[REDACTED]` for sensitive values.
-- [ ] *Merkle Integration:* Setting a secret must increment the Memory version.
-- [ ] *Dual-Path Auth:* Support both `:api-key` and `:session-cookies`.
-- [ ] *Onboarding Verification:* The cookie handshake successfully hydrates the vault.
-
-** 2. TDD Plan
-Tests in `tests/vault-tests.lisp` will verify:
-1. Retrieval of keys from both `.env` (fallback) and Vault (primary).
-2. Redaction of keys in log strings.
-3. Successful version increment in the Memory after `vault-set-secret`.
-
-* Phase D: Build (Implementation)
-
-** Package Context
-#+begin_src lisp
-#+end_src
-
-** Vault State
-We maintain an in-memory hash table for secrets, which is hydrated from and persisted to the Memory.
+* Implementation
 
+** Vault Storage
 #+begin_src lisp
 (defvar *vault-memory* (make-hash-table :test 'equal)
   "In-memory cache of sensitive credentials.")
 #+end_src
 
-** Helper: Secret Masking
-The `vault-mask-string` function ensures that diagnostic output never contains the full plaintext of a sensitive token.
-
-#+begin_src lisp
-(defun vault-mask-string (str)
-  "Returns a masked version of a sensitive string."
-  (if (and str (> (length str) 8))
-      (format nil "~a...~a" (subseq str 0 4) (subseq str (- (length str) 4)))
-      "[REDACTED]"))
-#+end_src
-
-** Retrieval (vault-get-secret)
-This function is the secure getter for all system secrets. It prioritizes the Vault (Memory) and falls back to environment variables for legacy compatibility.
-
+** Secret Management
 #+begin_src lisp
 (defun vault-get-secret (provider &key (type :api-key))
-  "Retrieves a credential. Type can be :api-key or :session."
+  "Retrieves a credential from the vault or environment."
   (let* ((key (format nil "~a-~a" provider type))
          (val (gethash key *vault-memory*)))
     (if val
         val
-        ;; Fallback to environment
         (let ((env-var (case provider
-                         ((:gemini :gemini-api) "GEMINI_API_KEY")
-                         (:openai "OPENAI_API_KEY")
-                         (:anthropic "ANTHROPIC_API_KEY")
-                         (:groq "GROQ_API_KEY")
-                         (:openrouter "OPENROUTER_API_KEY")
-                         (:telegram "TELEGRAM_BOT_TOKEN")
-                         (:signal "SIGNAL_ACCOUNT_NUMBER")
-                         (:matrix-homeserver "MATRIX_HOMESERVER")
-                         (:matrix-token "MATRIX_ACCESS_TOKEN")
-                         (t nil))))
-          (when (and env-var (eq type :api-key))
-            (uiop:getenv env-var))))))
-#+end_src
+                          (:gemini "GEMINI_API_KEY")
+                          (:openai "OPENAI_API_KEY")
+                          (:anthropic "ANTHROPIC_API_KEY")
+                          (:openrouter "OPENROUTER_API_KEY")
+                          (otherwise nil))))
+          (when env-var (uiop:getenv env-var))))))
 
-** Persistence (vault-set-secret)
-When a secret is updated, we immediately snapshot the Memory to ensure the credential change is versioned and durable.
-
-#+begin_src lisp
 (defun vault-set-secret (provider secret &key (type :api-key))
-  "Securely stores a secret and triggers a Merkle snapshot."
+  "Stores a secret in the vault."
   (let ((key (format nil "~a-~a" provider type)))
-    (setf (gethash key *vault-memory*) secret)
-    (harness-log "VAULT - Updated ~a for ~a. Triggering Merkle snapshot..." type provider)
-    (snapshot-memory)
-    t))
+    (setf (gethash key *vault-memory*) secret)))
 #+end_src
 
-** Onboarding Logic
-Retained from the legacy Google skill, this provides the instructions for the autonomous cookie handshake.
-
+** Skill Registration
 #+begin_src lisp
-(defun vault-onboard-gemini-web ()
-  "Instructions for the Autonomous Cookie Handshake."
-  (harness-log "--- GEMINI WEB ONBOARDING ---")
-  (harness-log "1. Visit gemini.google.com")
-  (harness-log "2. Run the 'Get Gemini Cookies' Bookmarklet.")
-  (harness-log "   CODE: javascript:(function(){const c=document.cookie.split('; ').reduce((r,v)=>{const [n,val]=v.split('=');r[n]=val;return r},{});const target=['__Secure-1PSID','__Secure-1PSIDTS'];const out=target.map(n=>({name:n,value:c[n]}));prompt('Copy JSON:',JSON.stringify(out));})();")
-  (harness-log "PLATFORM GUIDE: Chrome/Firefox/Safari all support Bookmarklets via 'Add Page' or 'New Bookmark'.")
-  t)
+(defskill :skill-credentials-vault
+  :priority 600
+  :trigger (lambda (ctx) (declare (ignore ctx)) nil))
 #+end_src
-
-** Registration
-#+begin_src lisp
-(progn
-  (defskill :skill-credentials-vault
-    :priority 200 ; High priority, foundational
-    :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :onboarding-request))
-    :probabilistic nil
-    :deterministic (lambda (action ctx) 
-                (vault-onboard-gemini-web)
-                action)))
-#+end_src
-
-* Phase E: Chaos (Verification)
-
-** 1. Unit Tests (FiveAM)
-#+begin_src lisp
-(defpackage :opencortex-vault-tests
-  (:use :cl :fiveam :opencortex))
-(in-package :opencortex-vault-tests)
-
-(def-suite vault-suite :description "Tests for the Credentials Vault.")
-(in-suite vault-suite)
-
-(test test-masking
-  (is (equal "sk-t...-key" (opencortex::vault-mask-string "sk-test-key")))
-  (is (equal "[REDACTED]" (opencortex::vault-mask-string "short"))))
-
-(test test-vault-persistence
-  "Verify that setting a secret triggers a snapshot (mock check)."
-  (let ((old-version (opencortex::org-object-version (gethash "root" *memory*))))
-    (opencortex:vault-set-secret :test "secret-val")
-    (is (> (opencortex::org-object-version (gethash "root" *memory*)) old-version))))
-#+end_src
-
-** 2. Chaos Scenarios
-- *Scenario A (Vault Poisoning):* Inject a malformed session string and verify the `llm-gateway` detects the invalid format and returns a standardized error instead of crashing.
-- *Scenario B (Memory Wipe):* Clear `*vault-memory*` during runtime and verify the vault successfully re-hydrates from the Memory (or environment fallback).
-
-* Phase F: Memory (RCA)
-- *[2026-04-09 Thu]:* Consolidated `auth-api-key` and `auth-google-oauth` into this vault. Introduced mandatory masking for all credential-related logging.

skills/org-skill-diagnostics.org

@@ -0,0 +1,247 @@
+#+TITLE: SKILL: Diagnostics (org-skill-diagnostics.org)
+#+AUTHOR: Agent
+#+FILETAGS: :system:diagnostics:doctor:
+#+PROPERTY: header-args:lisp :tangle org-skill-diagnostics.lisp
+
+* Overview
+The *Diagnostics Skill* (Doctor) provides system-wide health checks and dependency verification. It validates external dependencies, XDG environment, and LLM provider connectivity.
+
+* Phase A: Demand (Thinking)
+** Why a Doctor?
+The Doctor transforms opaque startup failures into actionable engineering reports. It ensures the Brain never attempts to boot in a compromised state.
+
+** Detection Invariant
+Binary detection must use shell probing (`which`) to account for varying `$PATH` inheritance between interactive and headless sessions.
+
+* Phase B: Protocol (Success Criteria)
+- Dependency check passes when all required binaries are found
+- Environment check passes when XDG directories exist and are accessible
+- LLM check passes when at least one provider is configured or Ollama is running locally
+
+* Phase C: Implementation (Build)
+
+** Global Configuration
+#+begin_src lisp
+(defvar *doctor-required-binaries* '("sbcl" "emacs" "git" "socat" "nc")
+  "List of external binaries required for full system operation.")
+
+(defvar *doctor-package-map*
+  '(("sbcl" . "sbcl")
+    ("emacs" . "emacs")
+    ("git" . "git")
+    ("socat" . "socat")
+    ("nc" . "netcat-openbsd")
+    ("curl" . "curl")
+    ("rlwrap" . "rlwrap"))
+  "Map binary names to apt package names.")
+
+(defvar *doctor-missing-deps* nil
+  "List of missing dependencies populated by doctor-check-dependencies.")
+
+(defvar *doctor-auto-install* t
+  "When T, doctor will attempt to install missing dependencies automatically.")
+#+end_src
+
+** Dependency Verification
+#+begin_src lisp
+(defun doctor-check-dependencies ()
+  "Verifies that required external binaries are available in the PATH via shell probe."
+  (setf *doctor-missing-deps* nil)
+  (let ((all-ok t))
+    (format t "DOCTOR: Checking system dependencies...~%")
+    (dolist (dep *doctor-required-binaries*)
+      (let ((path (ignore-errors
+                    (uiop:run-program (list "which" dep)
+                                      :output :string :ignore-error-status t))))
+        (if (and path (> (length path) 0))
+            (format t "  [OK] Found ~a~%" dep)
+            (progn
+              (format t "  [FAIL] Missing binary: ~a~%" dep)
+              (push dep *doctor-missing-deps*)
+              (setf all-ok nil)))))
+    (when (and all-ok (null *doctor-missing-deps*))
+      (format t "DOCTOR: All dependencies satisfied.~%"))
+    all-ok))
+#+end_src
+
+** Auto-Install Dependencies
+#+begin_src lisp
+(defun doctor-install-dependencies ()
+  "Attempts to install missing system dependencies via apt."
+  (when (null *doctor-missing-deps*)
+    (format t "DOCTOR: No missing dependencies to install.~%")
+    (return-from doctor-install-dependencies t))
+
+  (format t "DOCTOR: Attempting to install ~a missing dependencies...~%" (length *doctor-missing-deps*))
+
+  (let ((packages (remove-duplicates
+                   (mapcar (lambda (dep)
+                             (or (cdr (assoc dep *doctor-package-map* :test #'string=))
+                                 dep))
+                           *doctor-missing-deps*)
+                   :test #'string=)))
+    (format t "DOCTOR: Packages to install: ~a~%" packages)
+
+    (let ((cmd (format nil "apt-get install -y ~{~a~^ ~}" packages)))
+      (format t "DOCTOR: Running: ~a~%" cmd)
+      (handler-case
+          (let ((output (uiop:run-program cmd
+                                           :output :string
+                                           :error-output :string
+                                           :external-format :utf-8)))
+            (if (zerop (uiop:run-program (format nil "which ~a" (car *doctor-missing-deps*))
+                                          :ignore-error-status t))
+                (progn
+                  (format t "DOCTOR: Dependencies installed successfully.~%")
+                  (setf *doctor-missing-deps* nil)
+                  t)
+                (progn
+                  (format t "DOCTOR: Installation failed. Output: ~a~%" output)
+                  nil)))
+        (error (c)
+          (format t "DOCTOR: Installation error: ~a~%" c)
+          nil)))))
+#+end_src
+
+** XDG Environment Validation
+#+begin_src lisp
+(defun doctor-check-env ()
+  "Validates XDG directories and environment configuration."
+  (format t "DOCTOR: Checking XDG environment...~%")
+  (let ((all-ok t)
+        (config-dir (uiop:getenv "OC_CONFIG_DIR"))
+        (data-dir (uiop:getenv "OC_DATA_DIR"))
+        (state-dir (uiop:getenv "OC_STATE_DIR"))
+        (memex-dir (uiop:getenv "MEMEX_DIR")))
+
+    (flet ((check-dir (name path critical)
+             (if (and path (> (length path) 0))
+                 (if (uiop:directory-exists-p path)
+                     (format t "  [OK] ~a: ~a~%" name path)
+                     (progn
+                       (format t "  [FAIL] ~a directory missing: ~a~%" name path)
+                       (when critical (setf all-ok nil))))
+                 (progn
+                   (format t "  [FAIL] ~a variable not set.~%" name)
+                   (when critical (setf all-ok nil))))))
+
+      (check-dir "Config (OC_CONFIG_DIR)" config-dir t)
+      (check-dir "Data (OC_DATA_DIR)" data-dir t)
+      (check-dir "State (OC_STATE_DIR)" state-dir t)
+      (check-dir "Memex (MEMEX_DIR)" memex-dir t))
+    all-ok))
+#+end_src
+
+** LLM Connectivity
+The doctor checks all supported LLM providers and detects local Ollama instances.
+
+#+begin_src lisp
+(defun doctor-check-llm ()
+  "Tests connectivity to LLM providers. Returns T if at least one provider is configured."
+  (format t "DOCTOR: Checking LLM connectivity...~%")
+  (let ((providers '((:openrouter . "OPENROUTER_API_KEY")
+                    (:anthropic . "ANTHROPIC_API_KEY")
+                    (:openai . "OPENAI_API_KEY")
+                    (:groq . "GROQ_API_KEY")
+                    (:gemini . "GEMINI_API_KEY")
+                    (:ollama . "OLLAMA_URL")))
+        (configured nil))
+    (dolist (p providers)
+      (let ((env-val (uiop:getenv (cdr p))))
+        (cond
+          ((and env-val (> (length env-val) 0))
+           (format t "  [OK] ~a configured~%" (car p))
+           (setf configured t))
+          ((eq (car p) :ollama)
+           (let ((ollama-check (ignore-errors
+                                 (uiop:run-program '("curl" "-s" "http://localhost:11434/api/tags")
+                                                    :output :string :ignore-error-status t))))
+             (when (and ollama-check (search "\"models\"" ollama-check))
+               (format t "  [OK] Ollama local model server detected~%")
+               (setf configured t)))))))
+    (if configured
+        (progn
+          (format t "  [OK] LLM provider(s) available~%")
+          t)
+        (progn
+          (format t "  [WARN] No LLM provider configured.~%")
+          (format t "  Run 'opencortex setup' to configure a provider.~%")
+          t))))
+#+end_src
+
+** Orchestration
+#+begin_src lisp
+(defun doctor-run-all (&key (auto-install t))
+  "Executes the full diagnostic suite and returns T if system is healthy."
+  (format t "==================================================~%")
+  (format t " OPENCORTEX DOCTOR: Commencing Health Check~%")
+  (format t "==================================================~%")
+  (let ((dep-ok (doctor-check-dependencies)))
+    (when (and (not dep-ok) auto-install *doctor-auto-install*)
+      (format t "DOCTOR: Attempting automatic installation...~%")
+      (setf dep-ok (doctor-install-dependencies))
+      (when dep-ok
+        (setf dep-ok (doctor-check-dependencies))))
+    (let ((env-ok (doctor-check-env))
+          (llm-ok (doctor-check-llm)))
+      (format t "==================================================~%")
+      (if (and dep-ok env-ok)
+          (progn
+            (format t " ✓ SYSTEM HEALTHY: Ready for ignition.~%")
+            t)  ;; Explicitly return T
+          (progn
+            (format t "==================================================~%")
+            (format t " ISSUES FOUND:~%")
+            (when (not dep-ok)
+              (format t "  - Missing system dependencies~%"))
+            (when (not llm-ok)
+              (format t "  - No LLM provider configured~%"))
+            (format t "~%")
+            (format t " RECOMMENDED ACTIONS:~%")
+            (format t "  1. Run 'opencortex setup' to configure everything~%")
+            (format t "  2. Or run 'opencortex doctor --fix' for auto-repair~%")
+            (format t "==================================================~%")
+            nil)))))  ;; Return nil when issues found
+#+end_src
+
+** CLI Entry Point
+#+begin_src lisp
+(defun doctor-main ()
+  "Entry point for the 'doctor' CLI command."
+  (if (doctor-run-all)
+      (uiop:quit 0)
+      (uiop:quit 1)))
+#+end_src
+
+* Phase D: Verification (Testing)
+
+** Dependency Test
+#+begin_src lisp :tangle no
+(test test-doctor-dependency-check
+  "Verify that missing binaries are correctly identified as failures."
+  (let ((opencortex::*doctor-required-binaries* '("non-existent-binary-123")))
+    (is (null (opencortex:doctor-check-dependencies)))))
+#+end_src
+
+** Environment Test
+#+begin_src lisp :tangle no
+(test test-doctor-env-check
+  "Verify that an invalid MEMEX_DIR triggers a critical failure."
+  (let ((old-m (uiop:getenv "MEMEX_DIR")))
+    (unwind-protect
+         (progn
+           (setf (uiop:getenv "MEMEX_DIR") "/non/existent/path/999")
+           (is (null (opencortex:doctor-check-env))))
+      (setf (uiop:getenv "MEMEX_DIR") (or old-m "")))))
+#+end_src
+
+* Phase E: Lifecycle
+The doctor skill should be loaded early (priority 100) to validate system health before other skills initialize.
+
+** Skill Registration
+#+begin_src lisp
+(defskill :skill-diagnostics
+  :priority 100
+  :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :heartbeat))
+  :deterministic (lambda (action ctx) (declare (ignore action ctx)) nil))
+#+end_src

skills/org-skill-engineering-standards.org

@@ -0,0 +1,90 @@
+#+TITLE: SKILL: Engineering Standards (org-skill-engineering-standards.org)
+#+AUTHOR: Agent
+#+FILETAGS: :system:engineering:chaos:
+#+DEPENDS_ON: org-skill-utils-lisp
+#+PROPERTY: header-args:lisp :tangle org-skill-engineering-standards.lisp
+
+* Overview
+The *Engineering Standards Skill* defines the REPL-first engineering lifecycle and enforces technical invariants, including the **Commit-Before-Modify** rule and **Chaos-Driven Development**.
+
+** Engineering Lifecycle (Two-Track)
+
+The canonical workflow. Two tracks, not to be confused:
+
+*** Track 1 — Org-First: Prose, Tests, Thinking (Phases 0/A)
+
+This track stays in Org. No code is written yet.
+
+**** Phase 0: Exploration & Documentation
+1. Read the relevant Org source files for context
+2. Explore the problem in the running REPL with ~repl-inspect~ and ~repl-eval~
+3. Document findings in Org prose
+4. If a bug: document investigation in Org before fixing (Org as thinking medium)
+
+**** Phase A: Test-First Design
+1. Write the success criteria in Org prose — what the function does, arguments, return value, rationale
+2. Write the FiveAM test in a ~#+begin_src lisp :tangle no~ block
+3. Tangle the test and evaluate in the REPL — confirm it fails (red)
+4. The failing test is the success criteria. Do not proceed to Track 2 until it exists and is red.
+
+*** Track 2 — REPL-First: Implementation, Iteration, Reflection (Phases B/C/D/E)
+
+Code is prototyped in the REPL, never written directly into Org first.
+
+**** Phase B/C: REPL Implementation
+1. Write the function directly in the REPL using ~repl-eval~
+2. Iterate: evaluate, inspect, fix, re-evaluate — the image accumulates state
+3. Run the test in the REPL — confirm green
+4. Explore edge cases with ~repl-inspect~ and ad-hoc evaluations
+5. Before writing any ~defun~ in an Org block, verify it was prototyped and tested in the REPL first
+
+**** Phase D: Chaos Verification
+Run the appropriate chaos tier before reflecting code back to Org:
+- *Tier 1 (Deterministic)*: Full FiveAM test suite — required on every change
+- *Tier 2 (Probabilistic)*: Randomized fuzzing — required on every major release
+- *Tier 3 (Stress)*: Load and resource starvation — required during hardening sprints
+
+**** Phase E: Reflect Back to Org
+1. Copy the working function into its own ~#+begin_src lisp~ block in the Org file
+2. Update the prose to match what the function actually does (arguments, return, rationale)
+3. Before closing Phase E, run ~(utils-lisp-validate (uiop:read-file-string "path/to/file.lisp") :strict t)~ in the REPL — never external scripts or manual paren-counting
+4. Verify the Org file tangles correctly
+5. Tangle, commit, update GTD
+
+**** Syntax Error Protocol
+If a LOADER ERROR or reader-error occurs:
+1. Run ~(utils-lisp-validate (uiop:read-file-string "file.lisp") :strict t)~ in the REPL — never Python, never grep, never manual counting
+2. Fix the error in the Org file (since the code was prototyped in REPL first, this should be rare)
+3. Retangle and re-evaluate
+
+Rationale: The two tracks prevent the two failure modes we have observed. Writing implementation code directly in Org (without REPL prototyping) produces syntax errors that require external tools to debug. Skipping Org-first test writing produces code without verified success criteria. The split is not bureaucratic — it is the mechanism by which both failures are prevented.
+
+* Implementation
+
+** Standards Enforcement
+#+begin_src lisp
+(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))))
+
+(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 engineering-standards-format-lisp (code)
+  "Ensures Lisp code adheres to formatting standards."
+  (utils-lisp-format code))
+#+end_src
+
+** Skill Registration
+#+begin_src lisp
+(defskill :skill-engineering-standards
+  :priority 100
+  :trigger (lambda (ctx) (declare (ignore ctx)) nil))
+#+end_src

skills/org-skill-gardener.org

@@ -1,132 +1,32 @@
-:PROPERTIES:
-:ID:       gardener-skill
-:CREATED:  [2026-04-13 Mon 18:50]
-:END:
-#+TITLE: SKILL: Autonomous Gardener (Memex Maintenance)
-#+STARTUP: content
-#+FILETAGS: :gardener:maintenance:memex:autonomy:
+#+TITLE: SKILL: Gardener (org-skill-gardener.org)
+#+AUTHOR: Agent
+#+FILETAGS: :skill:maintenance:gardener:
+#+PROPERTY: header-args:lisp :tangle org-skill-gardener.lisp
 
 * Overview
-The *Autonomous Gardener* is the metabolic immune system of the Memex. It autonomously audits the knowledge graph for structural decay—broken links, orphaned nodes, and missing metadata—ensuring that the system remains coherent and navigatable over long horizons.
+The *Gardener Skill* performs periodic maintenance on the Memex knowledge graph.
 
-* Phase A: Demand (PRD)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
+* Implementation
 
-** 1. Purpose
-Maintain the structural integrity and "Vibe" of the Memex through autonomous auditing and self-repair proposals.
-
-** 2. Success Criteria
-- [ ] *Link Audit:* Detect `id:` links that point to non-existent objects.
-- [ ] *Orphan Detection:* Identify headlines that have zero inbound or outbound connections.
-- [ ] *Reporting:* Log structural issues or propose "Flight Plans" for manual repair.
-
-* Phase B: Blueprint (PROTOCOL)
-:PROPERTIES:
-:STATUS: SIGNED
-:END:
-
-** 1. Architectural Intent
-The Gardener runs on a low-priority heartbeat. It performs a "Deep Audit" of the entire `*memory*` graph. Unlike the Scribe, which creates new data, the Gardener focuses on the *relationships* between existing data.
-
-** 2. Semantic Interfaces
-- Trigger: `(:sensor :heartbeat)`
-- Action (Repair): `(:type :REQUEST :target :emacs :action :update-node :id "..." :attributes (...))`
-
-* Phase D: Build (Implementation)
-
-** Package Context
+** Maintenance Logic
 #+begin_src lisp
-(in-package :opencortex)
-#+end_src
+(defun gardener-prune-orphans ()
+  "Identifies and handles orphaned objects in memory."
+  (harness-log "GARDENER: Pruning orphans..."))
 
-** State: Maintenance Cycle
-We track the last audit time to ensure the Gardener doesn't over-consume resources.
-
-#+begin_src lisp
-(defvar *gardener-last-audit* 0
-  "The universal-time of the last full Memex audit.")
-#+end_src
-
-** Audit: Broken Links
-Scans the content of all objects for `id:` links and verifies the targets exist.
-
-#+begin_src lisp
-(defun gardener-find-broken-links ()
-  "Returns a list of broken ID links found in the Memex."
-  (let ((broken nil))
-    (maphash (lambda (id obj)
-               (let ((content (org-object-content obj)))
-                 (when content
-                   (cl-ppcre:do-register-groups (target-id) ("id:([A-Za-z0-9-]+)" content)
-                     (unless (lookup-object target-id)
-                       (push (list :source id :broken-target target-id) broken))))))
-             *memory*)
-    broken))
-#+end_src
-
-** Audit: Orphaned Nodes
-Identifies nodes that are not linked to and do not link to anything else.
-
-#+begin_src lisp
-(defun gardener-find-orphans ()
-  "Returns a list of IDs for headlines that are structurally isolated."
-  (let ((inbound (make-hash-table :test 'equal))
-        (outbound (make-hash-table :test 'equal))
-        (orphans nil))
-    ;; 1. Map all connections
-    (maphash (lambda (id obj)
-               (let ((content (org-object-content obj)))
-                 (when content
-                   (cl-ppcre:do-register-groups (target-id) ("id:([A-Za-z0-9-]+)" content)
-                     (setf (gethash id outbound) t)
-                     (setf (gethash target-id inbound) t)))))
-             *memory*)
-    ;; 2. Identify nodes with zero connections
-    (maphash (lambda (id obj)
-               (declare (ignore obj))
-               (unless (or (gethash id inbound) (gethash id outbound))
-                 (push id orphans)))
-             *memory*)
-    orphans))
-#+end_src
-
-** Skill Logic: The Audit Pass
-The Gardener's deterministic gate performs the actual analysis and logs the results. In future versions, it will generate probabilistic repair proposals.
-
-#+begin_src lisp
-(defun gardener-deterministic-gate (action context)
-  "Main gate for the Gardener skill. Audits graph integrity."
-  (declare (ignore action context))
-  (let ((broken (gardener-find-broken-links))
-        (orphans (gardener-find-orphans)))
-    
-    (when (or broken orphans)
-      (harness-log "GARDENER: Audit found ~a broken links and ~a orphans." 
-                   (length broken) (length orphans))
-      
-      (dolist (link broken)
-        (harness-log "  [BROKEN LINK] Node ~a -> ~a" (getf link :source) (getf link :broken-target)))
-      
-      (dolist (orphan orphans)
-        (harness-log "  [ORPHAN] Node ~a is isolated." orphan)))
-    
-    (setf *gardener-last-audit* (get-universal-time))
-    ;; Return a log to stop the loop
-    (list :type :LOG :payload (list :text "Gardener audit complete."))))
+(defun gardener-verify-merkle-integrity ()
+  "Validates the hashes of all objects in memory."
+  (harness-log "GARDENER: Verifying Merkle integrity..."))
 #+end_src
 
 ** Skill Registration
 #+begin_src lisp
 (defskill :skill-gardener
-  :priority 40
-  :trigger (lambda (ctx)
-             (let* ((payload (getf ctx :payload))
-                    (sensor (getf payload :sensor)))
-               (and (eq sensor :heartbeat)
-                    ;; Only audit once per day
-                    (> (- (get-universal-time) *gardener-last-audit*) 86400))))
-  :probabilistic nil
-  :deterministic #'gardener-deterministic-gate)
+  :priority 100
+  :trigger (lambda (ctx) (eq (getf (getf ctx :payload) :sensor) :heartbeat))
+  :deterministic (lambda (action ctx) 
+                   (declare (ignore action ctx))
+                   (gardener-prune-orphans)
+                   (gardener-verify-merkle-integrity)
+                   nil))
 #+end_src