superqode 2.5.3__tar.gz → 2.5.4__tar.gz

{superqode-2.5.3 → superqode-2.5.4}/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.5.4] - 2026-10-03
+
+### Fixed
+
+- Preserve Core's baseline tool-output bounding in context shadow mode while
+  retaining durable evidence references. Only enforce mode substitutes excerpts.
+- Reuse Jev context selections across small assistant continuations and restart.
+  Align cache validity with selection triggers; changed tasks, instructions,
+  evidence, errors and tool calls invalidate prior decisions.
+
+### Notes
+
+- Context selection remains opt-in and defaults to `off`. Shadow mode records
+  proposed excerpts; only enforce mode applies them. Jev selection remains
+  experimental, with bounded calls and conservative fallback.
+
 ## [2.5.3] - 2026-10-03
 
 ### Highlights

{superqode-2.5.3 → superqode-2.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.5.3
+Version: 2.5.4
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.5.3 → superqode-2.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.5.3"
+version = "2.5.4"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.5.3 → superqode-2.5.4}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.5.3"
+__version__ = "2.5.4"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.5.3 → superqode-2.5.4}/src/superqode/agent/loop.py

@@ -2407,8 +2407,11 @@ class AgentLoop:
                 )
                 self._context_artifact_store = store
                 self._ensure_context_chunk_tool()
+                result = replace(
+                    result, metadata={**result.metadata, "context_reference": record.reference}
+                )
                 cap = self._tool_output_byte_cap or 100_000
-                if len(output.encode()) > cap:
+                if policy.mode == "enforce" and len(output.encode()) > cap:
                     excerpt = reference_excerpt(
                         ContextCandidate(
                             0,

{superqode-2.5.3 → superqode-2.5.4}/src/superqode/harness/context_policy.py

@@ -16,7 +16,7 @@ from .context_artifacts import ContextArtifactStore
 from superqode.systemone.state import redact_evidence, prepare_decision_state
 from superqode.systemone.types import NoulQuestion
 
-POLICY_VERSION = "1"
+POLICY_VERSION = "2"
 
 
 @dataclass(frozen=True)
@@ -128,9 +128,6 @@ class ContextPolicyEngine:
             db.execute("""CREATE TABLE IF NOT EXISTS context_scorer_attempts (
                 scope TEXT NOT NULL, run_key TEXT NOT NULL, count INTEGER NOT NULL,
                 PRIMARY KEY(scope,run_key))""")
-            db.execute("""CREATE TABLE IF NOT EXISTS context_selection_triggers (
-                scope TEXT NOT NULL, run_key TEXT NOT NULL, signature TEXT NOT NULL,
-                PRIMARY KEY(scope,run_key))""")
 
     async def prepare(
         self,
@@ -200,31 +197,49 @@ class ContextPolicyEngine:
         trace["candidate_count"] = len(candidates)
         if not candidates:
             return self._finish((), {}, trace)
-        # Include all native context hashes so a changed instruction, step, result
-        # or unresolved error cannot reuse an earlier relevance decision.
-        key = hashlib.sha256(
+        # Keep the full input digest for diagnostics. Cache validity and selector
+        # triggers share one key; small plain assistant additions can reuse a
+        # decision only if the previous history is otherwise unchanged.
+        fingerprints = [self._item_fingerprint(item) for item in items]
+        cache_inputs = {
+            "policy": asdict(p),
+            "version": POLICY_VERSION,
+            "scorer_identity": f"{type(self.client).__module__}.{type(self.client).__name__}:{getattr(self.client, 'model', '')}",
+            "branch": branch,
+            "instructions": instruction_version,
+            "pressure_bucket": before // p.pressure_chars,
+            "items": [
+                fingerprint
+                for item, fingerprint in zip(items, fingerprints)
+                if not self._small_step(item)
+            ],
+            "candidates": [
+                {k: v for k, v in asdict(c).items() if k != "index"} for c in candidates
+            ],
+        }
+        key = hashlib.sha256(json.dumps(cache_inputs, sort_keys=True).encode()).hexdigest()
+        trace["input_sha256"] = hashlib.sha256(
             json.dumps(
                 {
-                    "policy": asdict(p),
-                    "version": POLICY_VERSION,
-                    "scorer_identity": f"{type(self.client).__module__}.{type(self.client).__name__}:{getattr(self.client, 'model', '')}",
-                    "branch": branch,
-                    "instructions": instruction_version,
+                    **cache_inputs,
                     "items": [asdict(item) for item in items],
                     "candidates": [asdict(c) for c in candidates],
                 },
                 sort_keys=True,
             ).encode()
         ).hexdigest()
-        trace["input_sha256"] = key
         with sqlite3.connect(self.store.path) as db:
             cached = db.execute(
                 "SELECT value FROM context_decisions WHERE scope=? AND key=?", (self.scope, key)
             ).fetchone()
         decisions: tuple[ContextDecision, ...] = ()
-        if cached:
-            decisions = tuple(ContextDecision(**v) for v in json.loads(cached[0]))
+        cached_state = json.loads(cached[0]) if cached else None
+        if cached_state and not self._unchanged_continuation(cached_state["history"], items):
+            cached_state = None
+        if cached_state:
+            decisions = tuple(ContextDecision(**v) for v in cached_state["decisions"])
             trace["cache_hit"] = True
+            trace["fallback"] = trace["fallback"] or cached_state["fallback"]
         elif p.selector == "rules":
             decisions = tuple(
                 ContextDecision(c.reference, "excerpt_with_reference", "old_large_output")
@@ -242,10 +257,6 @@ class ContextPolicyEngine:
                 trace["fallback"] = "scorer_unavailable"
             elif capped:
                 trace["fallback"] = "selector_spend_not_reserved"
-            elif not self._selection_trigger(
-                run_key or "session", task, candidates, before, instruction_version
-            ):
-                trace["fallback"] = "no_selection_trigger"
             elif not self._reserve_call(run_key or hashlib.sha256(task.encode()).hexdigest()):
                 trace["fallback"] = "scorer_call_limit"
             else:
@@ -310,12 +321,23 @@ class ContextPolicyEngine:
                 ContextDecision(c.reference, "keep", trace["fallback"] or "retain_evidence")
                 for c in candidates
             )
-        if not cached:
-            with sqlite3.connect(self.store.path) as db:
-                db.execute(
-                    "INSERT OR REPLACE INTO context_decisions VALUES (?,?,?)",
-                    (self.scope, key, json.dumps([asdict(v) for v in decisions])),
-                )
+        # Advance the history anchor on reuse too: subsequent edits or removal
+        # of any accepted step must invalidate the decision, including restart.
+        with sqlite3.connect(self.store.path) as db:
+            db.execute(
+                "INSERT OR REPLACE INTO context_decisions VALUES (?,?,?)",
+                (
+                    self.scope,
+                    key,
+                    json.dumps(
+                        {
+                            "decisions": [asdict(v) for v in decisions],
+                            "history": fingerprints,
+                            "fallback": trace["fallback"],
+                        }
+                    ),
+                ),
+            )
         chosen = {d.reference for d in decisions if d.action == "excerpt_with_reference"}
         proposed = {c.index: reference_excerpt(c) for c in candidates if c.reference in chosen}
         after = before - sum(len(items[i].text) - len(text) for i, text in proposed.items())
@@ -346,29 +368,28 @@ class ContextPolicyEngine:
             )
         return True
 
-    def _selection_trigger(self, run_key, task, candidates, chars, instruction_version):
-        signature = hashlib.sha256(
-            json.dumps(
-                {
-                    "task": hashlib.sha256(task.encode()).hexdigest(),
-                    "evidence": sorted(c.digest for c in candidates),
-                    "pressure_bucket": chars // self.policy.pressure_chars,
-                    "policy": asdict(self.policy),
-                    "instructions": instruction_version,
-                },
-                sort_keys=True,
-            ).encode()
-        ).hexdigest()
-        with sqlite3.connect(self.store.path, timeout=10) as db:
-            db.execute("BEGIN IMMEDIATE")
-            previous = db.execute(
-                "SELECT signature FROM context_selection_triggers WHERE scope=? AND run_key=?",
-                (self.scope, run_key),
-            ).fetchone()
-            if previous and previous[0] == signature:
+    def _small_step(self, item: ContextItem) -> bool:
+        return (
+            item.role == "assistant"
+            and not item.is_error
+            and not item.tool
+            and not item.call_id
+            and not item.arguments
+            and len(item.text) <= self.policy.excerpt_chars
+        )
+
+    @staticmethod
+    def _item_fingerprint(item: ContextItem) -> str:
+        # Core identities contain message positions, which shift on insertion.
+        # Candidate references separately bind eligible evidence to provenance.
+        value = {k: v for k, v in asdict(item).items() if k != "identity"}
+        return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
+
+    def _unchanged_continuation(self, previous: list[str], items: list[ContextItem]) -> bool:
+        position = 0
+        for item in items:
+            if position < len(previous) and self._item_fingerprint(item) == previous[position]:
+                position += 1
+            elif not self._small_step(item):
                 return False
-            db.execute(
-                "INSERT OR REPLACE INTO context_selection_triggers VALUES (?,?,?)",
-                (self.scope, run_key, signature),
-            )
-        return True
+        return position == len(previous)

{superqode-2.5.3 → superqode-2.5.4}/src/superqode/harness/core_context.py

@@ -61,6 +61,8 @@ def core_items(messages):
         if message.role == "tool" and call_id not in calls:
             call_id = ""
         identity = f"{index}:{call_id}:{hashlib.sha256(text.encode()).hexdigest()}"
+        if message.role == "assistant" and getattr(message, "tool_calls", None):
+            arguments = {"tool_calls": message.tool_calls}
         items.append(
             ContextItem(
                 identity,

{superqode-2.5.3 → superqode-2.5.4}/src/superqode/harness/pipy_context.py

@@ -59,6 +59,14 @@ def pipy_items(messages):
             else ""
         )
         identity = f"{getattr(message, 'timestamp', 0)}:{call_id}:{hashlib.sha256(text.encode()).hexdigest()}"
+        arguments = call.arguments if call else {}
+        if role == "assistant" and getattr(message, "tool_calls", ()):
+            arguments = {
+                "tool_calls": [
+                    {"id": c.id, "name": c.name, "arguments": c.arguments}
+                    for c in message.tool_calls
+                ]
+            }
         items.append(
             ContextItem(
                 identity,
@@ -66,7 +74,7 @@ def pipy_items(messages):
                 text,
                 getattr(message, "tool_name", ""),
                 call_id,
-                call.arguments if call else {},
+                arguments,
                 bool(getattr(message, "is_error", False)),
             )
         )

{superqode-2.5.3 → superqode-2.5.4}/src/superqode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.5.3
+Version: 2.5.4
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.5.3 → superqode-2.5.4}/tests/test_context_policy.py

@@ -1,10 +1,10 @@
 import json
+from dataclasses import replace
 
 import pytest
 
 from superqode.harness.context_artifacts import ContextArtifactStore
 from superqode.harness.context_policy import ContextItem, ContextPolicy, ContextPolicyEngine
-from superqode.systemone.client import StubSystemOneClient
 
 
 def history():
@@ -26,6 +26,152 @@ def history():
     ]
 
 
+class SelectingClient:
+    calls = 0
+    model = "pinned-selector"
+
+    async def evaluate(self, state, questions):
+        self.calls += 1
+
+        class Answers:
+            def noul(self, key):
+                return 0.01
+
+        return Answers()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "change",
+    [
+        "task",
+        "instructions",
+        "evidence",
+        "arguments",
+        "error",
+        "edit-step",
+        "remove-step",
+        "long-step",
+        "tool-call",
+        "small-result",
+        "branch",
+        "instruction-version",
+        "model",
+        "pressure",
+    ],
+)
+async def test_changed_relevance_rescores_instead_of_reusing_or_restoring(tmp_path, change):
+    client = SelectingClient()
+    items = history()
+    policy = ContextPolicy(
+        mode="enforce",
+        selector="jev",
+        recent_messages=1,
+        pressure_chars=sum(len(v.text) for v in items) + 10,
+    )
+    engine = ContextPolicyEngine(
+        ContextArtifactStore(tmp_path / "e.sqlite"), "scope", policy, client=client
+    )
+    first = await engine.prepare(items, run_key="run")
+    assert first.replacements
+    kwargs = {}
+    if change == "task":
+        items[1] = replace(items[1], text="Fix payments")
+    elif change == "instructions":
+        items[0] = replace(items[0], text="Never edit payment files")
+    elif change == "evidence":
+        items[3] = replace(items[3], identity="new-result", text=items[3].text + "changed")
+    elif change == "arguments":
+        items[3] = replace(items[3], identity="new-result", arguments={"path": "payments.py"})
+    elif change == "error":
+        items.insert(-1, ContextItem("failure", "assistant", "Error: test failed", is_error=True))
+    elif change == "edit-step":
+        items[5] = replace(items[5], text="Reconsider the full evidence")
+    elif change == "remove-step":
+        del items[2]
+    elif change == "long-step":
+        items.insert(-1, ContextItem("reasoning", "assistant", "reasoning " * 101))
+    elif change == "tool-call":
+        items.insert(
+            -1, ContextItem("call", "assistant", "", arguments={"tool_calls": [{"name": "bash"}]})
+        )
+    elif change == "small-result":
+        items.insert(-1, ContextItem("result-2", "tool", "new fact", "read_file", "call-4"))
+    elif change == "branch":
+        kwargs["branch"] = "fork"
+    elif change == "instruction-version":
+        kwargs["instruction_version"] = "updated"
+    elif change == "model":
+        client.model = "changed-selector"
+    elif change == "pressure":
+        items.insert(-1, ContextItem("step", "assistant", "A slightly longer step"))
+    second = await engine.prepare(items, run_key="run", **kwargs)
+    assert not second.trace["cache_hit"]
+    assert second.trace["scorer_calls"] == 1
+    assert second.replacements and client.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_reused_steps_become_part_of_restart_invalidation(tmp_path):
+    store = ContextArtifactStore(tmp_path / "e.sqlite")
+    client = SelectingClient()
+    policy = ContextPolicy(mode="enforce", selector="jev", recent_messages=1)
+    engine = ContextPolicyEngine(store, "scope", policy, client=client)
+    await engine.prepare(history(), run_key="run")
+    items = history()
+    items.insert(-1, ContextItem("step", "assistant", "Continue"))
+    assert (await engine.prepare(items, run_key="run")).trace["cache_hit"]
+    restarted = ContextPolicyEngine(store, "scope", policy, client=client)
+    items[-2] = replace(items[-2], text="Reconsider")
+    assert not (await restarted.prepare(items, run_key="run")).trace["cache_hit"]
+    assert client.calls == 2
+
+
+@pytest.mark.asyncio
+async def test_cached_selection_cannot_replace_newly_denied_or_error_evidence(tmp_path):
+    allowed = True
+    store = ContextArtifactStore(tmp_path / "e.sqlite", authorize=lambda *_: allowed)
+    client = SelectingClient()
+    engine = ContextPolicyEngine(
+        store,
+        "scope",
+        ContextPolicy(mode="enforce", selector="jev", recent_messages=1),
+        client=client,
+    )
+    assert (await engine.prepare(history())).replacements
+    allowed = False
+    denied = await engine.prepare(history())
+    assert not denied.replacements and denied.trace["fallback"] == "artifact_unavailable"
+    allowed = True
+    items = history()
+    items[3] = replace(items[3], is_error=True)
+    protected = await engine.prepare(items)
+    assert not protected.replacements
+    assert client.calls == 1
+
+
+@pytest.mark.asyncio
+async def test_successful_selection_survives_small_continuations_and_restart(tmp_path):
+    path = tmp_path / "e.sqlite"
+    client = SelectingClient()
+    policy = ContextPolicy(mode="enforce", selector="jev", recent_messages=1)
+    engine = ContextPolicyEngine(ContextArtifactStore(path), "scope", policy, client=client)
+    first = await engine.prepare(history(), run_key="run")
+    changed = history()
+    changed.insert(-1, ContextItem("new", "assistant", "Another small step"))
+    second = await engine.prepare(changed, run_key="run")
+    assert first.replacements == second.replacements
+    assert second.trace["chars_after"] == first.trace["chars_after"] + len("Another small step")
+    assert second.trace["cache_hit"] and second.trace["scorer_calls"] == 0
+    assert second.trace["input_sha256"] != first.trace["input_sha256"]
+    restarted = ContextPolicyEngine(ContextArtifactStore(path), "scope", policy, client=client)
+    changed.insert(-1, ContextItem("later", "assistant", "Continue"))
+    third = await restarted.prepare(changed, run_key="run")
+    assert third.replacements == first.replacements
+    assert third.trace["cache_hit"]
+    assert client.calls == 1
+
+
 @pytest.mark.asyncio
 async def test_shadow_enforce_restart_cache_and_protections(tmp_path):
     store = ContextArtifactStore(tmp_path / "e.sqlite")
@@ -155,9 +301,9 @@ async def test_timeout_is_cached_and_small_steps_do_not_call_selector(tmp_path):
     # Keep the latest protected evidence protected as the conversation grows.
     changed = history()
     changed.insert(-1, ContextItem("new", "assistant", "Another small step"))
-    assert (await engine.prepare(changed, run_key="run")).trace[
-        "fallback"
-    ] == "no_selection_trigger"
+    continuation = await engine.prepare(changed, run_key="run")
+    assert continuation.trace["fallback"] == "scorer_failed"
+    assert continuation.trace["cache_hit"] and not continuation.replacements
     assert client.calls == 1
 
 

{superqode-2.5.3 → superqode-2.5.4}/tests/test_core_host_context.py

@@ -68,8 +68,48 @@ def test_complete_output_captured_before_core_cap(tmp_path, monkeypatch):
         arguments={"path": "app.py"},
     )
     assert len(result.output) < len(original)
-    assert "secret" not in result.output
     reference = result.metadata["context_reference"]
     artifact = ContextArtifactStore(tmp_path / "context.sqlite").describe("session", reference)
     assert artifact.chars > 29_000
     assert "secret" not in core._context_page(reference).text
+
+
+@pytest.mark.parametrize(
+    "original",
+    ["x" * 4000, "x" * 4600, "x" * 7000, "漢字🙂" * 2400],
+    ids=["at-cap", "within-slack", "over-slack", "unicode"],
+)
+def test_shadow_capture_preserves_baseline_bounding(tmp_path, monkeypatch, original):
+    from superqode.tools.base import ToolResult
+
+    monkeypatch.setenv("SUPERQODE_CONTEXT_STORE", str(tmp_path / "context.sqlite"))
+    # Use a fixed spill destination so the actual baseline previews compare
+    # exactly, without different random filenames masking a behavioral change.
+    monkeypatch.setattr(
+        "superqode.tools.output_spill.spill_output",
+        lambda *_args, **_kwargs: tmp_path / "spill.txt",
+    )
+    results = {}
+    for mode in ("off", "shadow", "enforce"):
+        core = loop(tmp_path)
+        core.config.harness_spec = SimpleNamespace(
+            runtime=SimpleNamespace(config={"context": {"mode": mode}})
+        )
+        results[mode] = core._bound_tool_result(
+            "read_file",
+            ToolResult(True, original, metadata={"invocation_id": "call"}),
+            arguments={"path": "app.py"},
+        )
+    assert results["shadow"].output == results["off"].output
+    assert results["shadow"].success == results["off"].success
+    assert results["shadow"].error == results["off"].error
+    assert results["shadow"].metadata.get("loop_truncated") == results["off"].metadata.get(
+        "loop_truncated"
+    )
+    assert results["shadow"].metadata.get("spilled_to") == results["off"].metadata.get("spilled_to")
+    reference = results["shadow"].metadata["context_reference"]
+    assert ContextArtifactStore(tmp_path / "context.sqlite").describe(
+        "session", reference
+    ).chars == len(original)
+    if len(original.encode()) > 4000:
+        assert results["enforce"].output != results["off"].output