passepartout: v0.6.0 — Time Awareness

Level 2: symbolic-time-memory skill
- memory-objects-since(timestamp) — hash-table walk, objects with version >= timestamp
- memory-objects-in-range(since until) — version between two timestamps
- context-query-with-time — extended query with :since :until
- 6 tests, 100% pass

Level 3: sensor-time skill
- format-time-for-llm — TIME: section for system prompt (iso/natural format)
- session-duration — session start tracking
- sensor-time-tick — deadline scanning, cron-registered, 0 LLM tokens
- TIME_AWARENESS / TIME_FORMAT / DEADLINE_WARNING_MINUTES env vars
- 13 tests, 100% pass

Level 1: TIME injection in think() (core-reason)
- fboundp-guarded call to format-time-for-llm
- session duration included when sensor-time skill loaded
- Injected at top of system prompt in both token-economics and fallback paths

Full suite: 135/135 (100%)

lisp/symbolic-time-memory.lisp

@@ -0,0 +1,113 @@
+(in-package :passepartout)
+
+(defun memory-objects-since (timestamp)
+  "Returns all memory-objects from *memory-store* with version >= TIMESTAMP."
+  (let ((results nil))
+    (maphash (lambda (id obj)
+               (declare (ignore id))
+               (when (>= (memory-object-version obj) timestamp)
+                 (push obj results)))
+             *memory-store*)
+    (nreverse results)))
+
+(defun memory-objects-in-range (since until)
+  "Returns memory-objects with version between SINCE and UNTIL (inclusive)."
+  (let ((results nil))
+    (maphash (lambda (id obj)
+               (declare (ignore id))
+               (let ((v (memory-object-version obj)))
+                 (when (and (>= v since) (<= v until))
+                   (push obj results))))
+             *memory-store*)
+    (nreverse results)))
+
+(defun context-query-with-time (&key (max-results 20) type-filter todo-filter since until)
+  "Extended context query with temporal filtering.
+When :since and/or :until are provided, filters results by memory-object version.
+Falls back to context-query if temporal filtering is not requested."
+  (let* ((all (if (fboundp 'memory-objects-by-attribute)
+                  (if type-filter
+                      (memory-objects-by-attribute :TYPE type-filter)
+                      (let ((results nil))
+                        (maphash (lambda (id obj)
+                                   (declare (ignore id))
+                                   (push obj results))
+                                 *memory-store*)
+                        results))
+                  (let ((results nil))
+                    (maphash (lambda (id obj)
+                               (declare (ignore id))
+                               (push obj results))
+                             *memory-store*)
+                    results)))
+         (time-filtered (cond
+                          ((and since until)
+                           (remove-if (lambda (obj)
+                                        (let ((v (memory-object-version obj)))
+                                          (not (and (>= v since) (<= v until)))))
+                                      all))
+                          (since
+                           (remove-if (lambda (obj)
+                                        (< (memory-object-version obj) since))
+                                      all))
+                          (until
+                           (remove-if (lambda (obj)
+                                        (> (memory-object-version obj) until))
+                                      all))
+                          (t all))))
+    (let ((todo-filtered (if todo-filter
+                             (remove-if-not (lambda (obj)
+                                              (string-equal (getf (memory-object-attributes obj) :TODO-STATE "") todo-filter))
+                                            time-filtered)
+                             time-filtered)))
+      (subseq todo-filtered 0 (min max-results (length todo-filtered))))))
+
+(eval-when (:compile-toplevel :load-toplevel :execute)
+  (ql:quickload :fiveam :silent t))
+
+(defpackage :passepartout-time-memory-tests
+  (:use :cl :fiveam :passepartout)
+  (:export #:time-memory-suite))
+
+(in-package :passepartout-time-memory-tests)
+
+(def-suite time-memory-suite :description "Temporal memory filtering")
+(in-suite time-memory-suite)
+
+(test test-memory-objects-since
+  "Contract 1: ingest at T0 and T1, verify memory-objects-since(T1) returns only T1 nodes."
+  (clrhash passepartout::*memory-store*)
+  (let ((t0 (get-universal-time)))
+    (sleep 1)
+    (ingest-ast (list :type :HEADLINE :properties (list :ID "time-a" :TITLE "A") :contents nil))
+    (ingest-ast (list :type :HEADLINE :properties (list :ID "time-b" :TITLE "B") :contents nil))
+    (sleep 1)
+    (let ((t1 (get-universal-time)))
+      (sleep 1)
+      (ingest-ast (list :type :HEADLINE :properties (list :ID "time-c" :TITLE "C") :contents nil))
+      (ingest-ast (list :type :HEADLINE :properties (list :ID "time-d" :TITLE "D") :contents nil))
+      (let ((since-t1 (passepartout::memory-objects-since t1)))
+        (is (= 2 (length since-t1)))
+        (let ((ids (sort (mapcar #'memory-object-id since-t1) #'string<)))
+          (is (string= "time-c" (first ids)))
+          (is (string= "time-d" (second ids))))
+        (let ((since-t0 (passepartout::memory-objects-since t0)))
+          (is (= 4 (length since-t0))))))))
+
+(test test-memory-objects-in-range
+  "Contract 2: ingest nodes, verify range query returns correct subset."
+  (clrhash passepartout::*memory-store*)
+  (let ((t0 (get-universal-time)))
+    (sleep 1)
+    (ingest-ast (list :type :HEADLINE :properties (list :ID "rng-1" :TITLE "One") :contents nil))
+    (sleep 1)
+    (let ((t1 (get-universal-time)))
+      (sleep 1)
+      (ingest-ast (list :type :HEADLINE :properties (list :ID "rng-2" :TITLE "Two") :contents nil))
+      (sleep 1)
+      (let ((t2 (get-universal-time)))
+        (sleep 1)
+        (ingest-ast (list :type :HEADLINE :properties (list :ID "rng-3" :TITLE "Three") :contents nil))
+        (let ((range (passepartout::memory-objects-in-range t1 t2)))
+          (is (= 1 (length range)))
+          (is (string= "rng-2" (memory-object-id (first range)))))))))