[OMEGA-179 & OMEGA-183] Context Frames

.gitignore

@@ -6,6 +6,13 @@ chroma_db/
 # pulled in repos
 repos/
 
+# virtual environments
+.venv/
+venv/
+
+# logs 
+*.log
+
 # secrets
 .env
 memory/.channel/

Autotests/mock/conftest.py

@@ -60,3 +60,13 @@ def comm():
         yield server
     finally:
         server.stop(5)
+
+
+# Answers and the frames they were served for do not outlive the test that
+# registered them, so a frame left unfinished by one test cannot answer for
+# the next one.
+@pytest.fixture(autouse=True)
+def reset_llm(request):
+    yield
+    if "llm" in request.fixturenames:
+        request.getfixturevalue("llm").reset(5)

Autotests/mock/llm.py

@@ -6,17 +6,49 @@
 except ImportError:
     from rpc import Rpc, IPCClient, IPCServer
 from contextlib import contextmanager
+import re
 import threading
 
 LLM_MOCK_PORT = 9765
 
+FRAME_SECTION_HEADER = "CURRENT_CONTEXT_FRAME_S_EXPR:"
+FRAME_SECTION_END = "_newline_SKILLS:"
+FRAME_COMPLETION_SKILLS = ("complete-goals-stm", "complete-goals-ltm", "clear-frame-junk")
+FRAME_COMPLETION_ANSWER = '(complete-goals-stm "Answered by the mock, frame completed by the test harness.")'
+FRAME_COMPLETION_ATTEMPTS = 2
+FRAME_ID = re.compile(r"\(frameID\s+([^)\s]+)\)")
+
+
+def unescape(text):
+    return (text
+            .replace("_apostrophe_", "'")
+            .replace("_quote_", '"')
+            .replace("_newline_", "\n"))
+
+
+def frame_section(prompt):
+    start = prompt.find(FRAME_SECTION_HEADER)
+    if start < 0:
+        return None
+    start += len(FRAME_SECTION_HEADER)
+    end = prompt.find(FRAME_SECTION_END, start)
+    return prompt[start:] if end < 0 else prompt[start:end]
+
+
+def frame_id(section):
+    found = FRAME_ID.search(section)
+    return found.group(1) if found else "unknown-frame"
+
+
 class LlmMockAgent:
 
     def __init__(self, address):
         self._lock = threading.Lock()
         self._answers = {}
+        self._served = {}
         self._rpc = Rpc(IPCClient(address))
         self._rpc.on_request('set_answer', lambda args: self.on_set_answer(args))
+        self._rpc.on_request('reset', lambda args: self.on_reset(args))
         self._rpc.on_request('ping', lambda args: self.on_ping(args))
         self._rpc.start()
 
@@ -28,57 +60,114 @@ def chat(self, content):
         if len(user) < 2:
             return ""
 
+        message = self._message(user[1])
+        if message is not None:
+            answer = self._message_answer(message)
+            if answer:
+                print(f"[LlmMockAgent] Mock answers: {answer}")
+                return answer
+
+        section = frame_section(user[0])
+        if section is not None:
+            return self._frame_answer(section)
+
+        if message is not None:
+            print(f"[LlmMockAgent] Mock doesn't have answer for: {message}")
+        return ""
+
+    def _message(self, suffix):
         try:
-            body = eval(user[1])[1]
-        except SyntaxError:
-            return ""
+            return eval(suffix)[1]
+        except Exception:
+            return None
 
+    def _message_answer(self, body):
         # The agent escapes punctuation that would confuse its s-exp
         # parser ('->_apostrophe_, "->_quote_, \n->_newline_) before
         # the text reaches chat(). set_answer stores the literal
         # prompt key, so try the raw body first, then the normalized
         # form so prompts with quotes/apostrophes/newlines still match.
-        def normalize(text):
-            return (text
-                    .replace("_apostrophe_", "'")
-                    .replace("_quote_", '"')
-                    .replace("_newline_", "\n"))
-
         with self._lock:
-            answer = self._answers.get(body) or self._answers.get(normalize(body))
+            answer = self._response(self._answers.get(body) or self._answers.get(unescape(body)))
         if answer:
-            print(f"[LlmMockAgent] Mock answers: {answer}")
             return answer
 
         # IRC may deliver multiple PRIVMSGs in one agent iteration; the
         # agent concatenates them with " | " between speakers. Split
         # and look up each fragment individually so a registered answer
         # is not missed when several messages arrive together.
-        fragments = body.split(" | ")
-        for fragment in fragments:
+        for fragment in body.split(" | "):
             if ": " not in fragment:
                 continue
             prompt = fragment.split(": ", 1)[1]
             with self._lock:
-                a = self._answers.get(normalize(prompt)) or self._answers.get(prompt)
-            if a:
-                answer = a
+                found = self._answers.get(unescape(prompt)) or self._answers.get(prompt)
+            if found:
+                answer = self._response(found)
+
+        return answer
+
+    # With context frames the received message is no longer passed after
+    # the ":-:-:-:" delimiter: the delimiter carries a loop signal and the
+    # text becomes the current frame, projected into the prompt under
+    # CURRENT_CONTEXT_FRAME_S_EXPR. Matching against that section rather
+    # than the whole prompt keeps the mock honest: a message that was
+    # admitted but did not become current is not answered.
+    def _frame_answer(self, section):
+        current = unescape(section)
+        frame = frame_id(section)
 
-        if answer:
-            print(f"[LlmMockAgent] Mock answers: {answer}")
-            return answer
-        else:
-            print(f"[LlmMockAgent] Mock doesn't have answer for: {body}")
-            return ""
+        with self._lock:
+            match = None
+            for request, entry in self._answers.items():
+                if request in current or unescape(request) in current:
+                    match = (request, entry)
+                    break
+
+            if match is None:
+                print(f"[LlmMockAgent] Mock doesn't have answer for frame: {frame}")
+                return ""
+
+            request, (response, complete_frame) = match
+            served = self._served.get((frame, request), 0)
+            self._served[(frame, request)] = served + 1
+
+        # A frame outlives the iteration that answered it, so the answer is
+        # served once. While the same frame keeps coming back the harness
+        # completes it instead, otherwise the next message is admitted but
+        # never becomes current and every later test fails with it.
+        if served == 0:
+            if complete_frame and not any(skill in response for skill in FRAME_COMPLETION_SKILLS):
+                response = f"{response} {FRAME_COMPLETION_ANSWER}"
+            print(f"[LlmMockAgent] Mock answers: {response}")
+            return response
+
+        if complete_frame and served <= FRAME_COMPLETION_ATTEMPTS:
+            print(f"[LlmMockAgent] Frame {frame} is still current, completing it")
+            return FRAME_COMPLETION_ANSWER
+
+        print(f"[LlmMockAgent] Frame {frame} was already answered")
+        return ""
+
+    def _response(self, entry):
+        return entry[0] if entry else None
 
     def on_set_answer(self, args):
         with self._lock:
             request = args['request']
             response = args['response']
+            complete_frame = args.get('complete_frame', True)
             print(f'[LlmMockAgent] Mock request: "{request}" with response "{response}"')
-            self._answers[request] = response
+            self._answers[request] = (response, complete_frame)
             return True
 
+    def on_reset(self, args):
+        with self._lock:
+            self._answers.clear()
+            self._served.clear()
+        print('[LlmMockAgent] Mock answers cleared')
+        return True
+
     def on_ping(self, args):
         print(f'[LlmMockAgent] Mock ping request processed')
         return True
@@ -92,13 +181,21 @@ def __init__(self, address):
     def stop(self, timeout=None):
         self._rpc.stop(timeout)
 
-    def set_answer(self, request, response, timeout=10):
-        result = self._rpc.request('set_answer', { 'request': request, 'response': response })
+    def set_answer(self, request, response, complete_frame=True, timeout=10):
+        result = self._rpc.request('set_answer', { 'request': request, 'response': response,
+                                                   'complete_frame': complete_frame })
         if result.get(timeout) != True:
             print(f'[LlmMockController] Cannot set answer to the mock, error: {result.error()}')
             return False
         return True
 
+    def reset(self, timeout=10):
+        result = self._rpc.request('reset', {})
+        if result.get(timeout) != True:
+            print(f'[LlmMockController] Cannot reset the mock, error: {result.error()}')
+            return False
+        return True
+
     def ping(self, timeout=None):
         print(f'[LlmMockController] Ping agent')
         result = self._rpc.request('ping', {})

Autotests/mock/test_llm.py

@@ -5,6 +5,27 @@
 
 TEST_ADDRESS = (LOCALHOST, 9767)
 
+FRAME = "Frame-20260729T144803343500Z"
+OTHER_FRAME = "Frame-20260729T144839020270Z"
+SIGNAL = "NEW_INPUT_HAS_BEEN_ADMITTED_AS_ACTIVE_FRAME."
+
+
+def frame_prompt(deliverable, frame=FRAME, signal=SIGNAL):
+    return (
+        "PROMPT: You are a OmegaClaw agentic harness in a continuous loop._newline_"
+        "RUNTIME-PROMPT: The current frame is the authoritative task state._newline_"
+        "CURRENT_CONTEXT_FRAME_S_EXPR: (ContextProjection (RootFrame (RootFrame RootFrame-1 "
+        f"(current-frame-id {frame}) (last-admitted-frame-id {frame}) (mode Fast))) "
+        f"(CurrentFrame (Frame (frameID {frame}) (parent-frameID ()) (source UserDirective) "
+        "(priority 1.0) (status Active) (frame-mode Fast) "
+        f"(history-summary sha256:a48d311b2a4172dc chars:{len(deliverable)} excerpt:{deliverable}) "
+        f"(deliverables ({deliverable})) (results ()))))_newline_"
+        "SKILLS: - Remember a particular string: remember string_newline_"
+        "OUTPUT_FORMAT: Up to 5 lines_newline_"
+        "TIME: 2026-07-29 14:48:03"
+        f":-:-:-:{signal}"
+    )
+
 class TestLlmMock:
 
     def setup_class(cls):
@@ -64,3 +85,111 @@ def test_context_manager_timeout(self, agent):
                 assert False
         except RuntimeError as e:
             assert e.args == ("Agent didn't answered in 2 seconds",)
+
+    def test_iteration_without_message_is_silent(self, agent, controller, capsys):
+        assert controller.set_answer("hello", "world")
+        capsys.readouterr()
+
+        assert agent.chat("PROMPT: nothing new here:-:-:-:") == ""
+
+        assert "Mock doesn't have answer" not in capsys.readouterr().out
+
+    def test_missing_answer_is_reported_with_the_message(self, agent, controller, capsys):
+        assert controller.set_answer("hello", "world")
+        capsys.readouterr()
+
+        assert agent.chat(":-:-:-:['HUMAN-MSG', 'test: goodbye']") == ""
+
+        assert "Mock doesn't have answer for: test: goodbye" in capsys.readouterr().out
+
+    def test_reset_drops_answers(self, agent, controller):
+        assert controller.set_answer("hello", "world")
+        assert agent.chat(":-:-:-:['HUMAN-MSG', 'test: hello']") == "world"
+        assert controller.reset()
+        assert agent.chat(":-:-:-:['HUMAN-MSG', 'test: hello']") == ""
+
+
+class TestLlmMockContextFrames:
+
+    @pytest.fixture
+    def agent(self):
+        agent = LlmMockAgent(TEST_ADDRESS)
+        yield agent
+        agent.stop(5)
+
+    @pytest.fixture
+    def controller(self):
+        controller = LlmMockController(TEST_ADDRESS)
+        yield controller
+        controller.stop(5)
+
+    def test_answer_matched_against_current_frame(self, agent, controller):
+        request = "[REQ-1] please write Hello into /tmp/hello.txt"
+        assert controller.set_answer(request, '(write-file "/tmp/hello.txt" "Hello")')
+
+        answer = agent.chat(frame_prompt(request))
+
+        assert answer.startswith('(write-file "/tmp/hello.txt" "Hello")')
+
+    def test_answer_completes_the_frame(self, agent, controller):
+        request = "[REQ-2] send Done"
+        assert controller.set_answer(request, '(send "Done")')
+
+        answer = agent.chat(frame_prompt(request))
+
+        assert answer == f'(send "Done") {FRAME_COMPLETION_ANSWER}'
+
+    def test_own_completion_is_not_duplicated(self, agent, controller):
+        request = "[REQ-3] send Done"
+        response = '(send "Done") (complete-goals-ltm "kept for later")'
+        assert controller.set_answer(request, response)
+
+        assert agent.chat(frame_prompt(request)) == response
+
+    def test_frame_kept_open_when_test_asks_for_it(self, agent, controller):
+        request = "[REQ-4] send Done"
+        assert controller.set_answer(request, '(send "Done")', complete_frame=False)
+
+        assert agent.chat(frame_prompt(request)) == '(send "Done")'
+
+    def test_answer_is_served_once_then_frame_is_drained(self, agent, controller):
+        request = "[REQ-5] send Done"
+        assert controller.set_answer(request, '(send "Done")')
+        prompt = frame_prompt(request)
+
+        first = agent.chat(prompt)
+        second = agent.chat(prompt)
+        third = agent.chat(prompt)
+        fourth = agent.chat(prompt)
+
+        assert first.startswith('(send "Done")')
+        assert second == FRAME_COMPLETION_ANSWER
+        assert third == FRAME_COMPLETION_ANSWER
+        assert fourth == ""
+
+    def test_same_request_in_a_new_frame_is_answered_again(self, agent, controller):
+        request = "[REQ-6] send Done"
+        assert controller.set_answer(request, '(send "Done")')
+
+        assert agent.chat(frame_prompt(request)).startswith('(send "Done")')
+        assert agent.chat(frame_prompt(request, frame=OTHER_FRAME)).startswith('(send "Done")')
+
+    def test_escaped_request_matches(self, agent, controller):
+        request = 'don\'t write "Hello world" into\n/tmp/e.txt'
+        escaped = 'don_apostrophe_t write _quote_Hello world_quote_ into_newline_/tmp/e.txt'
+        assert controller.set_answer(request, '(send "ok")')
+
+        assert agent.chat(frame_prompt(escaped)).startswith('(send "ok")')
+
+    def test_unknown_frame_is_not_answered(self, agent, controller):
+        assert controller.set_answer("[REQ-7] something else", '(send "Done")')
+
+        assert agent.chat(frame_prompt("[REQ-8] not registered")) == ""
+
+    def test_request_outside_the_frame_section_is_not_answered(self, agent, controller):
+        request = "[REQ-9] send Done"
+        assert controller.set_answer(request, '(send "Done")')
+        prompt = frame_prompt("another task entirely")
+        prompt = prompt.replace("OUTPUT_FORMAT:", f"LAST_SKILL_USE_RESULTS: {request}_newline_OUTPUT_FORMAT:")
+
+        assert agent.chat(prompt) == ""

Dockerfile

@@ -128,4 +128,4 @@ RUN cp ${OMEGACLAW_DIR}/run.metta /PeTTa/run.metta \
  && chown -R 65534:65534 /opt/huggingface /opt/sentence_transformers
 
 ENTRYPOINT ["/PeTTa/repos/OmegaClaw-Core/entrypoint.sh"]
-CMD []
+CMD []

channels/auth.py

@@ -22,7 +22,8 @@
 def get_proxy_url():
     global _proxy_url
     if _proxy_url is None:
-        _proxy_url = config_get_by_key("GATEWAY_URL", "").rstrip("/")
+        configured_url = config_get_by_key("GATEWAY_URL", "")
+        _proxy_url = str(configured_url or "").strip().rstrip("/")
     return _proxy_url