REFAC: Applied literate granularity and configuration externalization to context stage

src/context.lisp

@@ -34,20 +34,19 @@
 (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 (merge-pathnames "skills/" (asdf:system-source-directory :org-agent)))
+         (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)))
 
-(defun context-get-system-logs (&optional (limit 20))
+(defun context-get-system-logs (&optional limit)
   "Retrieves the most recent lines from the harness's internal log."
-  (bt:with-lock-held (*logs-lock*)
-    (let ((count (min limit (length *system-logs*)))) (subseq *system-logs* 0 count))))
+  (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)))))
 
-(defun context-get-skill-telemetry (skill-name)
-  "Returns performance and execution data for a specific skill."
-  (bt:with-lock-held (*telemetry-lock*) (gethash (string-downcase skill-name) *skill-telemetry*)))
-
-(defun context-render-to-org (obj &key (depth 1) (foveal-id nil) (semantic-threshold 0.75) (foveal-vector nil))
+(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))
@@ -56,10 +55,11 @@
          (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 semantic-threshold))
+         (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.
@@ -86,25 +86,25 @@
                                         (context-render-to-org child-obj 
                                                                :depth (1+ depth) 
                                                                :foveal-id next-foveal
-                                                               :semantic-threshold semantic-threshold
+                                                               :semantic-threshold threshold
                                                                :foveal-vector foveal-vector))))))))
     output))
 
 (defun context-resolve-path (path-string)
-  "Expands environment variables within path strings (e.g. $HOME/...)."
-  (if (and (stringp path-string) (uiop:string-prefix-p "$" path-string))
-      (let* ((parts (uiop:split-string path-string :separator '(#\/)))
-             (var-name (subseq (car parts) 1)) (var-val (uiop:getenv var-name))
-             (remaining (cl:reduce (lambda (a b) (format nil "~a/~a" a b)) (cdr parts))))
-        (if var-val (let ((clean-val (string-trim '(#\" #\Space) var-val)))
-                      (format nil "~a/~a" (string-right-trim "/" clean-val) remaining))
-            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))
 
 (defun context-assemble-global-awareness (&optional signal)
   "Produces a high-level skeletal outline of the current Memory for the LLM."
-  (let* ((payload (when signal (getf signal :payload)))
-         (foveal-id (when payload (getf payload :target-id)))
+  (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):
 "))