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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thinkstack-core
-Version: 4.0.0
+Version: 4.1.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
@@ -24,6 +24,7 @@ Requires-Dist: pytest>=8.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"
+Requires-Dist: tiktoken>=0.7.0; extra == "dev"
 Provides-Extra: wrapper
 Requires-Dist: anthropic>=0.40.0; extra == "wrapper"
 Requires-Dist: openai>=1.50.0; extra == "wrapper"
@@ -60,10 +61,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` **3.0.2** — Local-first AI governance split into a core SDK (`thinkstack-core`) and a CLI (`thinkstack-cli`). Install or upgrade with `pip install -U thinkstack-cli`.
+> **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`.
 
 ```bash
-pip install -U thinkstack-cli>=3.0.1
+pip install -U thinkstack-cli>=4.0.0
 thinkstack init
 thinkstack setup          # connects to Claude Code, Cursor, or Antigravity
 thinkstack debug timeline

{thinkstack_core-4.0.0 → thinkstack_core-4.1.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` **3.0.2** — Local-first AI governance split into a core SDK (`thinkstack-core`) and a CLI (`thinkstack-cli`). Install or upgrade with `pip install -U thinkstack-cli`.
+> **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`.
 
 ```bash
-pip install -U thinkstack-cli>=3.0.1
+pip install -U thinkstack-cli>=4.0.0
 thinkstack init
 thinkstack setup          # connects to Claude Code, Cursor, or Antigravity
 thinkstack debug timeline

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

@@ -1,6 +1,6 @@
 [project]
 name = "thinkstack-core"
-version = "4.0.0"
+version = "4.1.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"]
+dev = ["pytest>=8.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.0.0 → thinkstack_core-4.1.0}/tests/test_s1_branch_merge.py

@@ -20,14 +20,14 @@ def test_commit_ids_are_deterministic_and_monotonic(tmp_path: Path) -> None:
     commits_dir = gcc_dir / "commits"
 
     # Expect two commits with deterministic, hex-encoded IDs starting from 1
-    files = sorted(p.name for p in commits_dir.glob("*.json"))
-    assert files == ["00000001.json", "00000002.json"]
+    files = sorted(p.name for p in commits_dir.glob("*.toon"))
+    assert files == ["00000001.toon", "00000002.toon"]
 
     # Re-open repo and commit once more: ID should continue monotonically
     repo2 = GCCRepository.at(tmp_path)
     repo2.commit("c3")
-    files = sorted(p.name for p in commits_dir.glob("*.json"))
-    assert files == ["00000001.json", "00000002.json", "00000003.json"]
+    files = sorted(p.name for p in commits_dir.glob("*.toon"))
+    assert files == ["00000001.toon", "00000002.toon", "00000003.toon"]
 
 
 def test_branch_and_history(tmp_path: Path) -> None:

{thinkstack_core-4.0.0 → thinkstack_core-4.1.0}/tests/test_s24_reasoning_plus_learning.py

@@ -31,6 +31,7 @@ from thinkstack_core.reasoning_plus.learning import (
     ReasoningCall,
     workspace_state_hash,
 )
+from thinkstack_core.serialization import loads as toon_loads
 
 
 # ---------------------------------------------------------------------------
@@ -433,7 +434,7 @@ class TestReasoningPlusLearning:
         )
         learnings = drpl.get_relevant_learnings("fix parse_date bug")
         assert len(learnings) >= 1
-        assert "utils.py" in learnings[0].content or "parse_date" in learnings[0].content
+        assert "parse_date" in learnings[0].content
 
     def test_compose_user_prompt(self, drpl):
         learnings = [Learning(content="Check foo.py first")]
@@ -574,7 +575,7 @@ class TestMCPLearningTools:
         repo = self._make_repo(temp_repo)
         self._seed_learning(repo)
         text = _dispatch_tool(repo, "thinkstack_reasoning_plus_learning_query", {"context": "fix parse_date bug"})
-        data = json.loads(text)
+        data = toon_loads(text)
         assert data["count"] >= 1
         assert "parse_date" in data["learnings"][0]["content"]
 
@@ -590,7 +591,7 @@ class TestMCPLearningTools:
             "thinkstack_reasoning_plus_learning_feedback",
             {"learning_id": learning.id, "outcome": "success"},
         )
-        data = json.loads(text)
+        data = toon_loads(text)
         assert data["confidence"] > 0.8
 
     def test_learning_purge(self, temp_repo):

{thinkstack_core-4.0.0 → thinkstack_core-4.1.0}/tests/test_s3_sensitivity.py

@@ -200,6 +200,7 @@ class TestSensitivityStore:
         store.add(SensitivityEvent("n1", "schema_version", "", 0.9, "PUBLIC"))
         store.add(SensitivityEvent("n2", "schema_version", "", 0.7, "PROTECTED"))
         store.add(SensitivityEvent("n3", "pii_fields", "", 0.6, "PRIVATE"))
+        import json
         index = json.loads((tmp_path / "sens" / "index.json").read_text())
         assert len(index["schema_version"]) == 2
         assert len(index["pii_fields"]) == 1

{thinkstack_core-4.0.0 → thinkstack_core-4.1.0}/tests/test_s7_mcp_hooks.py

@@ -15,6 +15,7 @@ Tests:
 from __future__ import annotations
 
 import json
+from thinkstack_core.serialization import loads as toon_loads
 import sys
 import io
 from pathlib import Path
@@ -287,13 +288,17 @@ class TestMCPServer(unittest.TestCase):
         resp = responses[0]
         self.assertIn("result", resp)
         tools = resp["result"]["tools"]
-        # 19 original tools + 3 S21 + 1 S23 sync status = 23
-        self.assertEqual(len(tools), 23)
+        # 23 new tools + 23 legacy devtorch_* aliases = 46
+        self.assertEqual(len(tools), 46)
         names = {t["name"] for t in tools}
         self.assertIn("thinkstack_commit", names)
+        self.assertIn("devtorch_commit", names)
         self.assertIn("thinkstack_sensitivity_add", names)
+        self.assertIn("devtorch_sensitivity_add", names)
         self.assertIn("thinkstack_context", names)
+        self.assertIn("devtorch_context", names)
         self.assertIn("thinkstack_theta_read", names)
+        self.assertIn("devtorch_theta_read", names)
         self.assertIn("thinkstack_reasoning_plus_config", names)
         self.assertIn("thinkstack_reasoning_plus_set", names)
         self.assertIn("thinkstack_reasoning_plus_learning_query", names)
@@ -384,7 +389,7 @@ class TestMCPServer(unittest.TestCase):
         }
         responses = self._call_jsonrpc(mock_repo, req)
         text = responses[0]["result"]["content"][0]["text"]
-        parsed = json.loads(text)
+        parsed = toon_loads(text)
         self.assertIn("auth", parsed)
         self.assertIn("api", parsed)
 
@@ -409,7 +414,7 @@ class TestMCPServer(unittest.TestCase):
         }
         responses = self._call_jsonrpc(mock_repo, req)
         text = responses[0]["result"]["content"][0]["text"]
-        parsed = json.loads(text)
+        parsed = toon_loads(text)
         self.assertIn("auth", parsed)
         self.assertIn("schema", parsed)
         self.assertNotIn("api", parsed)
@@ -453,7 +458,7 @@ class TestMCPServer(unittest.TestCase):
             }
             responses = self._call_jsonrpc(repo, req)
             text = responses[0]["result"]["content"][0]["text"]
-            parsed = json.loads(text)
+            parsed = toon_loads(text)
             self.assertIn("source", parsed)
             self.assertIn("config", parsed)
             self.assertIn("enabled", parsed["config"])
@@ -476,8 +481,8 @@ class TestMCPServer(unittest.TestCase):
             }
             responses = self._call_jsonrpc(repo, req)
             text = responses[0]["result"]["content"][0]["text"]
-            self.assertIn("\"enabled\": false", text)
-            settings = json.loads((repo.gcc_dir / "settings.json").read_text())
+            self.assertIn("enabled: false", text)
+            settings = toon_loads((repo.gcc_dir / "settings.toon").read_text()) if (repo.gcc_dir / "settings.toon").exists() else json.loads((repo.gcc_dir / "settings.json").read_text())
             self.assertFalse(settings["reasoning_plus"]["enabled"])
             self.assertEqual(settings["reasoning_plus"]["smart_top_n"], 5)
 

{thinkstack_core-4.0.0 → thinkstack_core-4.1.0}/tests/test_s7_parser.py

@@ -6,13 +6,15 @@ Tests for the S7 parser layer (thinkstack_core.parser).
 Coverage
 --------
 * extract_racp_blocks  — both block types, only commits, only sensitivities,
-                         malformed XML, no blocks, attribute-order variation
+                          malformed XML, no blocks, attribute-order variation
 * strip_racp_blocks    — blocks removed, surrounding text preserved,
-                         paired tags, mixed content
-* extract_thinking_blocks — Anthropic format, OpenAI format, empty / missing
+                          paired tags, mixed content
+* extract_thinking_blocks — Anthropic format, OpenAI format, Gemini format,
+                            DeepSeek/generic, generic XML/bracket tags,
+                            precedence order, nested tags, empty / missing
 * thinking_to_commit_message — normal, empty, long text, whitespace collapse
 * infer_sensitivity    — schema keywords, auth keywords, empty text,
-                         max_concepts limit, multi-match
+                          max_concepts limit, multi-match
 * extract_decision_summary — normal sentence, markdown-heavy, very long,
                               empty, code-fence stripping
 """
@@ -104,14 +106,10 @@ class TestExtractRacpBlocks:
     def test_malformed_tag_skipped_gracefully(self):
         """Malformed XML must not raise; valid blocks in same text are still extracted."""
         text = (
-            # malformed: unquoted attribute value
             '<thinkstack:commit message=not-quoted confidence="0.9"/>\n'
-            # valid block follows
             '<thinkstack:commit message="valid block" confidence="0.8"/>\n'
         )
-        # Should not raise
         commits, sensitivities = extract_racp_blocks(text)
-        # The valid block should be parsed
         valid = [c for c in commits if c.message == "valid block"]
         assert len(valid) == 1
 
@@ -356,6 +354,7 @@ class TestExtractThinkingBlocks:
         assert blocks == []
 
     def test_anthropic_thinking_block_empty_text_skipped(self):
+        """Empty thinking text should be skipped."""
         response = {
             "content": [
                 {"type": "thinking", "thinking": ""},
@@ -363,7 +362,6 @@ class TestExtractThinkingBlocks:
             ]
         }
         blocks = extract_thinking_blocks(response)
-        # Empty thinking text should be skipped
         assert len(blocks) == 1
         assert blocks[0].text == "Non-empty thought."
 
@@ -384,6 +382,332 @@ class TestExtractThinkingBlocks:
         blocks = extract_thinking_blocks(response)
         assert blocks == []
 
+    def test_gemini_format(self):
+        response = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {"text": "I need to check the API limits first.", "thought": True},
+                            {"text": "The answer is 42."},
+                        ]
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "I need to check the API limits first."
+        assert blocks[0].source == "gemini_thought"
+
+    def test_gemini_format_multiple_thoughts(self):
+        response = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {"text": "Thought one.", "thought": True},
+                            {"text": "Thought two.", "thought": True},
+                            {"text": "Final answer."},
+                        ]
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 2
+        assert blocks[0].text == "Thought one."
+        assert blocks[1].text == "Thought two."
+
+    def test_gemini_format_no_thoughts(self):
+        response = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {"text": "Direct answer without thinking."},
+                        ]
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert blocks == []
+
+    def test_deepseek_reasoning_content(self):
+        """DeepSeek / generic servers using reasoning_content field."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "The answer.",
+                        "reasoning_content": "DeepSeek reasoning goes here.",
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "DeepSeek reasoning goes here."
+        assert blocks[0].source == "reasoning_content"
+
+    def test_generic_reasoning_field_fallback(self):
+        """Some servers use 'reasoning' instead of 'reasoning_content'."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Final answer.",
+                        "reasoning": "Alternative field name.",
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "Alternative field name."
+        assert blocks[0].source == "reasoning"
+
+    def test_generic_chain_of_thought_field(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Final answer.",
+                        "chain_of_thought": "Step-by-step reasoning.",
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "Step-by-step reasoning."
+        assert blocks[0].source == "chain_of_thought"
+
+    def test_precedence_api_native_wins_over_generic_tags(self):
+        """API-native reasoning_content takes priority over generic tags in text."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<thinking>Should not be captured.</thinking>\nFinal answer.",
+                        "reasoning_content": "API-native reasoning wins.",
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "API-native reasoning wins."
+        assert blocks[0].source == "reasoning_content"
+
+    def test_generic_tag_thinking_in_output_text(self):
+        """<thinking> tags in response text when no API-native fields present."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<thinking>This is my reasoning.</thinking>\nFinal answer."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "This is my reasoning."
+        assert blocks[0].source == "tag_thinking"
+
+    def test_generic_tag_reasoning_in_output_text(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<reasoning>Step-by-step logic.</reasoning>\nOutput."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "Step-by-step logic."
+        assert blocks[0].source == "tag_reasoning"
+
+    def test_generic_bracket_thinking_in_output_text(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "[thinking]Bracket reasoning.[/thinking]\nFinal."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].text == "Bracket reasoning."
+        assert blocks[0].source == "bracket_thinking"
+
+    def test_generic_html_comment_with_reasoning_marker(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<!-- think: Reasoning inside HTML comment -->\nFinal answer."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert "Reasoning inside HTML comment" in blocks[0].text
+        assert blocks[0].source == "html_comment"
+
+    def test_generic_html_comment_with_reasoning_marker_lowercase(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<!-- reasoning Step-by-step logic. -->\nFinal."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert "Step-by-step logic." in blocks[0].text
+        assert blocks[0].source == "html_comment"
+
+    def test_generic_html_comment_false_positive_not_captured(self):
+        """Plain HTML comments without a reasoning marker must NOT be captured."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<!-- generated by tool -->\nFinal answer here."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert blocks == []
+
+    def test_generic_html_comment_false_positive_pii_disclaimer(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<!-- TODO: fix security issue -->\nThe answer is 42."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert blocks == []
+
+    def test_no_matching_generic_tag_returns_empty(self):
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Just a normal response with no tags."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert blocks == []
+
+    def test_nested_tags_first_closing_wins(self):
+        """Nested/overlapping tags: first matching closing tag captures content."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<thinking>Outer <reasoning>inner</reasoning> still outer</thinking>\nAnswer."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert "Outer" in blocks[0].text
+        assert blocks[0].source == "tag_thinking"
+
+    def test_multi_format_dedup_first_pattern_wins(self):
+        """When both <thinking> and [thinking] coexist, only first pattern used."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<thinking>XML thinking.</thinking>\n[thinking]Bracket thinking.[/thinking]"
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].source == "tag_thinking"
+
+    def test_multiple_thinking_tags_same_pattern_all_captured(self):
+        """Multiple occurrences of the SAME tag convention are all captured."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "<thinking>First thought.</thinking>\n<thinking>Second thought.</thinking>\nAnswer."
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 2
+        assert blocks[0].text == "First thought."
+        assert blocks[1].text == "Second thought."
+
+    def test_backward_compatibility_anthropic_still_works(self):
+        """Existing Anthropic-only tests must still pass."""
+        response = {
+            "content": [
+                {"type": "thinking", "thinking": "Thinking content."},
+                {"type": "text", "text": "Answer."},
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].source == "thinking_content"
+
+    def test_backward_compatibility_openai_still_works(self):
+        """Existing OpenAI-only tests must still pass."""
+        response = {
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Answer.",
+                        "reasoning_content": "OpenAI reasoning.",
+                    }
+                }
+            ]
+        }
+        blocks = extract_thinking_blocks(response)
+        assert len(blocks) == 1
+        assert blocks[0].source == "reasoning_content"
+
 
 # ===========================================================================
 # thinking_to_commit_message
@@ -401,10 +725,9 @@ class TestThinkingToCommitMessage:
         assert result == "auto: (no thinking content)"
 
     def test_truncation_at_max_chars(self):
-        long_text = "word " * 100  # 500 chars
+        long_text = "word " * 100
         blocks = [ThinkingBlock(text=long_text)]
         result = thinking_to_commit_message(blocks, max_chars=50)
-        # "auto: " is 6 chars, the rest is <= 50 chars of content
         content = result[len("auto: "):]
         assert len(content) <= 50
 
@@ -470,7 +793,6 @@ class TestInferSensitivity:
         text = "Update the environment configuration to point to the new endpoint."
         results = infer_sensitivity(text)
         concepts = [r.concept for r in results]
-        # Should match at least one of 'configuration' or 'api_interface'
         assert any(c in concepts for c in ("configuration", "api_interface"))
 
     def test_empty_text(self):
@@ -487,7 +809,6 @@ class TestInferSensitivity:
         assert results == []
 
     def test_max_concepts_limit(self):
-        # This text deliberately contains keywords for multiple concepts.
         text = (
             "The database migration affects the JWT auth token and the "
             "deploy pipeline and the cache layer."
@@ -534,7 +855,6 @@ class TestExtractDecisionSummary:
         )
         result = extract_decision_summary(text)
         assert result.startswith("auto: ")
-        # Markdown markers should be stripped
         assert "##" not in result
         assert "**" not in result
         assert "_" not in result
@@ -545,9 +865,7 @@ class TestExtractDecisionSummary:
             "The above code prints hello."
         )
         result = extract_decision_summary(text)
-        # Python syntax from inside the fence must be gone
         assert "print('hello')" not in result
-        # The plain-English sentence following the fence should be captured
         assert "prints hello" in result or result.startswith("auto: ")
 
     def test_very_long_text_truncated(self):
@@ -575,7 +893,6 @@ class TestExtractDecisionSummary:
             "We chose the first option."
         )
         result = extract_decision_summary(text)
-        # Bullet markers should not appear
         assert "- " not in result
 
     def test_numbered_list_stripped(self):
@@ -591,5 +908,4 @@ class TestExtractDecisionSummary:
         text = "This is\na sentence\nspread over lines."
         result = extract_decision_summary(text)
         assert result.startswith("auto: ")
-        # Should contain the content (collapsed)
         assert "\n" not in result

{thinkstack_core-4.0.0 → thinkstack_core-4.1.0}/tests/test_sync_bundle.py

@@ -193,8 +193,8 @@ class TestMergePull:
         result = merge_pull(gcc_dir, remote_delta, conflict_log)
         assert result["counts"]["commits"] == 2
         assert result["conflicts"] == []
-        assert (gcc_dir / "commits" / "c001.json").exists()
-        assert (gcc_dir / "commits" / "c002.json").exists()
+        assert (gcc_dir / "commits" / "c001.toon").exists()
+        assert (gcc_dir / "commits" / "c002.toon").exists()
 
     def test_merge_pull_detects_commit_id_collision(
         self, gcc_dir: Path, conflict_log: _MockConflictLog