Something went wrong. Try again.
personal memory agent
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384# SPDX-License-Identifier: AGPL-3.0-only# Copyright (c) 2026 sol pbc
from __future__ import annotations
import argparseimport hashlibimport jsonimport loggingimport sysfrom datetime import datetime, timedelta, timezonefrom pathlib import Pathfrom types import SimpleNamespacefrom typing import Any
import pytest
from solstone.think import brain_clifrom solstone.think.journal_io.lease import acquire_file_leasefrom solstone.think.providers import brain_state as brain_state_modulefrom solstone.think.providers.brain_state import ( DEFAULT_READY_EVIDENCE_TTL, BrainProbeOutcome, BrainStateConflictError, begin_brain_refresh, brain_fingerprint_key_path, brain_refresh_lease_path, brain_state_path, finish_brain_refresh,)from tests.openhands_fakes import install_fake_openhands
NOW = datetime(2026, 1, 2, 3, 4, 5, tzinfo=timezone.utc)RUNTIME_FP = "b" * 64
def _write_config(journal: Path, config: dict[str, Any]) -> None: path = journal / "config" / "journal.json" path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(config), encoding="utf-8")
def _cloud_config( *, key: str = "config-secret", model: str = "gpt-5") -> dict[str, Any]: env = {"OPENAI_API_KEY": key} if key else {} return { "providers": {"active": {"provider": "openai", "model": model}}, "env": env, }
def _none_config() -> dict[str, Any]: return {"providers": {"active": {"provider": "none"}}, "env": {}}
def _bundled_config() -> dict[str, Any]: return { "providers": {"active": {"provider": "local", "model": "local/qwen3.5-4b"}}, "env": {}, }
def _endpoint_config(*, confidential: bool = False) -> dict[str, Any]: config: dict[str, Any] = { "providers": { "active": {"provider": "local", "model": "local/qwen3.5-4b"}, "local": { "endpoint_url": "https://brain.example.test/v1", "served_model_id": "served-model", "credential": "endpoint-secret", }, }, "env": {}, } if confidential: config["services"] = { "confidential": { "endpoint_url": "https://brain.example.test", "served_model_id": "served-model", "credential_fingerprint_sha256": hashlib.sha256( b"endpoint-secret" ).hexdigest(), } } return config
def _invalid_endpoint_config() -> dict[str, Any]: return { "providers": { "active": {"provider": "local", "model": "local/qwen3.5-4b"}, "local": {"endpoint_url": "https://brain.example.test/v1"}, }, "env": {}, }
def _component( now: datetime = NOW, *, expires_at: datetime | None = None) -> dict[str, Any]: return { "status": "ok", "observed_at": now.isoformat(), "expires_at": (expires_at or now + DEFAULT_READY_EVIDENCE_TTL).isoformat(), }
def _ready_outcome(now: datetime = NOW) -> BrainProbeOutcome: return { "configuration": _component(now), "lane_prerequisites": _component(now), "generate": _component(now), "cogitate": _component(now), }
def _write_ready_record( journal: Path, config: dict[str, Any], *, now: datetime = NOW, expires_at: datetime | None = None,) -> None: _write_config(journal, config) permit = begin_brain_refresh(now, journal_path=journal) assert permit is not None outcome = _ready_outcome(now) if expires_at is not None: for component in outcome.values(): assert component is not None component["expires_at"] = expires_at.isoformat() finish_brain_refresh(permit, outcome, now, journal_path=journal)
def _health_snapshot(journal: Path) -> dict[str, bytes]: root = journal / "health" if not root.exists(): return {} return { path.relative_to(root).as_posix(): path.read_bytes() for path in sorted(root.rglob("*")) if path.is_file() }
def _args(**kwargs: Any) -> argparse.Namespace: defaults = { "json": False, "expected_fingerprint": None, "expected_active_fingerprint": False, "expect_active_fingerprint_absent": False, } defaults.update(kwargs) return argparse.Namespace(**defaults)
@pytest.fixturedef brain_journal(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path: monkeypatch.setenv("SOLSTONE_JOURNAL", str(tmp_path)) monkeypatch.setattr(brain_cli, "_now", lambda: NOW) monkeypatch.setattr(brain_state_module, "get_journal", lambda: str(tmp_path)) monkeypatch.setattr(brain_cli, "require_solstone", lambda: None) return tmp_path
def _forbid_provider_calls(monkeypatch: pytest.MonkeyPatch) -> None: def fail(*_args: Any, **_kwargs: Any) -> None: raise AssertionError("provider call was not expected")
monkeypatch.setattr(brain_cli, "generate_with_result", fail) monkeypatch.setattr(brain_cli, "get_provider_module", fail)
def _run_status_json(capsys: pytest.CaptureFixture[str]) -> dict[str, Any]: code = brain_cli._run_status(_args(json=True)) out = capsys.readouterr().out payload = json.loads(out) payload["exit_code"] = code return payload
@pytest.mark.parametrize( ("name", "prepare", "expected_state", "expected_reason", "expected_exit"), [ ( "missing", lambda journal, monkeypatch: _write_config(journal, _cloud_config()), "unknown", "brain_record_missing", 2, ), ( "malformed", lambda journal, monkeypatch: ( _write_config(journal, _cloud_config()), brain_state_path(journal_path=journal).parent.mkdir( parents=True, exist_ok=True, ), brain_state_path(journal_path=journal).write_text( "{", encoding="utf-8" ), ), "unknown", "brain_record_invalid", 2, ), ( "configuration-invalid", lambda journal, monkeypatch: _write_config( journal, _invalid_endpoint_config() ), "unknown", "configuration_invalid", 2, ), ( "lane-none", lambda journal, monkeypatch: ( _write_config(journal, _none_config()), begin_brain_refresh(NOW, journal_path=journal), ), "blocked", "thinking_engine_not_chosen", 1, ), ( "fingerprint-key-unavailable", lambda journal, monkeypatch: ( _write_ready_record(journal, _cloud_config()), brain_fingerprint_key_path(journal_path=journal).unlink(), ), "unknown", "fingerprint_key_unavailable", 2, ), ( "checking-in-progress", lambda journal, monkeypatch: ( _write_config(journal, _cloud_config()), monkeypatch.setattr( brain_cli, "_held_permit", begin_brain_refresh(NOW, journal_path=journal), raising=False, ), ), "checking", "brain_check_in_progress", 2, ), ( "checking-interrupted", lambda journal, monkeypatch: _prepare_interrupted_check(journal), "unknown", "brain_check_interrupted", 2, ), ( "config-changed", lambda journal, monkeypatch: ( _write_ready_record(journal, _cloud_config(model="gpt-5")), _write_config(journal, _cloud_config(model="gpt-5.4-mini")), ), "unknown", "brain_config_changed", 2, ), ( "stale-ready", lambda journal, monkeypatch: _write_ready_record( journal, _cloud_config(), expires_at=NOW, ), "unknown", "brain_record_stale", 2, ), ( "healthy-ready", lambda journal, monkeypatch: _write_ready_record(journal, _cloud_config()), "ready", None, 0, ), ],)def test_status_renders_all_projection_states_without_writes_or_provider_calls( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], name: str, prepare, expected_state: str, expected_reason: str | None, expected_exit: int,) -> None: del name prepare(brain_journal, monkeypatch) before = _health_snapshot(brain_journal) _forbid_provider_calls(monkeypatch)
payload = _run_status_json(capsys)
assert payload["aggregate_state"] == expected_state assert payload["reason_code"] == expected_reason assert payload["exit_code"] == expected_exit assert _health_snapshot(brain_journal) == before
held = getattr(brain_cli, "_held_permit", None) if held is not None: held.release()
@pytest.mark.parametrize( ("name", "prepare", "expected_text", "expected_exit"), [ ( "ready", lambda journal, monkeypatch: _write_ready_record(journal, _cloud_config()), "Brain ready:", 0, ), ( "blocked", lambda journal, monkeypatch: ( _write_config(journal, _none_config()), begin_brain_refresh(NOW, journal_path=journal), ), "Brain blocked: no thinking engine chosen", 1, ), ( "unknown", lambda journal, monkeypatch: _write_config( journal, _invalid_endpoint_config() ), "Brain unknown: configuration invalid", 2, ), ( "unhealthy", lambda journal, monkeypatch: _write_unhealthy_record(journal), "Brain unhealthy: provider response invalid (generate)", 1, ), ( "checking", lambda journal, monkeypatch: monkeypatch.setattr( brain_cli, "_held_permit", _prepare_held_check(journal), raising=False, ), "Brain checking: brain check in progress", 2, ), ],)def test_status_human_renders_key_state_classes( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], name: str, prepare, expected_text: str, expected_exit: int,) -> None: del name prepare(brain_journal, monkeypatch) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_status(_args(json=False)) out = capsys.readouterr().out
assert code == expected_exit assert expected_text in out
held = getattr(brain_cli, "_held_permit", None) if held is not None: held.release()
def _prepare_interrupted_check(journal: Path) -> None: _write_config(journal, _cloud_config()) permit = begin_brain_refresh(NOW, journal_path=journal) assert permit is not None permit.release()
def _prepare_held_check(journal: Path): _write_config(journal, _cloud_config()) permit = begin_brain_refresh(NOW, journal_path=journal) assert permit is not None return permit
def _write_unhealthy_record(journal: Path) -> None: _write_config(journal, _cloud_config()) permit = begin_brain_refresh(NOW, journal_path=journal) assert permit is not None finish_brain_refresh( permit, { "configuration": _component(), "lane_prerequisites": _component(), "generate": brain_cli._failed_component(NOW, "provider_response_invalid"), "cogitate": _component(), }, NOW, journal_path=journal, )
@pytest.mark.parametrize( ("raw_reason", "expected_reason", "expected_status"), [ ("nvattest_install_in_progress", "nvattest_install_in_progress", "blocked"), ("nvattest_platform_unsupported", "nvattest_platform_unsupported", "blocked"), ("nvattest_unavailable", "nvattest_unavailable", "blocked"), ("nvattest_install_failed", "nvattest_install_failed", "failed"), ("nvattest_integrity_failed", "nvattest_integrity_failed", "failed"), ("gateway_unreachable", "attestation_not_verified", "blocked"), ("attestation_failed", "attestation_rejected", "failed"), ("pcr_pin_mismatch", "attestation_rejected", "failed"), ],)def test_spp_prerequisite_maps_failure_reason_code( monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture, raw_reason: str, expected_reason: str, expected_status: str,) -> None: from solstone.think.services import spp
spp.delete_attestation_state() caplog.set_level(logging.WARNING, logger=brain_cli.LOG.name) monkeypatch.setattr( "solstone.think.services.spp_transport.recheck_confidential_attestation", lambda: spp.record_attestation_failed("failed", raw_reason), ) try: component, reason = brain_cli._spp_prerequisite(NOW) finally: spp.delete_attestation_state()
assert reason == expected_reason assert component["reason_code"] == expected_reason assert component["status"] == expected_status assert "event=spp_attestation_reason_unmapped" not in caplog.text
def test_spp_prerequisite_warns_and_fails_closed_on_unmapped_reason( monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture,) -> None: from solstone.think.services import spp
spp.delete_attestation_state() monkeypatch.setattr( "solstone.think.services.spp_transport.recheck_confidential_attestation", lambda: spp.record_attestation_failed("failed", "new_raw_reason"), ) caplog.set_level(logging.WARNING, logger=brain_cli.LOG.name) try: component, reason = brain_cli._spp_prerequisite(NOW) finally: spp.delete_attestation_state()
assert reason == "attestation_rejected" assert component["reason_code"] == "attestation_rejected" assert ( "event=spp_attestation_reason_unmapped raw_reason=new_raw_reason" in caplog.text )
def _fake_runtime_inspection( *, phase: str = "ready", desired: str = RUNTIME_FP) -> dict[str, Any]: return { "status": "ok", "provider": "local", "record_kind": "health", "path": "/tmp/local.json", "record": { "schema_version": 1, "provider": "local", "revision": 1, "phase": phase, "reason_code": None, "detail": {}, "desired_fingerprint_sha256": desired, "incarnation": None, "generation": 1, "attempt": 0, "process": None, "updated_at": NOW.isoformat(), "display_deadline_at": None, "owner": None, }, "reason_code": None, "error": None, }
class _FakeProviderModule: def __init__(self, calls: list[dict[str, Any]], result: str | None = "OK") -> None: self.calls = calls self.result = result
async def run_cogitate( self, *, config: dict[str, Any], on_event: Any ) -> str | None: assert on_event is None self.calls.append(config) return self.result
class _ReasonedProviderError(RuntimeError): def __init__(self, reason_code: str) -> None: super().__init__(reason_code) self.reason_code = reason_code
def _patch_generate_and_cogitate( monkeypatch: pytest.MonkeyPatch, *, generate_result: dict[str, Any] | None = None, generate_exc: BaseException | None = None, cogitate_result: str | None = "OK",) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: generate_calls: list[dict[str, Any]] = [] cogitate_calls: list[dict[str, Any]] = []
def fake_generate(*args: Any, **kwargs: Any) -> dict[str, Any]: generate_calls.append({"args": args, "kwargs": kwargs}) if generate_exc is not None: raise generate_exc return generate_result or {"text": "OK", "finish_reason": "stop"}
monkeypatch.setattr(brain_cli, "generate_with_result", fake_generate) monkeypatch.setattr( brain_cli, "get_provider_module", lambda provider: _FakeProviderModule(cogitate_calls, cogitate_result), ) return generate_calls, cogitate_calls
@pytest.mark.parametrize( ("lane", "config", "patch_prereq"), [ ("bundled", _bundled_config(), "bundled"), ("byo-cloud", _cloud_config(), None), ("byo-endpoint", _endpoint_config(), None), ("spp", _endpoint_config(confidential=True), "spp"), ],)def test_refresh_success_proves_each_lane_once( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], lane: str, config: dict[str, Any], patch_prereq: str | None,) -> None: _write_config(brain_journal, config) if patch_prereq == "bundled": monkeypatch.setattr( brain_state_module, "_bundled_runtime_fingerprint_sha", lambda: RUNTIME_FP, ) monkeypatch.setattr( brain_cli, "_current_bundled_runtime_fingerprint", lambda _config: RUNTIME_FP, ) monkeypatch.setattr( brain_cli, "inspect_runtime_health", lambda _provider: _fake_runtime_inspection(), ) monkeypatch.setattr( brain_state_module, "inspect_runtime_health", lambda _provider, *, journal_path=None: _fake_runtime_inspection(), ) elif patch_prereq == "spp": monkeypatch.setattr( brain_cli, "_spp_prerequisite", lambda now: (brain_cli._ok_component(now), None), ) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 0 assert payload["aggregate_state"] == "ready" assert payload["lane"] == lane assert len(generate_calls) == 1 assert generate_calls[0]["kwargs"]["num_retries"] == 0 assert generate_calls[0]["kwargs"]["thinking_budget"] == 0 assert len(cogitate_calls) == 1 assert cogitate_calls[0]["provider"] == payload["provider"] assert cogitate_calls[0]["model"] == payload["model"] assert cogitate_calls[0]["diagnostic"] is True
def test_refresh_prerequisite_failure_skips_inference_and_commits_not_attempted( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _bundled_config()) monkeypatch.setattr( brain_state_module, "_bundled_runtime_fingerprint_sha", lambda: RUNTIME_FP, ) monkeypatch.setattr( brain_cli, "_current_bundled_runtime_fingerprint", lambda _config: RUNTIME_FP, ) monkeypatch.setattr( brain_cli, "inspect_runtime_health", lambda _provider: _fake_runtime_inspection(phase="starting"), ) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out) record = json.loads(brain_state_path(journal_path=brain_journal).read_text())
assert code == 1 assert payload["reason_code"] == "local_runtime_not_ready" assert generate_calls == [] assert cogitate_calls == [] assert record["evidence"]["generate"]["status"] == "not_attempted" assert record["evidence"]["cogitate"]["reason_code"] == "local_runtime_not_ready"
def test_renew_prerequisites_updates_spp_only_without_model_probes( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: config = _endpoint_config(confidential=True) prior_now = NOW - timedelta(minutes=1) _write_ready_record(brain_journal, config, now=prior_now) before = json.loads(brain_state_path(journal_path=brain_journal).read_text()) expected = brain_state_module.read_active_brain_fingerprint_sha256( journal_path=brain_journal ) assert expected is not None _forbid_provider_calls(monkeypatch) monkeypatch.setattr( brain_cli, "_spp_prerequisite", lambda now: ( brain_cli._ok_component(now, expires_at=now + timedelta(minutes=10)), None, ), )
code = brain_cli._run_renew_prerequisites( _args(json=True, expected_fingerprint=expected) ) payload = json.loads(capsys.readouterr().out) record = json.loads(brain_state_path(journal_path=brain_journal).read_text())
assert code == 0 assert payload["aggregate_state"] == "ready" assert record["evidence"]["configuration"] == before["evidence"]["configuration"] assert record["evidence"]["generate"] == before["evidence"]["generate"] assert record["evidence"]["cogitate"] == before["evidence"]["cogitate"] assert record["evidence"]["lane_prerequisites"]["observed_at"] == NOW.isoformat()
def test_renew_prerequisites_busy_does_not_fallback( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_ready_record(brain_journal, _endpoint_config(confidential=True)) lease = acquire_file_lease(brain_refresh_lease_path(journal_path=brain_journal)) assert lease is not None monkeypatch.setattr( brain_cli, "_run_refresh", lambda _args: pytest.fail("busy must not fallback to full refresh"), ) _forbid_provider_calls(monkeypatch) try: code = brain_cli._run_renew_prerequisites(_args(json=True)) finally: lease.release() payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "busy"
def test_renew_prerequisites_unsafe_dispatches_full_refresh( brain_journal: Path, monkeypatch: pytest.MonkeyPatch,) -> None: _write_config(brain_journal, _cloud_config()) calls: list[argparse.Namespace] = []
def fake_refresh(args: argparse.Namespace) -> int: calls.append(args) return 7
monkeypatch.setattr(brain_cli, "_run_refresh", fake_refresh)
assert brain_cli._run_renew_prerequisites(_args(json=True)) == 7 assert len(calls) == 1 assert calls[0].expected_active_fingerprint is True
def test_renew_prerequisites_expected_mismatch_writes_nothing( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_ready_record(brain_journal, _endpoint_config(confidential=True)) before = _health_snapshot(brain_journal) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_renew_prerequisites( _args(json=True, expected_fingerprint="f" * 64) ) payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "stale_expected_fingerprint" assert _health_snapshot(brain_journal) == before
def test_refresh_cloud_missing_key_skips_inference( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _cloud_config(key="")) monkeypatch.delenv("OPENAI_API_KEY", raising=False) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 1 assert payload["reason_code"] == "provider_key_missing" assert generate_calls == [] assert cogitate_calls == []
def test_refresh_generate_failure_does_not_suppress_cogitate( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _cloud_config()) generate_calls, cogitate_calls = _patch_generate_and_cogitate( monkeypatch, generate_result={"text": "", "finish_reason": "stop"}, cogitate_result="OK", )
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out) record = json.loads(brain_state_path(journal_path=brain_journal).read_text())
assert code == 1 assert payload["reason_code"] == "provider_response_invalid" assert len(generate_calls) == 1 assert len(cogitate_calls) == 1 assert record["evidence"]["generate"]["reason_code"] == "provider_response_invalid" assert record["evidence"]["cogitate"]["status"] == "ok"
@pytest.mark.parametrize( ("generate_result", "generate_exc", "expected_reason", "expected_exit"), [ ({"text": "", "finish_reason": "max_tokens"}, None, "probe_output_starved", 2), ({"text": "", "finish_reason": "stop"}, None, "provider_response_invalid", 1), (None, _ReasonedProviderError("network_unreachable"), "network_unreachable", 1), ( None, _ReasonedProviderError("context_window_exceeded"), "probe_internal_error", 2, ), ],)def test_refresh_generate_mapping_branches( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], generate_result: dict[str, Any] | None, generate_exc: BaseException | None, expected_reason: str, expected_exit: int,) -> None: _write_config(brain_journal, _cloud_config()) generate_calls, cogitate_calls = _patch_generate_and_cogitate( monkeypatch, generate_result=generate_result, generate_exc=generate_exc, )
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out) record = json.loads(brain_state_path(journal_path=brain_journal).read_text())
assert code == expected_exit assert payload["reason_code"] == expected_reason assert len(generate_calls) == 1 assert len(cogitate_calls) == 1 assert record["evidence"]["generate"]["reason_code"] == expected_reason assert record["evidence"]["cogitate"]["status"] == "ok"
def test_refresh_uses_current_identity_after_begin_with_missing_key( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _bundled_config()) monkeypatch.setattr( brain_state_module, "_bundled_runtime_fingerprint_sha", lambda: RUNTIME_FP, ) _write_ready_record(brain_journal, _bundled_config()) brain_fingerprint_key_path(journal_path=brain_journal).unlink() _write_config( brain_journal, { "providers": {"active": {"provider": "openai", "model": "gpt-5.4-mini"}}, "env": {"OPENAI_API_KEY": "current-key"}, }, ) monkeypatch.setattr( brain_cli, "inspect_runtime_health", lambda _provider: pytest.fail("stale bundled lane was used"), ) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 0 assert payload["provider"] == "openai" assert len(generate_calls) == 1 assert len(cogitate_calls) == 1 assert cogitate_calls[0]["provider"] == "openai"
def test_refresh_excludes_inactive_providers( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config( brain_journal, { "providers": {"active": {"provider": "openai", "model": "gpt-5.4-mini"}}, "env": { "OPENAI_API_KEY": "active-key", "ANTHROPIC_API_KEY": "inactive-key", "GOOGLE_API_KEY": "inactive-key", }, }, ) generate_calls: list[dict[str, Any]] = [] cogitate_calls: list[dict[str, Any]] = []
def fake_generate(*args: Any, **kwargs: Any) -> dict[str, Any]: from solstone.think.models import resolve_provider
provider, model = resolve_provider("generate") generate_calls.append({"provider": provider, "model": model, "kwargs": kwargs}) return {"text": "OK", "finish_reason": "stop"}
def fake_module(provider: str) -> _FakeProviderModule: assert provider == "openai" return _FakeProviderModule(cogitate_calls)
monkeypatch.setattr(brain_cli, "generate_with_result", fake_generate) monkeypatch.setattr(brain_cli, "get_provider_module", fake_module)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 0 assert payload["provider"] == "openai" assert len(generate_calls) == 1 assert generate_calls[0]["provider"] == "openai" assert generate_calls[0]["model"] == "gpt-5.4-mini" assert cogitate_calls[0]["provider"] == "openai"
def test_byo_endpoint_generate_uses_served_model_post_not_get_probe( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: import httpx
from solstone.think.providers import local_admission, local_endpoint
class NullAdmission: def __enter__(self): return self
def __exit__(self, *_args: Any) -> None: return None
def release(self) -> None: return None
class FakeResponse: def raise_for_status(self) -> None: return None
def json(self) -> dict[str, Any]: return { "choices": [ { "message": {"content": "OK"}, "finish_reason": "stop", } ] }
posts: list[dict[str, Any]] = [] _write_config(brain_journal, _endpoint_config()) monkeypatch.setattr( local_endpoint, "probe_local_endpoint", lambda *_args, **_kwargs: pytest.fail("GET / endpoint probe was used"), ) monkeypatch.setattr( local_admission, "acquire_local_slot", lambda *_args, **_kwargs: NullAdmission(), )
def fake_post(url: str, **kwargs: Any) -> FakeResponse: posts.append({"url": url, "kwargs": kwargs}) return FakeResponse()
monkeypatch.setattr(httpx, "post", fake_post) cogitate_calls: list[dict[str, Any]] = [] monkeypatch.setattr( brain_cli, "get_provider_module", lambda _provider: _FakeProviderModule(cogitate_calls), )
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 0 assert payload["lane"] == "byo-endpoint" assert len(posts) == 1 assert posts[0]["url"] == "https://brain.example.test/v1/chat/completions" assert posts[0]["kwargs"]["json"]["model"] == "served-model" assert len(cogitate_calls) == 1 assert cogitate_calls[0]["provider"] == "local"
def test_refresh_none_lane_persists_blocked_without_provider_calls( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _none_config()) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 1 assert payload["reason_code"] == "thinking_engine_not_chosen" assert brain_state_path(journal_path=brain_journal).exists()
def test_refresh_configuration_invalid_writes_nothing( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _invalid_endpoint_config()) before = _health_snapshot(brain_journal) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out)
assert code == 2 assert payload["reason_code"] == "configuration_invalid" assert _health_snapshot(brain_journal) == before
def test_refresh_busy_exits_three( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _cloud_config()) lease = acquire_file_lease(brain_refresh_lease_path(journal_path=brain_journal)) assert lease is not None _forbid_provider_calls(monkeypatch) try: code = brain_cli._run_refresh(_args(json=True)) finally: lease.release() payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "busy"
def test_refresh_lost_fence_exits_three( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _cloud_config()) _patch_generate_and_cogitate(monkeypatch)
def lost(*_args: Any, **_kwargs: Any) -> None: raise BrainStateConflictError("lost")
monkeypatch.setattr(brain_cli, "finish_brain_refresh", lost)
code = brain_cli._run_refresh(_args(json=True)) payload = json.loads(capsys.readouterr().out) record = json.loads(brain_state_path(journal_path=brain_journal).read_text())
assert code == 3 assert payload["reason_code"] == "lost_fence" assert record["aggregate_state"] == "checking"
def test_expected_fingerprint_mismatch_or_non_bundled_exits_stale( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _cloud_config()) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_refresh(_args(json=True, expected_fingerprint=RUNTIME_FP)) payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "stale_expected_fingerprint"
def test_refresh_expected_active_fingerprint_mismatch_writes_nothing( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: original = _endpoint_config(confidential=True) changed = _endpoint_config(confidential=True) changed["providers"]["local"]["served_model_id"] = "new-served-model" changed["services"]["confidential"]["served_model_id"] = "new-served-model" _write_ready_record(brain_journal, original) expected = brain_state_module.read_active_brain_fingerprint_sha256( journal_path=brain_journal ) assert expected is not None before = _health_snapshot(brain_journal) _write_config(brain_journal, changed) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_refresh( _args( json=True, expected_fingerprint=expected, expected_active_fingerprint=True, ) ) payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "stale_expected_fingerprint" assert _health_snapshot(brain_journal) == before
def test_refresh_expected_active_fingerprint_race_before_begin_writes_nothing( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: original = _endpoint_config(confidential=True) changed = _endpoint_config(confidential=True) changed["providers"]["local"]["served_model_id"] = "race-served-model" changed["services"]["confidential"]["served_model_id"] = "race-served-model" _write_ready_record(brain_journal, original) expected = brain_state_module.read_active_brain_fingerprint_sha256( journal_path=brain_journal ) assert expected is not None before = _health_snapshot(brain_journal) real_match = brain_cli._expected_refresh_fingerprint_matches
def match_then_switch(args: argparse.Namespace, value: str) -> bool: assert real_match(args, value) _write_config(brain_journal, changed) return True
monkeypatch.setattr( brain_cli, "_expected_refresh_fingerprint_matches", match_then_switch, ) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_refresh( _args( json=True, expected_fingerprint=expected, expected_active_fingerprint=True, ) ) payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "stale_expected_fingerprint" assert _health_snapshot(brain_journal) == before
def test_refresh_expected_absent_fingerprint_bootstraps_spp( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _endpoint_config(confidential=True)) assert not brain_fingerprint_key_path(journal_path=brain_journal).exists() monkeypatch.setattr( brain_cli, "_spp_prerequisite", lambda now: ( brain_cli._ok_component(now, expires_at=now + timedelta(minutes=10)), None, ), ) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
code = brain_cli._run_refresh( _args(json=True, expect_active_fingerprint_absent=True) ) payload = json.loads(capsys.readouterr().out)
assert code == 0 assert payload["aggregate_state"] == "ready" assert payload["lane"] == "spp" assert brain_fingerprint_key_path(journal_path=brain_journal).exists() assert len(generate_calls) == 1 assert len(cogitate_calls) == 1
def test_refresh_expected_absent_fingerprint_stale_when_key_appears( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_ready_record(brain_journal, _endpoint_config(confidential=True)) before = _health_snapshot(brain_journal) _forbid_provider_calls(monkeypatch)
code = brain_cli._run_refresh( _args(json=True, expect_active_fingerprint_absent=True) ) payload = json.loads(capsys.readouterr().out)
assert code == 3 assert payload["reason_code"] == "stale_expected_fingerprint" assert _health_snapshot(brain_journal) == before
def test_expected_fingerprint_match_proceeds_and_ready_short_circuits( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _bundled_config()) monkeypatch.setattr( brain_state_module, "_bundled_runtime_fingerprint_sha", lambda: RUNTIME_FP, ) monkeypatch.setattr( brain_cli, "inspect_runtime_health", lambda _provider: _fake_runtime_inspection(), ) monkeypatch.setattr( brain_state_module, "inspect_runtime_health", lambda _provider, *, journal_path=None: _fake_runtime_inspection(), ) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
assert not brain_fingerprint_key_path(journal_path=brain_journal).exists() first = brain_cli._run_refresh(_args(json=True, expected_fingerprint=RUNTIME_FP)) capsys.readouterr() second = brain_cli._run_refresh(_args(json=True, expected_fingerprint=RUNTIME_FP)) payload = json.loads(capsys.readouterr().out)
assert first == 0 assert second == 0 assert payload["aggregate_state"] == "ready" assert brain_fingerprint_key_path(journal_path=brain_journal).exists() assert len(generate_calls) == 1 assert len(cogitate_calls) == 1
def test_f1_f2_supersession_runs_new_fingerprint_once( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: fp1 = "1" * 64 fp2 = "2" * 64 current_fp = {"value": fp1} _write_config(brain_journal, _bundled_config()) monkeypatch.setattr( brain_state_module, "_bundled_runtime_fingerprint_sha", lambda: current_fp["value"], ) monkeypatch.setattr( brain_cli, "inspect_runtime_health", lambda _provider: _fake_runtime_inspection(desired=current_fp["value"]), ) monkeypatch.setattr( brain_state_module, "inspect_runtime_health", lambda _provider, *, journal_path=None: _fake_runtime_inspection( desired=current_fp["value"] ), ) real_probe_outcome = brain_cli._probe_outcome
def f1_probe_outcome(**_kwargs: Any) -> BrainProbeOutcome: current_fp["value"] = fp2 return _ready_outcome()
monkeypatch.setattr(brain_cli, "_probe_outcome", f1_probe_outcome)
first = brain_cli._run_refresh(_args(json=True, expected_fingerprint=fp1)) first_payload = json.loads(capsys.readouterr().out)
assert first == 3 assert first_payload["reason_code"] == "lost_fence"
monkeypatch.setattr(brain_cli, "_probe_outcome", real_probe_outcome) generate_calls, cogitate_calls = _patch_generate_and_cogitate(monkeypatch)
second = brain_cli._run_refresh(_args(json=True, expected_fingerprint=fp2)) second_payload = json.loads(capsys.readouterr().out)
assert second == 0 assert second_payload["aggregate_state"] == "ready" assert len(generate_calls) == 1 assert len(cogitate_calls) == 1
def test_refresh_diagnostic_cogitate_constructs_zero_retry_llm( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: from solstone.think.providers import emit_final_tool, openhands
fake_openhands = install_fake_openhands(monkeypatch) emit_final_tool._EMIT_FINAL_TYPES.clear() monkeypatch.setattr(openhands, "get_journal", lambda: brain_journal) monkeypatch.setattr(openhands, "get_project_root", lambda: brain_journal) monkeypatch.setattr(brain_cli, "get_provider_module", lambda _provider: openhands) monkeypatch.setenv("OPENAI_API_KEY", "config-secret") _write_config(brain_journal, _cloud_config())
async def emit_final(conversation): for callback in conversation.callbacks: callback( fake_openhands.ActionEvent( reasoning_content=None, thinking_blocks=[], responses_reasoning_item=None, tool_name="emit_final", tool_call=SimpleNamespace(arguments={"content": "OK"}), tool_call_id="emit-1", action=SimpleNamespace(content="OK"), ) )
fake_openhands.Conversation.arun_impl = emit_final generate_calls: list[dict[str, Any]] = []
def fake_generate(*args: Any, **kwargs: Any) -> dict[str, Any]: generate_calls.append({"args": args, "kwargs": kwargs}) return {"text": "OK", "finish_reason": "stop"}
monkeypatch.setattr(brain_cli, "generate_with_result", fake_generate)
code = brain_cli._run_refresh(_args(json=True)) json.loads(capsys.readouterr().out)
assert code == 0 assert generate_calls[0]["kwargs"]["num_retries"] == 0 assert fake_openhands.LLM.instances[-1].num_retries == 0
@pytest.mark.parametrize( ("aggregate_state", "expected"), [ ("ready", 0), ("blocked", 1), ("unhealthy", 1), ("unknown", 2), ("checking", 2), ],)def test_exit_table_for_status_and_refresh_aggregates( aggregate_state: str, expected: int,) -> None: assert brain_cli.brain_exit_code(aggregate_state=aggregate_state) == expected
@pytest.mark.parametrize( "refresh_outcome", ["busy", "stale_expected_fingerprint", "lost_fence"],)def test_exit_table_for_refresh_only_outcomes(refresh_outcome: str) -> None: assert brain_cli.brain_exit_code(refresh_outcome=refresh_outcome) == 3
def test_module_main_help_and_status_are_clean( brain_journal: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],) -> None: _write_config(brain_journal, _cloud_config()) _forbid_provider_calls(monkeypatch) before = _health_snapshot(brain_journal)
monkeypatch.setattr(sys, "argv", ["journal brain", "--help"]) with pytest.raises(SystemExit) as help_exit: brain_cli.main() assert help_exit.value.code == 0 assert "status" in capsys.readouterr().out
monkeypatch.setattr(sys, "argv", ["journal brain", "status"]) with pytest.raises(SystemExit) as status_exit: brain_cli.main() assert status_exit.value.code == 2 assert "Brain unknown" in capsys.readouterr().out
monkeypatch.setattr(sys, "argv", ["journal brain", "status", "--json"]) with pytest.raises(SystemExit) as json_exit: brain_cli.main() assert json_exit.value.code == 2 payload = json.loads(capsys.readouterr().out) assert payload["reason_code"] == "brain_record_missing" assert _health_snapshot(brain_journal) == before