thinkstack-core 4.1.0__tar.gz → 4.2.0__tar.gz

{thinkstack_core-4.1.0/thinkstack_core.egg-info → thinkstack_core-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thinkstack-core
-Version: 4.1.0
+Version: 4.2.0
 Summary: ThinkStack — AI reasoning capture, audit trail, and governance for agent-assisted development (core library)
 Author-email: Hemant Joshi <hemant@flotorch.ai>
 License: Apache-2.0
@@ -21,6 +21,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
 Requires-Dist: boto3>=1.34.0; extra == "dev"
 Requires-Dist: pyyaml>=6.0; extra == "dev"
 Requires-Dist: pdfminer.six>=20221105; extra == "dev"
@@ -61,10 +62,10 @@ Requires-Dist: thinkstack-core[audit,cloud,embeddings,mcp,proxy,wrapper]; extra
 
 **Local-first AI agent governance.** ThinkStack gives multi-agent systems a shared on-disk audit trail, coordination vector, privacy controls, and LLM integration layer — all without a remote service.
 
-> **Latest release:** `thinkstack-core` and `thinkstack-cli` **4.0.0** — Multi-model reasoning parsers + TOON default serialization + RACP spec paper. Install or upgrade with `pip install -U thinkstack-cli`.
+> **Latest release:** `thinkstack-core` and `thinkstack-cli` **4.2.0** — learning capture on the Claude Code path, redacted call records, JSON sync bundles, a stateless MCP transport, and honest metrics. Install or upgrade with `pip install -U thinkstack-cli`.
 
 ```bash
-pip install -U thinkstack-cli>=4.0.0
+pip install -U 'thinkstack-cli>=4.2.0'
 thinkstack init
 thinkstack setup          # connects to Claude Code, Cursor, or Antigravity
 thinkstack debug timeline
@@ -98,6 +99,21 @@ thinkstack reasoning-plus config --smart-top-n 3 --smart-max-lines 150 --learnin
 
 Set `THINKSTACK_REASONING_PLUS=0` to disable it for a single session. See [REASONING_PLUS.md](REASONING_PLUS.md) for details.
 
+#### Learning capture
+
+Every captured call is recorded under `.GCC/reasoning_learnings/` and a learning is extracted from it — what was decided, and why. Secrets and structured PII are redacted *before* anything is written, so a credential or an email in a model response never reaches the store.
+
+In Claude Code the final assistant message is captured on the `Stop` hook (Claude Code v2.1.47+), so a session that only reads and reasons still leaves a learning behind.
+
+```bash
+thinkstack learning stats          # totals, average confidence, danger zones
+thinkstack learning list           # active learnings, filterable by type or scope
+thinkstack learning show <id>      # one learning in full
+thinkstack learning promote <id>   # share it with your org
+```
+
+"Danger zones" are concepts whose recorded outcomes disagree — the places where re-injecting past reasoning is most likely to mislead. The directory holds `calls/` (what was recorded), `learnings/` (what was extracted), and `provenance/` (which call produced which learning).
+
 Everything lives in `.GCC/` — a local directory in your project. No database, no network service, no telemetry.
 
 ---
@@ -547,6 +563,8 @@ No API key required. Fully local — RACP context and captures stay on-device.
 
 For teams that want a single shared reasoning backend across all projects and machines, ThinkStack provides a Cloudflare Worker MCP server. It stores `.GCC/` in Cloudflare R2 and exposes an HTTPS SSE endpoint that every IDE can connect to.
 
+The transport is **stateless**: `GET /{org}/{repo}/sse` answers the MCP handshake and closes, and `POST /{org}/{repo}/messages` returns the JSON-RPC response in the response body. Nothing is held server-side between calls, so the worker runs comfortably inside Cloudflare's free tier. All routes except `/health` require an API key or OAuth/JWT.
+
 **Deploy once, use everywhere:**
 
 ```bash
@@ -859,6 +877,7 @@ ThinkStack is explicit about what every number is based on:
 - **Auditor rate** — BLS SOC 13-2011 (2023): $39–40/hr employed staff. External rates ($75–400/hr) not used as defaults.
 - **MCS/DHS weights** — Design choices. No external benchmark. Calibrate with your team's data.
 - **Developer hourly rate** — No default. You must set it: `thinkstack calibrate --set developer_hourly_rate=<value>`
+- **A metric that is not measured is reported as 0, not estimated.** `bundle_tokens` and `latency_speedup_factor`, for instance, stay at 0 until something actually measures a bundle. A plausible-looking derived number is worse than an obvious zero: it reads as evidence, and it survives review. The same principle applies to the learning statistics — an empty store reports zero rather than an inferred figure.
 
 See `thinkstack_core/metrics/credibility.py` for the full citation registry.
 

{thinkstack_core-4.1.0 → thinkstack_core-4.2.0}/README.md

@@ -2,10 +2,10 @@
 
 **Local-first AI agent governance.** ThinkStack gives multi-agent systems a shared on-disk audit trail, coordination vector, privacy controls, and LLM integration layer — all without a remote service.
 
-> **Latest release:** `thinkstack-core` and `thinkstack-cli` **4.0.0** — Multi-model reasoning parsers + TOON default serialization + RACP spec paper. Install or upgrade with `pip install -U thinkstack-cli`.
+> **Latest release:** `thinkstack-core` and `thinkstack-cli` **4.2.0** — learning capture on the Claude Code path, redacted call records, JSON sync bundles, a stateless MCP transport, and honest metrics. Install or upgrade with `pip install -U thinkstack-cli`.
 
 ```bash
-pip install -U thinkstack-cli>=4.0.0
+pip install -U 'thinkstack-cli>=4.2.0'
 thinkstack init
 thinkstack setup          # connects to Claude Code, Cursor, or Antigravity
 thinkstack debug timeline
@@ -39,6 +39,21 @@ thinkstack reasoning-plus config --smart-top-n 3 --smart-max-lines 150 --learnin
 
 Set `THINKSTACK_REASONING_PLUS=0` to disable it for a single session. See [REASONING_PLUS.md](REASONING_PLUS.md) for details.
 
+#### Learning capture
+
+Every captured call is recorded under `.GCC/reasoning_learnings/` and a learning is extracted from it — what was decided, and why. Secrets and structured PII are redacted *before* anything is written, so a credential or an email in a model response never reaches the store.
+
+In Claude Code the final assistant message is captured on the `Stop` hook (Claude Code v2.1.47+), so a session that only reads and reasons still leaves a learning behind.
+
+```bash
+thinkstack learning stats          # totals, average confidence, danger zones
+thinkstack learning list           # active learnings, filterable by type or scope
+thinkstack learning show <id>      # one learning in full
+thinkstack learning promote <id>   # share it with your org
+```
+
+"Danger zones" are concepts whose recorded outcomes disagree — the places where re-injecting past reasoning is most likely to mislead. The directory holds `calls/` (what was recorded), `learnings/` (what was extracted), and `provenance/` (which call produced which learning).
+
 Everything lives in `.GCC/` — a local directory in your project. No database, no network service, no telemetry.
 
 ---
@@ -488,6 +503,8 @@ No API key required. Fully local — RACP context and captures stay on-device.
 
 For teams that want a single shared reasoning backend across all projects and machines, ThinkStack provides a Cloudflare Worker MCP server. It stores `.GCC/` in Cloudflare R2 and exposes an HTTPS SSE endpoint that every IDE can connect to.
 
+The transport is **stateless**: `GET /{org}/{repo}/sse` answers the MCP handshake and closes, and `POST /{org}/{repo}/messages` returns the JSON-RPC response in the response body. Nothing is held server-side between calls, so the worker runs comfortably inside Cloudflare's free tier. All routes except `/health` require an API key or OAuth/JWT.
+
 **Deploy once, use everywhere:**
 
 ```bash
@@ -800,6 +817,7 @@ ThinkStack is explicit about what every number is based on:
 - **Auditor rate** — BLS SOC 13-2011 (2023): $39–40/hr employed staff. External rates ($75–400/hr) not used as defaults.
 - **MCS/DHS weights** — Design choices. No external benchmark. Calibrate with your team's data.
 - **Developer hourly rate** — No default. You must set it: `thinkstack calibrate --set developer_hourly_rate=<value>`
+- **A metric that is not measured is reported as 0, not estimated.** `bundle_tokens` and `latency_speedup_factor`, for instance, stay at 0 until something actually measures a bundle. A plausible-looking derived number is worse than an obvious zero: it reads as evidence, and it survives review. The same principle applies to the learning statistics — an empty store reports zero rather than an inferred figure.
 
 See `thinkstack_core/metrics/credibility.py` for the full citation registry.
 

{thinkstack_core-4.1.0 → thinkstack_core-4.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "thinkstack-core"
-version = "4.1.0"
+version = "4.2.0"
 description = "ThinkStack — AI reasoning capture, audit trail, and governance for agent-assisted development (core library)"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -26,7 +26,7 @@ dependencies = []
 thinkstack-hook = "thinkstack_core.hooks.runner:cli"
 
 [project.optional-dependencies]
-dev = ["pytest>=8.0.0", "boto3>=1.34.0", "pyyaml>=6.0", "pdfminer.six>=20221105", "tiktoken>=0.7.0"]
+dev = ["pytest>=8.0.0", "pytest-cov>=7.0.0", "boto3>=1.34.0", "pyyaml>=6.0", "pdfminer.six>=20221105", "tiktoken>=0.7.0"]
 wrapper = [
     "anthropic>=0.40.0",
     "openai>=1.50.0",

{thinkstack_core-4.1.0 → thinkstack_core-4.2.0}/tests/test_hidden_profile_benchmark.py

@@ -181,3 +181,59 @@ class TestBenchmarkResultsDoc:
         results_dir = BENCHMARK_DIR / "results" / "thinkstack"
         assert results_dir.exists()
         assert any(results_dir.glob("*/*.json"))
+
+
+# ---------------------------------------------------------------------------
+# Determinism
+# ---------------------------------------------------------------------------
+
+
+def _load_run_baseline():
+    """Import benchmarks/hidden_profile/run_baseline.py as a module."""
+    import importlib.util
+
+    spec = importlib.util.spec_from_file_location(
+        "run_baseline", BENCHMARK_DIR / "run_baseline.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class TestDeterminism:
+    def test_decision_does_not_depend_on_theta_key_order(self):
+        """Benchmark output must not vary with dict/set iteration order.
+
+        theta reached agent_decide() from a set, so PYTHONHASHSEED reordered
+        its keys between processes. Both the rendered "Theta signals read:
+        [...]" line and the order of constraints_included varied, so the
+        committed results under results/ churned on every regeneration with no
+        change in behaviour.
+        """
+        module = _load_run_baseline()
+
+        scenario = {
+            "required_constraints": ["c2", "c3"],
+            "agents": [
+                {
+                    "id": "peer",
+                    "private_info": [
+                        {"constraint_id": "c2", "affects": ["alpha"]},
+                        {"constraint_id": "c3", "affects": ["beta"]},
+                    ],
+                }
+            ],
+        }
+        agent = {
+            "id": "decider",
+            "role": "dba",
+            "private_info": [{"constraint_id": "c1", "description": "d"}],
+        }
+        theta_ab = {"alpha": {"mean_confidence": 0.9}, "beta": {"mean_confidence": 0.9}}
+        theta_ba = {"beta": {"mean_confidence": 0.9}, "alpha": {"mean_confidence": 0.9}}
+
+        first = module.agent_decide(agent, scenario, shared_theta=theta_ab)
+        second = module.agent_decide(agent, scenario, shared_theta=theta_ba)
+
+        assert first["constraints_included"] == second["constraints_included"]
+        assert first["decision_text"] == second["decision_text"]

thinkstack_core-4.2.0/tests/test_hooks_learning_capture.py

@@ -0,0 +1,263 @@
+"""The Stop hook must record the final response and extract a learning (plan Task 2).
+
+Reported symptom: a full session records events and commits but zero learnings,
+because nothing on the Claude Code path ever wrote a ReasoningCall.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from thinkstack_core import GCCRepository
+from thinkstack_core.hooks import runner
+from thinkstack_core.reasoning_plus.config import ReasoningPlusConfig, SettingsStore
+from thinkstack_core.reasoning_plus.learning.store import LearningStore
+
+MESSAGE = (
+    "Retrieval beat finetuning here because the corpus changed mid-experiment."
+)
+
+
+def _init_repo(tmp_path: Path) -> Path:
+    """A genuinely initialised store — is_initialized() requires VERSION."""
+    repo = GCCRepository.at(tmp_path)
+    repo.init()
+    return repo.gcc_dir
+
+
+def test_session_end_captures_a_learning(tmp_path, monkeypatch):
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.handle_session_end({
+        "session_id": "s-1",
+        "last_assistant_message": MESSAGE,
+    })
+
+    learnings = LearningStore(gcc).list()
+    assert len(learnings) == 1
+    assert "retrieval" in {c.lower() for c in learnings[0].trigger_concepts}
+
+
+def test_session_end_without_message_records_no_learning(tmp_path, monkeypatch):
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.handle_session_end({"session_id": "s-2"})
+
+    assert LearningStore(gcc).list() == []
+
+
+def test_session_end_never_raises(tmp_path, monkeypatch):
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    # A payload that would blow up any naive implementation.
+    runner.handle_session_end({
+        "last_assistant_message": None,
+        "session_id": object(),
+    })
+
+    assert LearningStore(gcc).list() == []
+
+
+def test_capture_disabled_by_config(tmp_path, monkeypatch):
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    SettingsStore(gcc).save_project(
+        ReasoningPlusConfig(learning_capture_on_stop=False)
+    )
+
+    runner.handle_session_end({
+        "session_id": "s-3",
+        "last_assistant_message": MESSAGE,
+    })
+
+    assert LearningStore(gcc).list() == []
+
+
+def test_session_end_flushes_pending_extractions(tmp_path, monkeypatch):
+    """Queued calls are extracted at session end, not discarded.
+
+    The docstring promised a final flush of learnings; the body never called
+    flush_extractions(), so anything in the batch queue was dropped.
+    """
+    from unittest.mock import patch
+
+    from thinkstack_core.reasoning_plus.learning import api as learning_api
+
+    _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    called = {"flush": 0}
+    real_flush = learning_api.ReasoningPlusLearning.flush_extractions
+
+    def spy(self):
+        called["flush"] += 1
+        return real_flush(self)
+
+    with patch.object(learning_api.ReasoningPlusLearning, "flush_extractions", spy):
+        runner.handle_session_end({"session_id": "s-flush"})
+
+    assert called["flush"] == 1
+
+
+def test_auto_sync_event_is_honest_without_org_id(tmp_path, monkeypatch):
+    """No org configured -> the event must not claim a push happened.
+
+    The event was appended outside the try with learnings_pushed/pulled
+    hard-coded true, so session end logged a successful org push even when
+    org_id was None and nothing was sent.
+    """
+    import json
+
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("THINKSTACK_ORG_ID", raising=False)
+    monkeypatch.delenv("DEVTORCH_ORG_ID", raising=False)
+
+    runner.handle_session_end({"session_id": "s-org"})
+
+    events = [
+        json.loads(line)
+        for line in (gcc / "events.log.jsonl").read_text().splitlines()
+        if line.strip()
+    ]
+    sync_events = [e for e in events if e["event_type"] == "AUTO_SYNC_ON_STOP"]
+    assert len(sync_events) == 1
+    payload = sync_events[0]["payload"]
+    assert payload["org_id"] is None
+    assert payload["learnings_pushed"] is False
+    assert payload["learnings_pulled"] is False
+
+
+def test_capture_ignores_non_string_message(tmp_path, monkeypatch):
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.handle_session_end({"session_id": "s-ns", "last_assistant_message": 12345})
+
+    assert LearningStore(gcc).list() == []
+
+
+def test_capture_ignores_whitespace_only_message(tmp_path, monkeypatch):
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.handle_session_end({
+        "session_id": "s-ws",
+        "last_assistant_message": "   \n  ",
+    })
+
+    assert LearningStore(gcc).list() == []
+
+
+def test_capture_truncates_a_very_long_message(tmp_path, monkeypatch):
+    """Review Focus: an unbounded response must not produce an unbounded write."""
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.handle_session_end({
+        "session_id": "s-long",
+        "last_assistant_message": "retrieval corpus changed " * 5000,
+    })
+
+    calls = list((gcc / "reasoning_learnings" / "calls").glob("*"))
+    assert calls, "capture should still produce a call record"
+    assert len(calls[0].read_text()) < 200_000
+
+
+def test_capture_survives_a_corrupt_settings_file(tmp_path, monkeypatch):
+    """Hooks must exit 0 even when settings are unreadable.
+
+    Note the file is settings.toon, not settings.json — PROJECT_SETTINGS_FILENAME
+    is settings.toon, so writing settings.json here would be silently ignored.
+    A corrupt file makes the loader fall back to defaults, so capture still runs.
+    """
+    import json
+
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    (gcc / "settings.toon").write_text("{ this is not valid toon or json")
+
+    runner.handle_session_end({
+        "session_id": "s-bad",
+        "last_assistant_message": MESSAGE,
+    })
+
+    logged = [
+        json.loads(line)
+        for line in (gcc / "events.log.jsonl").read_text().splitlines()
+        if line.strip()
+    ]
+    assert any(e["event_type"] == "SESSION_END" for e in logged), "handler must complete"
+
+
+def test_capture_disabled_when_learning_disabled(tmp_path, monkeypatch):
+    """learning_enabled=False is a hard gate at the hook level too."""
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    SettingsStore(gcc).save_project(ReasoningPlusConfig(learning_enabled=False))
+
+    runner.handle_session_end({
+        "session_id": "s-off",
+        "last_assistant_message": MESSAGE,
+    })
+
+    assert LearningStore(gcc).list() == []
+
+
+def test_auto_sync_reports_success_when_org_configured(tmp_path, monkeypatch):
+    """With an org set, the event reports the push and pull as done."""
+    import json
+
+    import thinkstack_core.cloud.team_sync as team_sync
+
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("THINKSTACK_ORG_ID", "test-org")
+
+    calls = []
+    monkeypatch.setattr(team_sync, "push_learnings", lambda org, d: calls.append(("push", org)))
+    monkeypatch.setattr(team_sync, "pull_learnings", lambda org, d: calls.append(("pull", org)))
+
+    runner.handle_session_end({"session_id": "s-org2"})
+
+    events = [
+        json.loads(line)
+        for line in (gcc / "events.log.jsonl").read_text().splitlines()
+        if line.strip()
+    ]
+    payloads = [e["payload"] for e in events if e["event_type"] == "AUTO_SYNC_ON_STOP"]
+    assert payloads[0]["org_id"] == "test-org"
+    assert payloads[0]["learnings_pushed"] is True
+    assert payloads[0]["learnings_pulled"] is True
+    assert ("push", "test-org") in calls
+    assert ("pull", "test-org") in calls
+
+
+def test_capture_does_not_persist_credentials(tmp_path, monkeypatch):
+    """Review Focus: a response containing a secret or PII must not land raw.
+
+    The extractor quarantines the resulting learning, but the call record stores
+    the response text verbatim — so both the credential and the email survived
+    in reasoning_learnings/calls/*.toon.
+    """
+    gcc = _init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+
+    runner.handle_session_end({
+        "session_id": "s-secret",
+        "last_assistant_message": (
+            "We fixed the deploy. The leaked key is AKIAIOSFODNN7EXAMPLE "
+            "and the owner is jane.doe@example.com — rotate it."
+        ),
+    })
+
+    leaked = []
+    for path in (gcc / "reasoning_learnings").rglob("*"):
+        if not path.is_file():
+            continue
+        body = path.read_text(errors="replace")
+        if "AKIAIOSFODNN7EXAMPLE" in body or "jane.doe@example.com" in body:
+            leaked.append(path.name)
+    assert leaked == [], f"secret/PII persisted in {leaked}"

thinkstack_core-4.2.0/tests/test_learning_capture_config.py

@@ -0,0 +1,19 @@
+"""Config for the Stop-hook learning capture path (plan Task 1)."""
+from __future__ import annotations
+
+from thinkstack_core.reasoning_plus.config import ReasoningPlusConfig
+
+
+def test_capture_on_stop_defaults_true():
+    assert ReasoningPlusConfig().learning_capture_on_stop is True
+
+
+def test_capture_on_stop_survives_dict_round_trip():
+    cfg = ReasoningPlusConfig(learning_capture_on_stop=False)
+    assert cfg.to_dict()["learning_capture_on_stop"] is False
+    assert ReasoningPlusConfig.from_dict(cfg.to_dict()).learning_capture_on_stop is False
+
+
+def test_capture_on_stop_survives_with_values():
+    cfg = ReasoningPlusConfig().with_values(learning_capture_on_stop=False)
+    assert cfg.learning_capture_on_stop is False

thinkstack_core-4.2.0/tests/test_learning_stats_counts.py

@@ -0,0 +1,103 @@
+"""learning stats must report learning count, not concept assignments (plan Task 5/6/8)."""
+from __future__ import annotations
+
+from argparse import Namespace
+from pathlib import Path
+
+import thinkstack_cli
+from thinkstack_cli.main import cmd_learning_stats
+
+from thinkstack_core import GCCRepository
+from thinkstack_core.reasoning_plus.learning.api import ReasoningPlusLearning
+
+MESSAGE = (
+    "Retrieval beat finetuning here because the corpus changed mid-experiment."
+)
+
+
+def test_cli_imports_from_repo_source():
+    """Guard: CLI tests must exercise thinkstack-cli/, not site-packages."""
+    assert "thinkstack-cli" in thinkstack_cli.__file__, thinkstack_cli.__file__
+
+
+def _repo_with_one_five_concept_learning(tmp_path: Path) -> Path:
+    """One learning carrying five trigger concepts."""
+    repo = GCCRepository.at(tmp_path)
+    repo.init()
+    ReasoningPlusLearning(gcc_dir=repo.gcc_dir).record_and_extract(
+        call_type="llm",
+        reasoning=MESSAGE,
+        outcome="success",
+        session_id="stats-1",
+    )
+    return tmp_path
+
+
+def test_total_counts_learnings_not_concepts(tmp_path, monkeypatch, capsys):
+    root = _repo_with_one_five_concept_learning(tmp_path)
+    monkeypatch.chdir(root)
+
+    assert cmd_learning_stats(Namespace(path=str(root), by_concept=False)) == 0
+
+    out = capsys.readouterr().out
+    assert "Total learnings: 1" in out
+    assert "Active: 1" in out
+
+
+def test_single_learning_is_not_a_danger_zone(tmp_path, monkeypatch, capsys):
+    """One learning cannot be a danger zone: dangers need min_samples evidence.
+
+    The inline `success_rate < 0.4` check had no minimum sample, and
+    _compute_success_rate returns 0.0 for concepts with no non-unknown
+    outcomes, so a single learning reported five danger zones from no data.
+    """
+    root = _repo_with_one_five_concept_learning(tmp_path)
+    monkeypatch.chdir(root)
+
+    assert cmd_learning_stats(Namespace(path=str(root), by_concept=False)) == 0
+
+    out = capsys.readouterr().out
+    assert "Danger zones: 0" in out
+
+
+def test_empty_store_states_the_capture_path(tmp_path, monkeypatch, capsys):
+    """A project with learning on but no producer must not look merely empty.
+
+    'No learnings found' was indistinguishable from 'nothing can be learned
+    here', which is what made the reported bug invisible.
+    """
+    repo = GCCRepository.at(tmp_path)
+    repo.init()
+    monkeypatch.chdir(tmp_path)
+
+    assert cmd_learning_stats(Namespace(path=str(tmp_path), by_concept=False)) == 0
+
+    out = capsys.readouterr().out
+    assert "No learnings found." in out
+    assert "capture path" in out.lower()
+
+
+def test_by_concept_branch_still_works(tmp_path, monkeypatch, capsys):
+    root = _repo_with_one_five_concept_learning(tmp_path)
+    monkeypatch.chdir(root)
+
+    assert cmd_learning_stats(Namespace(path=str(root), by_concept=True)) == 0
+
+    out = capsys.readouterr().out
+    assert "Total: 1" in out
+    assert "Success rate:" in out
+
+
+def test_stats_reports_zero_capture_when_learning_disabled(tmp_path, monkeypatch, capsys):
+    """Writes settings.toon via the store — settings.json is not the filename."""
+    from thinkstack_core.reasoning_plus.config import ReasoningPlusConfig, SettingsStore
+
+    repo = GCCRepository.at(tmp_path)
+    repo.init()
+    SettingsStore(repo.gcc_dir).save_project(
+        ReasoningPlusConfig(learning_enabled=False)
+    )
+    monkeypatch.chdir(tmp_path)
+
+    assert cmd_learning_stats(Namespace(path=str(tmp_path), by_concept=False)) == 0
+    assert "learning_enabled is false" in capsys.readouterr().out

{thinkstack_core-4.1.0 → thinkstack_core-4.2.0}/tests/test_mcp_client.py

@@ -131,6 +131,10 @@ class TestMcpClient:
         post_resp = MagicMock()
         post_resp.__enter__ = MagicMock(return_value=post_resp)
         post_resp.__exit__ = MagicMock(return_value=False)
+        # An SSE-only server returns 202 with an empty body; the response
+        # arrives on the stream. Returning a bare MagicMock here would be a
+        # body that is neither str nor bytes.
+        post_resp.read = MagicMock(return_value=b"")
 
         def urlopen_side_effect(req, **kwargs):
             if req.get_full_url() == "https://example.com/sse":
@@ -156,6 +160,10 @@ class TestMcpClient:
         post_resp = MagicMock()
         post_resp.__enter__ = MagicMock(return_value=post_resp)
         post_resp.__exit__ = MagicMock(return_value=False)
+        # An SSE-only server returns 202 with an empty body; the response
+        # arrives on the stream. Returning a bare MagicMock here would be a
+        # body that is neither str nor bytes.
+        post_resp.read = MagicMock(return_value=b"")
 
         def urlopen_side_effect(req, **kwargs):
             if req.get_full_url() == "https://example.com/sse":
@@ -168,6 +176,49 @@ class TestMcpClient:
 
         client.close()
 
+    def test_call_tool_reads_response_from_post_body(self) -> None:
+        """A stateless server answers in the POST body.
+
+        The stream carries only the handshake, so the response can only come
+        from the body. Before this was supported the client waited on a stream
+        that never delivered and failed with a timeout.
+        """
+        client = McpClient("https://example.com/sse", "test-key")
+        mock_messages_url = "https://example.com/messages?sessionId=test"
+
+        sse_resp = _SSEMockResponse([
+            b"event: endpoint\n",
+            f"data: {mock_messages_url}\n".encode("utf-8"),
+            b"\n",
+            # Deliberately no message event: the answer is only in the body.
+        ])
+
+        body = json.dumps({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "result": {
+                "content": [
+                    {"type": "text", "text": "Topics:\n  authentication (5 concepts)"}
+                ],
+                "isError": False,
+            },
+        }).encode("utf-8")
+        post_resp = MagicMock()
+        post_resp.__enter__ = MagicMock(return_value=post_resp)
+        post_resp.__exit__ = MagicMock(return_value=False)
+        post_resp.read = MagicMock(return_value=body)
+
+        def urlopen_side_effect(req, **kwargs):
+            if req.get_full_url() == "https://example.com/sse":
+                return sse_resp
+            return post_resp
+
+        with patch("urllib.request.urlopen", side_effect=urlopen_side_effect):
+            result = client.call_tool("thinkstack_topics_list", {"all": True})
+            assert "authentication" in result
+
+        client.close()
+
     def test_is_available_returns_false_on_error(self) -> None:
         client = McpClient("https://nonexistent.example.com/sse", "bad-key", timeout=0.01)