refactor: Flatten directory structure library->harness, library/gen->skills

harness/memory.org

@@ -31,14 +31,14 @@ flowchart TD
 #+end_src
 
 ** Package Context
-#+begin_src lisp :tangle ../library/memory.lisp
+#+begin_src lisp :tangle ./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 ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defvar *memory* (make-hash-table :test 'equal))
 
 (defvar *history-store* (make-hash-table :test 'equal)
@@ -48,7 +48,7 @@ The `*memory*` is the global hash table that holds every Org element by its uniq
 ** 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 ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defstruct org-object
   id type attributes content vector parent-id children version last-sync hash)
 
@@ -60,7 +60,7 @@ Every element in the Memex (headlines, paragraphs, etc.) is represented by an `o
 ** 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 ../library/memory.lisp
+#+begin_src lisp :tangle ./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)))
@@ -77,7 +77,7 @@ The `compute-merkle-hash` function ensures the cryptographic integrity of the kn
 ** 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 ../library/memory.lisp
+#+begin_src lisp :tangle ./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))
@@ -116,7 +116,7 @@ The `ingest-ast` function is the primary bridge between the external world (Emac
 ** 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 ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defvar *object-store-snapshots* nil)
 
 (defun copy-hash-table (hash-table)
@@ -138,7 +138,7 @@ Because objects are stored immutably in the `*history-store*`, a snapshot is a l
 ** Memory Rollback (rollback-memory)
 Restores the state of the Memex from one of the previous snapshots.
 
-#+begin_src lisp :tangle ../library/memory.lisp
+#+begin_src lisp :tangle ./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*)))
@@ -153,7 +153,7 @@ Restores the state of the Memex from one of the previous snapshots.
 These tests verify the Memory system. Run with:
 ~(fiveam:run! 'memory-suite)~
 
-#+begin_src lisp :tangle ../tests/memory-tests.lisp
+#+begin_src lisp :tangle ./tests/memory-tests.lisp
 (defpackage :opencortex-memory-tests
   (:use :cl :fiveam :opencortex)
   (:export #:memory-suite))
@@ -206,7 +206,7 @@ These tests verify the Memory system. Run with:
 ** Disk Persistence (save-memory / load-memory)
 Essential for surviving crashes. Saves the in-memory hash tables to disk and loads them back on restart. The path is controlled by the `MEMORY_SNAPSHOT_PATH` environment variable.
 
-#+begin_src lisp :tangle ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defvar *memory-snapshot-path* nil
   "Path to the memory snapshot file. Set from MEMORY_SNAPSHOT_PATH env or default.")
 
@@ -261,7 +261,7 @@ Support for vector embeddings via Ollama and semantic search with cosine similar
 
 The vector slot on org-objects enables semantic recall - searching memory by meaning rather than just keywords. Embeddings are generated on ingest when the :EMBED property is set to "t", and cached locally to avoid redundant API calls.
 
-#+begin_src lisp :tangle ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defvar *embedding-cache* (make-hash-table :test 'equal)
   "Cache for embeddings to avoid redundant API calls.")
 
@@ -317,12 +317,35 @@ Returns up to LIMIT objects with similarity >= MIN-SIMILARITY, sorted by similar
           (semantic-search (getf args :query)
                         :limit (or (getf args :limit) 10)
                         :min-similarity (or (getf args :min-similarity) 0.5))))
+
+** Cognitive Tool: Generate Embeddings
+Provided for the Probabilistic Engine to invoke embedding generation on demand.
+
+#+begin_src lisp :tangle ./memory.lisp
+(def-cognitive-tool :generate-embeddings
+  "Generates vector embeddings for given text via the configured embedding backend (Ollama)."
+  ((:texts :type :list :description "List of text strings to embed."))
+  :body (lambda (args)
+          (let ((texts (getf args :texts)))
+            (unless (and texts (listp texts))
+              (return-from generate-embeddings
+                (list :status :error :message ":texts must be a list of strings.")))
+            (let ((results nil) (errors nil))
+              (dolist (text texts)
+                (let ((vec (get-embedding text)))
+                  (if vec
+                      (push (list :text text :vector vec) results)
+                      (push text errors))))
+              (list :status (if errors :partial :success)
+                    :embeddings (nreverse results)
+                    :failed (when errors (nreverse errors))
+                    :count (length results))))))
 #+end_src
 
 ** Lookup Utilities
 Basic functions for retrieving objects by ID or type.
 
-#+begin_src lisp :tangle ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defun org-id-new ()
   "Generates a new UUID string for Org-mode identification."
   (string-downcase (format nil "~a" (uuid:make-v4-uuid))))
@@ -351,7 +374,7 @@ Basic functions for retrieving objects by ID or type.
 ** Structural Helpers
 Utility functions for AST traversal and path resolution.
 
-#+begin_src lisp :tangle ../library/memory.lisp
+#+begin_src lisp :tangle ./memory.lisp
 (defun find-headline-missing-id (ast)
   "Traverses an AST to find headlines that lack an :ID: property."
   (when (listp ast)
@@ -367,7 +390,7 @@ Utility functions for AST traversal and path resolution.
 * 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
+#+begin_src lisp :tangle ./tests/memory-tests.lisp
 (defpackage :opencortex-memory-tests
   (:use :cl :fiveam :opencortex)
   (:export #:memory-suite))