feat(memory): add observation memory lifecycle (#259)

* feat(memory): add observation memory lifecycle

Add file-backed observation memory with deterministic markdown records,
structured record_observation tooling, startup indexing, and
profile/observation prompt guidance.

Launch post-turn and post-subagent EvoMemory workers through LangGraph
dev so completed runs can update profile memory, save durable
observations, and write subagent execution summaries without blocking
the active agent.

Wire memory middleware into the main agent, subagents, async graphs, TUI
status reporting, worker activity accounting, and observation-aware
research prompts, with regression coverage for storage, lifecycle
scheduling, graph registration, status display, and stream reset
behavior.

* fix(cli): sync background agent server on resume

Resume flows now need to keep the LangGraph dev background server
aligned with the active workspace even when async subagents are
disabled. EvoMemory workers use that server too, so gating resume-time
sync on enable_async_subagents could leave workers pinned to the launch
workspace after resuming a thread from another workspace.

Run workspace sync unconditionally for Rich CLI and Textual resume
paths, while preserving WorkspaceMismatchError handling so failed sync
aborts the resume before mutating the active thread or workspace.

Propagate aborted resume callbacks through the command UI so
channel-issued /resume commands do not send false success or history
output. Channel slash dispatch now treats CommandManager-caught command
errors as command errors and skips completion hooks for those failed
commands.

Add regression coverage for disabled async subagents, callback aborts,
and channel command error reporting.

* fix(cli): prepare serve resume workspace before adopting

Load the resumed workspace agent and sync the background server as a
single pre-adoption step. Restore the previous active workspace if
preparation fails so serve mode keeps using the old session
consistently.

* fix(memory): untrack abandoned worker status watches

Stop treating watcher shutdown as confirmed worker completion. Terminal
worker statuses still count memory deltas, while poll failures or
watcher setup failures now remove the active run without crediting
partial outputs.

* fix(cli): report channel command failures accurately

Treat command_error as a None sentinel so empty error strings still
fail, and let TUI resumes continue only on non-mismatch
background-server sync failures while reporting degraded mode.

* fix(stream): clear memory counters for resume streams

Reset completed-memory counters for every new agent stream, including
Command-based HITL and resume streams, so saved-memory indicators do not
leak across turns.

* docs(tools): make observation recording guidance conditional

Clarify that agents should call record_observation only when the
observation tool is available, preserving the existing durability and
usefulness criteria.

* feat(config): add controls for profile and observation memory

Add config flags for profile memory, observation memory, observation
writer placement, and background memory workers.

Wire the controls through main agents, subagents, EvoMemory middleware,
and memory lifecycle workers so observation writes can be assigned to
the live agent, subagent worker, both, or neither. Keep turn memory
workers profile-only and make prompts reflect the available observation
read/write paths. Skip langgraph dev startup when neither async
subagents nor memory workers need the background server.

Add coverage for config parsing, prompt gating, middleware wiring, and
worker tool availability.

* test(cli): include memory defaults in serve config stubs

* fix(memory): offload async worker launch blocking calls

Run the langgraph-dev health check and memory-output snapshot in worker
threads from the async EvoMemory launcher so it does not block the event
loop.

* chore(memory): harden turn worker subagent guardrail

* chore(memory): refresh profile context per request

* fix(memory): offload async profile file reads

* fix(memory): offload async worker completion accounting

tests/test_cli_tui_dispatch.py

@@ -1,5 +1,8 @@
 """Tests for CLI interactive UI backend dispatch."""
 
+import asyncio
+from types import SimpleNamespace
+
 import pytest
 
 from EvoScientist.cli.commands import _is_fresh_interactive_session
@@ -77,16 +80,65 @@ def test_main_callback_resume_falls_back_to_cli(monkeypatch):
     assert calls.get("dispatch") == ("cli", "cli")
 
 
+def test_background_agent_server_starts_even_when_async_subagents_disabled(
+    monkeypatch,
+):
+    import EvoScientist.cli.commands as cmds
+
+    calls = []
+
+    def fake_ensure(config, *, workspace_dir):
+        calls.append((config, workspace_dir))
+
+    monkeypatch.setattr(
+        "EvoScientist.langgraph_dev.manager.ensure_langgraph_dev",
+        fake_ensure,
+    )
+
+    config = SimpleNamespace(enable_async_subagents=False)
+    cmds._ensure_async_subagent_server(config, workspace_dir="/tmp/workspace")
+
+    assert calls == [(config, "/tmp/workspace")]
+
+
+def test_resume_workspace_sync_runs_even_when_async_subagents_disabled(
+    monkeypatch,
+):
+    import EvoScientist.cli.commands as cmds
+
+    calls = []
+
+    def fake_ensure(config, *, workspace_dir):
+        calls.append((config, workspace_dir))
+
+    monkeypatch.setattr(
+        "EvoScientist.langgraph_dev.manager.ensure_langgraph_dev",
+        fake_ensure,
+    )
+
+    config = SimpleNamespace(enable_async_subagents=False)
+    asyncio.run(
+        cmds._sync_background_agent_server_workspace(
+            config,
+            workspace_dir="/tmp/resumed-workspace",
+        )
+    )
+
+    assert calls == [(config, "/tmp/resumed-workspace")]
+
+
 def test_cmd_interactive_dispatches_to_textual(monkeypatch):
     captured: dict[str, object] = {}
+    captured_kwargs: list[dict[str, object]] = []
+    effective_config = SimpleNamespace(langgraph_dev_port=9999)
 
     def _fake_resolve_ui_backend(value, *, warn_fallback=False):
         captured["resolved_input"] = value
         captured["warn_fallback"] = warn_fallback
         return "tui"
 
-    def _fake_run_textual_interactive(**kwargs):
-        captured["kwargs"] = kwargs
+    def _fake_run_textual_interactive(**kwargs: object):
+        captured_kwargs.append(kwargs)
 
     monkeypatch.setattr(
         "EvoScientist.cli.interactive.resolve_ui_backend",
@@ -108,13 +160,14 @@ def test_cmd_interactive_dispatches_to_textual(monkeypatch):
         run_name="demo-run",
         thread_id="thread-1",
         ui_backend="tui",
+        config=effective_config,
     )
 
     assert captured["resolved_input"] == "tui"
     assert captured["warn_fallback"] is True
 
-    kwargs = captured["kwargs"]
-    assert isinstance(kwargs, dict)
+    assert len(captured_kwargs) == 1
+    kwargs = captured_kwargs[0]
     assert kwargs["workspace_dir"] == "/tmp/workspace"
     assert kwargs["workspace_fixed"] is True
     assert kwargs["mode"] == "daemon"
@@ -122,6 +175,7 @@ def test_cmd_interactive_dispatches_to_textual(monkeypatch):
     assert kwargs["provider"] == "demo-provider"
     assert kwargs["run_name"] == "demo-run"
     assert kwargs["thread_id"] == "thread-1"
+    assert kwargs["config"] is effective_config
     assert kwargs["channel_send_thinking"] is True
     assert callable(kwargs["load_agent"])
     assert callable(kwargs["create_session_workspace"])