superlocalmemory 4.0.9 → 4.1.0

package/src/superlocalmemory/encoding/prospective_markers.py

@@ -0,0 +1,262 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Does this sentence describe something that has not happened yet?
+
+A prospective memory is a plan: a deadline, an appointment, a scheduled event,
+something with a date still ahead of it. It is a different kind of memory from
+a record of what happened, and it is meant to be small and precise — the
+handful of things a user is waiting on.
+
+WHY THIS MODULE EXISTS
+
+Two different regexes used to answer this question, one in ``fact_extractor``
+and one in ``type_router``, and they disagreed. Measured on a real 468 MB
+store: 869 facts carried the prospective type and **7** contained any planning
+language at all. The rest were session summaries and records of completed work.
+
+The extractor's pattern contained ``by \\w+``, which matches every passive-voice
+and attribution sentence ever written — "was caused **by a** stale DNS entry" —
+and ``yesterday``, which cannot indicate a plan. The router's contained bare
+``ends?``, so "the service ends at midnight" was a plan.
+
+WHAT REPLACED THEM
+
+Two tiers, because the evidence really is of two strengths:
+
+*Definite* markers point forward on their own. "Tomorrow" is tomorrow whatever
+else the sentence says, and a deadline is a deadline.
+
+*Circumstantial* markers — a weekday, a clock time, "starts", "in three days" —
+are shaped like a plan but read equally well as narration. They count only when
+nothing in the sentence says the thing already happened.
+
+The asymmetry is deliberate. A plan wrongly filed as an ordinary memory is
+still found by every other channel and costs a user nothing. An ordinary
+memory wrongly filed as a plan pollutes the one list a user checks to see what
+is coming up. **When in doubt, it is not a plan.**
+"""
+
+from __future__ import annotations
+
+import re
+
+__all__ = [
+    "ANCHORED_FUTURE",
+    "PLANNING_LANGUAGE",
+    "CIRCUMSTANTIAL_FUTURE",
+    "RECURRING",
+    "ALREADY_HAPPENED",
+    "CALLED_OFF",
+    "PLACEMENT",
+    "RESCHEDULING",
+    "DEFINITE_FUTURE",
+    "looks_prospective",
+]
+
+_WEEKDAY = r"(?:mon|tues?|wednes|thurs?|fri|satur|sun)day"
+_MONTH = (
+    r"(?:january|february|march|april|may|june|july|august|september|"
+    r"october|november|december|jan|feb|mar|apr|jun|jul|aug|sep|sept|oct|nov|dec)"
+)
+
+#: Points forward on its own, whatever else the sentence says. Every member
+#: carries an explicit forward time anchor, so "rescheduled to next Friday" is
+#: still a plan even though "rescheduled" reads as past.
+ANCHORED_FUTURE = re.compile(
+    r"\b(?:"
+    r"tomorrow|"
+    r"next\s+(?:week|weekend|month|year|quarter|sprint|release|" + _WEEKDAY + r")|"
+    r"this\s+(?:coming|weekend)|"
+    r"upcoming\s+(?:release|meeting|week|month|sprint|deadline|event|launch|"
+    r"call|review|milestone)|"
+    r"by\s+(?:end\s+of|eod|eow|cob|" + _WEEKDAY + r"|" + _MONTH + r"|\d{4}-\d{2}-\d{2})|"
+    r"due\s+(?:date|by|on|" + _WEEKDAY + r"|" + _MONTH + r")"
+    r")\b",
+    re.IGNORECASE,
+)
+
+#: The vocabulary of planning. These words are ABOUT something being planned,
+#: and they read exactly as well in the past: a deadline can be missed, an
+#: appointment cancelled, a launch date long gone. They count only when nothing
+#: says the thing already happened.
+#:
+#: Treating them as definite is what re-polluted the list this module exists to
+#: clean — "the appointment was cancelled yesterday" was filed as something to
+#: look forward to.
+PLANNING_LANGUAGE = re.compile(
+    r"\b(?:"
+    r"deadline|"
+    r"appointment|"
+    r"before\s+(?:" + _WEEKDAY + r"|" + _MONTH + r"|\d{4}-\d{2}-\d{2})|"
+    r"expir(?:es|ing|e)\s+(?:on|at)\s+(?:" + _WEEKDAY + r"|" + _MONTH + r"|\d)|"
+    r"expir(?:y|ation)\s+date|"
+    r"scheduled?\s+(?:for|on|at|to)|reschedul(?:e|ed|ing)|"
+    r"plans?\s+to|planning\s+to|"
+    r"go[-\s]?live|cut[-\s]?over|launch\s+date|"
+    r"will\s+(?:happen|start|begin|expire|ship|launch|resume|reopen|take\s+place)|"
+    r"will\s+be\s+(?:deleted|removed|released|deployed|held|published|migrated|"
+    r"archived|retired|rotated|decommissioned|shut\s+down)|"
+    r"going\s+to\s+(?:happen|ship|start|launch|begin)"
+    r")\b",
+    re.IGNORECASE,
+)
+
+#: Kept for callers that imported the old name; the two tiers together are what
+#: it used to mean.
+DEFINITE_FUTURE = ANCHORED_FUTURE
+
+#: Shaped like a plan, but reads equally well as narration.
+CIRCUMSTANTIAL_FUTURE = re.compile(
+    r"\b(?:"
+    r"on\s+" + _WEEKDAY + r"|"
+    r"(?:is|are)\s+(?:this\s+)?" + _WEEKDAY + r"|"
+    r"this\s+(?:week|" + _WEEKDAY + r")|"
+    r"at\s+\d{1,2}:\d{2}|"
+    r"in\s+\d+\s+(?:days?|weeks?|months?|years?)|"
+    r"(?:starts?|begins?|resumes?|reopens?)\s+(?:on|at)|"
+    r"(?:on|at)\s+\d{4}-\d{2}-\d{2}|"
+    r"meeting\s+(?:on|at)"
+    r")\b",
+    re.IGNORECASE,
+)
+
+#: A thing that happens on a cycle is not a thing that is coming up. "Standup at
+#: 09:30 every day" belongs in nobody's list of what to expect this week.
+RECURRING = re.compile(
+    r"\b(?:every|each)\s+(?:day|week|month|morning|afternoon|evening|night|"
+    r"sprint|release|" + _WEEKDAY + r")|\b(?:daily|weekly|monthly|nightly|"
+    r"hourly|per\s+request|recurring)\b",
+    re.IGNORECASE,
+)
+
+#: Verbs that PUT an event on a date, rather than report on one. "Rescheduled
+#: to next Friday" and "was scheduled for next Monday" are both still plans;
+#: "discussed the deadline for next month" is a record of a conversation. All
+#: three are past-tense sentences containing a forward date, and only the first
+#: two are something to look forward to — so a forward anchor overrides the past
+#: only when one of these is what made the sentence past.
+#:
+#: The passive forms matter more than they look: people write notes that way
+#: ("the appointment was booked for Tuesday"), and leaving them out missed a
+#: whole class of ordinary phrasing.
+PLACEMENT = re.compile(
+    r"\b(?:reschedul(?:e|ed|ing)|mov(?:e|ed|ing)\s+to|postpon(?:e|ed|ing)|"
+    r"push(?:ed)?\s+(?:to|back)|shift(?:ed)?\s+to|defer(?:red)?\s+to|"
+    r"brought\s+forward|pull(?:ed)?\s+forward|bumped\s+to|"
+    r"(?:scheduled?|booked|planned|slated|arranged|set|pencilled|penciled)\s+"
+    r"(?:for|on|at|to)|"
+    r"extend(?:ed)?\s+to|mov(?:e|ed)\s+forward\s+to|"
+    r"chang(?:e|ed)\s+(?:the\s+)?(?:\w+\s+)?"
+    r"(?:date|deadline|time|schedule|window)\s+to)\b",
+    re.IGNORECASE,
+)
+
+#: The old name, kept because it reads in the one place it is used.
+RESCHEDULING = PLACEMENT
+
+#: Says the thing has already happened. Vetoes anything but an anchored future
+#: that was anchored BY a rescheduling.
+ALREADY_HAPPENED = re.compile(
+    r"\b(?:"
+    r"yesterday|"
+    r"last\s+(?:night|week|month|year|" + _WEEKDAY + r")|"
+    r"\d+\s+(?:days?|weeks?|months?|years?)\s+ago|ago|"
+    r"already|"
+    r"was|were|had\s+been|has\s+been|have\s+been|"
+    r"did|done|"
+    r"complet(?:e|ed)|finish(?:ed)?|"
+    r"shipped|released|landed|merged|deployed|"
+    r"fixed|resolved|closed|cancelled|canceled|missed|happened|expired|"
+    r"turned\s+out|ended|began|begun|started|"
+    r"produced|caused|created|caught|found|"
+    r"updated|changed|edited|modified|renamed|bumped|committed|"
+    r"restarted|configured|installed|"
+    r"had|met|arrived|attended|ate|spoke|talked|visited|saw|"
+    # deleted / removed / added are deliberately absent: each is both a simple
+    # past AND the participle in a future passive, and "the worktrees will be
+    # deleted" is a plan. The future-passive list in PLANNING_LANGUAGE is the
+    # narrower half of that ambiguity and it is the half worth keeping.
+    r"decided|agreed|discussed|reviewed|reported|"
+    r"ran|wrote|built|took|made|went|came|said|led|"
+    r"failed|passed|broke|resulted"
+    r")\b",
+    re.IGNORECASE,
+)
+
+
+#: The event is off. This outranks everything, including a present-tense clause
+#: saying when it was going to be.
+CALLED_OFF = re.compile(
+    r"\b(?:cancel(?:led|ed|s)?|called\s+off|scrapped|abandoned|"
+    r"dropped|shelved|withdrawn|no\s+longer\s+(?:happening|planned|scheduled))\b",
+    re.IGNORECASE,
+)
+
+
+#: A present-tense statement that something is on a future date: "the launch is
+#: next Friday", "the freeze starts Monday", "the review is this Tuesday".
+#: Present tense about a forward date is a plan whatever else the surrounding
+#: sentence reports having done.
+#:
+#: Every part of this is bounded on both sides. A first attempt was not, and it
+#: matched "is dec" inside "is decision", "are mar" inside "are marked", and
+#: "this a" inside "is this a" — turning 14 memories into 72 on a real store.
+#: An unbounded month abbreviation is a trap in any prose.
+_FUTURE_FACT = re.compile(
+    r"\b(?:is|are|starts?|begins?|opens?|closes?|resumes?|reopens?|runs?|"
+    r"lands?|ships?|goes\s+live|kicks\s+off)\s+"
+    r"(?:on\s+|at\s+)?"
+    r"(?:"
+    r"tomorrow"
+    r"|next\s+(?:week|weekend|month|year|quarter|sprint|release|" + _WEEKDAY + r")"
+    r"|this\s+(?:coming\s+)?(?:week|weekend|" + _WEEKDAY + r")"
+    r"|" + _WEEKDAY +
+    r"|\d{4}-\d{2}-\d{2}"
+    r")\b",
+    re.IGNORECASE,
+)
+
+
+def _states_a_future_fact(text: str) -> bool:
+    """Present tense about a forward date, inside any sentence."""
+    return bool(_FUTURE_FACT.search(text))
+
+
+def looks_prospective(text: str) -> bool:
+    """True when the text describes something still ahead.
+
+    Three tiers, because the evidence really is of three strengths. An anchored
+    future — "next Tuesday", "by Friday", "on 2026-09-04" — points forward
+    whatever else the sentence says. Planning vocabulary and circumstantial
+    wording both read equally well in the past, so they count only when nothing
+    says the thing already happened. Anything on a cycle is not a plan at all.
+    """
+    if not text:
+        return False
+    behind = ALREADY_HAPPENED.search(text)
+    if CALLED_OFF.search(text):
+        # "The deadline is next Friday but was cancelled yesterday" reads as a
+        # future fact and is not one. Cancelling is the one thing that beats a
+        # present-tense statement about a forward date.
+        return False
+    if _states_a_future_fact(text):
+        # "I updated the timeline so the launch IS next Friday" — the past-tense
+        # verb is about the note, and the clause with the date is in the present
+        # about something ahead. A veto that scans the whole sentence cannot see
+        # that difference and drops a real deadline.
+        return True
+    if ANCHORED_FUTURE.search(text):
+        # Checked BEFORE the recurring veto. "The weekly review is next Tuesday"
+        # names one dated occurrence of a recurring thing, and that occurrence
+        # is coming up; "weekly" describes the series, not this instance.
+        # A forward anchor beats the past only when the past word is what moved
+        # the event. "Rescheduled to next Friday" is a plan; "discussed the
+        # deadline for next month" is a record of a conversation.
+        return not behind or bool(RESCHEDULING.search(text))
+    if RECURRING.search(text):
+        return False
+    if PLANNING_LANGUAGE.search(text) or CIRCUMSTANTIAL_FUTURE.search(text):
+        return not behind
+    return False

package/src/superlocalmemory/encoding/type_router.py

@@ -19,6 +19,7 @@ import logging
 import re
 from typing import TYPE_CHECKING
 
+from superlocalmemory.encoding.prospective_markers import looks_prospective
 from superlocalmemory.storage.models import AtomicFact, FactType, Mode
 
 if TYPE_CHECKING:
@@ -73,12 +74,6 @@ _OPINION_MARKERS = re.compile(
     re.IGNORECASE,
 )
 
-_TEMPORAL_MARKERS = re.compile(
-    r"\b(scheduled|deadline|appointment|planned|tomorrow|"
-    r"next week|next month|upcoming|due date|starts?|ends?|"
-    r"will happen|going to|plan to)\b",
-    re.IGNORECASE,
-)
 
 _EPISODIC_MARKERS = re.compile(
     r"\b(went|visited|traveled|attended|met|saw|did|"
@@ -91,7 +86,7 @@ class TypeRouter:
     """Route facts to typed stores based on content classification.
 
     Uses embedding similarity (Mode A) or LLM (Mode B/C) to classify
-    each fact as episodic, semantic, opinion, or temporal.
+    each fact as episodic, semantic, opinion, or prospective.
     """
 
     def __init__(
@@ -155,8 +150,8 @@ class TypeRouter:
 
         if _OPINION_MARKERS.search(text):
             return FactType.OPINION
-        if _TEMPORAL_MARKERS.search(text):
-            return FactType.TEMPORAL
+        if looks_prospective(text):
+            return FactType.PROSPECTIVE
         if _EPISODIC_MARKERS.search(text):
             return FactType.EPISODIC
         return FactType.SEMANTIC
@@ -199,7 +194,7 @@ class TypeRouter:
             f"- episodic: An event that happened (who did what when)\n"
             f"- semantic: A general fact about the world (X is Y)\n"
             f"- opinion: A subjective belief or preference\n"
-            f"- temporal: A scheduled/planned future event\n"
+            f"- prospective: A scheduled/planned future event\n"
             f"Reply with ONLY the category name (one word)."
         )
         try:
@@ -208,7 +203,12 @@ class TypeRouter:
                 "episodic": FactType.EPISODIC,
                 "semantic": FactType.SEMANTIC,
                 "opinion": FactType.OPINION,
-                "temporal": FactType.TEMPORAL,
+                "prospective": FactType.PROSPECTIVE,
+                # The prompt asked for "temporal" until 4.1.0. Both words are
+                # accepted because a model does not always echo the current
+                # prompt, and an unrecognised word falls through to SEMANTIC —
+                # a silently wrong type rather than a visible failure.
+                "temporal": FactType.PROSPECTIVE,
             }
             return type_map.get(response, FactType.SEMANTIC)
         except Exception:
@@ -223,7 +223,7 @@ class TypeRouter:
             FactType.EPISODIC: self._embedder.embed_batch(_EPISODIC_TEMPLATES),
             FactType.SEMANTIC: self._embedder.embed_batch(_SEMANTIC_TEMPLATES),
             FactType.OPINION: self._embedder.embed_batch(_OPINION_TEMPLATES),
-            FactType.TEMPORAL: self._embedder.embed_batch(_TEMPORAL_TEMPLATES),
+            FactType.PROSPECTIVE: self._embedder.embed_batch(_TEMPORAL_TEMPLATES),
         }
 
 

package/src/superlocalmemory/evolution/mutation_generator.py

@@ -94,14 +94,38 @@ def parse_mutation_output(output: str) -> Optional[str]:
 # secret-exfiltration instructions must never be persisted. Structure checks
 # alone are insufficient — reject dangerous content outright.
 _SKILL_DENY_PATTERNS: tuple[str, ...] = (
-    "os.environ", "subprocess", "exec(", "eval(", "__import__", "import os",
-    "import subprocess", "pickle.loads", "curl ", "wget ", "rm -rf",
-    "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "AWS_SECRET", "/.ssh/", ".install_token",
+    # Reading the environment. "os.environ" was listed and "os.getenv" was not,
+    # which is the same act spelled the other way.
+    "os.environ", "os.getenv", "getenv(", "environ[",
+    # Running things.
+    "subprocess", "import subprocess", "import os", "__import__",
+    "exec(", "eval(", "compile(", "os.system", "os.popen", "os.spawn",
+    "popen(", "pty.spawn", "runpy",
+    # PowerShell and Windows shells, which were absent entirely.
+    "invoke-webrequest", "invoke-expression", "iex ", "start-process",
+    "new-object net.webclient", "powershell -", "cmd.exe /c",
+    # POSIX shells and fetchers. The trailing space is gone: "curl" at the end
+    # of a line, or followed by a newline, was not matched.
+    "curl", "wget", "rm -rf", "bash -c", "sh -c", "zsh -c", "nc -",
+    # Network from inside Python.
+    "requests.get", "requests.post", "urllib.request", "httpx.get",
+    "httpx.post", "socket.socket", "smtplib",
+    # Deserialisation and encoding used to smuggle payloads.
+    "pickle.loads", "marshal.loads", "base64.b64decode", "codecs.decode",
+    # Secrets.
+    "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "AWS_SECRET", "AWS_ACCESS_KEY",
+    "/.ssh/", ".install_token", ".aws/credentials", ".netrc",
     # Semantic exfiltration patterns — skills must not instruct unauthorized
     # data transfer or bypass of user consent.
     "without consent", "exfiltrat",
 )
 
+#: Whitespace between a name and its opening parenthesis. ``eval (payload)``
+#: runs exactly as ``eval(payload)`` does, and a substring list only saw the
+#: second. Collapsing it before matching closes the whole family rather than
+#: one member of it.
+_CALL_SPACING = re.compile(r"([A-Za-z_][A-Za-z0-9_.]*)\s+\(")
+
 
 def validate_skill_content(content: str) -> Optional[str]:
     """Validate evolved skill content. Returns error message or None if valid."""
@@ -111,7 +135,9 @@ def validate_skill_content(content: str) -> Optional[str]:
         return "Missing YAML frontmatter (no --- found)"
     if content.count("---") >= 2 and "name:" not in content.split("---")[1]:
         return "Missing 'name:' in frontmatter"
-    lowered = content.lower()
+    # Normalise before matching, so a space, a newline or a non-breaking space
+    # between the name and the parenthesis does not walk past the list.
+    lowered = _CALL_SPACING.sub(r"\1(", content.lower().replace("\u00a0", " "))
     for pat in _SKILL_DENY_PATTERNS:
         if pat.lower() in lowered:
             return (f"Rejected: evolved skill contains a disallowed pattern "

package/src/superlocalmemory/graph/cozo_adjacency.py

@@ -0,0 +1,122 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""The graph projection's reader: one profile's edges, for the walk to run over.
+
+WHY THIS EXISTS
+---------------
+Until this module the projection had no reader. It was written on every store,
+drained through an outbox, kept at bidirectional parity with SQLite, and purged
+on erasure -- and nothing in retrieval ever queried it. That is the same failure
+the traversal removed from ``cozo_backend`` had ("correct data that nothing could
+use"), one layer up, and it is the honest answer to "what does the graph engine
+buy us": on its own, nothing. It buys something here.
+
+Measured on a copy of the author's 208,151-edge store, warmed, five runs:
+
+    reading one profile's adjacency     p50
+    SQLite (open + logical-edge query)  2,477 ms
+    graph projection (one query)          395 ms   6.3x
+
+Recall rebuilds that adjacency whenever the edge count changes or the cache TTL
+expires, so this is on the recall path, and the gap widens with edge count.
+
+WHAT IT DELIBERATELY DOES NOT DO
+--------------------------------
+It returns edges. It does not walk them, rank them, or decide what is visible.
+The walk lives once, in ``retrieval/spreading``, as a pure function of a
+snapshot; visibility is applied by the channel, which prunes both endpoints
+against the visible fact corpus. A source that answered questions instead of
+supplying data is exactly the defect the ``AdjacencySource`` seam was carved to
+prevent -- the previous attempt shipped a second, differently-behaved
+implementation of the walk and diverged from SQLite on every query.
+
+WHEN IT DECLINES
+----------------
+Global and shared scope. The projection stores one ``profile_id`` per edge and
+this reader filters on it, so a query that must also see another profile's global
+or shared memories would come back short. It returns ``None`` for those, and the
+channel reads SQLite, which is the only store that can answer them. Failing over
+is not a fallback here; it is the correct answer.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+#: One profile's edges, both directions left to the caller. Selecting the three
+#: columns the walk needs -- and no ``edge_type`` -- lets the engine collapse
+#: parallel typed edges between the same pair, which is what the snapshot does
+#: with them anyway.
+_EDGE_QUERY = (
+    "?[source, target, weight] := *edge{from_id: source, to_id: target, "
+    "                                   weight: weight, profile_id: $pid}"
+)
+
+
+class CozoAdjacencySource:
+    """Supplies one profile's fact graph from the projection. Data only."""
+
+    name = "cozo"
+
+    def __init__(self, backend: Any) -> None:
+        self._backend = backend
+
+    def edges(
+        self,
+        profile_id: str,
+        *,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[tuple[str, str, float]] | None:
+        """Edge triples, or ``None`` when this source cannot answer in full.
+
+        ``None`` is not an error and must not be logged as one -- it is this
+        source saying the question is outside what it holds. A partial answer
+        would silently shrink the graph around a candidate, which is the failure
+        mode that makes a projection worse than no projection.
+        """
+        if include_global or include_shared:
+            return None
+        client = getattr(self._backend, "_db", None)
+        if client is None:
+            return None
+        try:
+            result = client.run(_EDGE_QUERY, {"pid": profile_id})
+        except Exception as exc:  # noqa: BLE001 -- SQLite can always answer this
+            logger.debug("Graph projection unreadable, using SQLite: %s", exc)
+            return None
+        try:
+            return [
+                (str(row[0]), str(row[1]), float(row[2]))
+                for row in result.values.tolist()
+            ]
+        except Exception as exc:  # noqa: BLE001
+            logger.debug("Graph projection returned an unusable shape: %s", exc)
+            return None
+
+
+def adjacency_source() -> CozoAdjacencySource | None:
+    """The live projection's reader, or None when there is not one.
+
+    Resolved through the orchestrator because the daemon is the projection's sole
+    owner: it runs on RocksDB, which takes an exclusive process lock, so a second
+    process opening it would not degrade -- it would fail. ``get_graph_backend``
+    already returns the backend only while its status is active.
+    """
+    try:
+        from superlocalmemory.core.backend_orchestrator import get_orchestrator
+
+        orchestrator = get_orchestrator()
+        if orchestrator is None:
+            return None
+        backend = orchestrator.get_graph_backend()
+        if backend is None:
+            return None
+        return CozoAdjacencySource(backend)
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("No graph projection available: %s", exc)
+        return None