webbee 0.3.0__tar.gz → 0.3.1__tar.gz

{webbee-0.3.0 → webbee-0.3.1}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.3.1
+
+- Auto-checkpointing no longer disables itself after a single transient
+  shadow-git error — it only pauses after repeated failures, and
+  `/checkpoints` shows when it's paused.
+
 ## 0.3.0
 
 - **The agent plans in the open.** A live todo checklist (📋) rendered from the

{webbee-0.3.0 → webbee-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.0
+Version: 0.3.1
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.3.0 → webbee-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.0"
+version = "0.3.1"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.1/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{webbee-0.3.0 → webbee-0.3.1}/src/webbee/checkpoints.py

@@ -44,7 +44,8 @@ class ShadowGit:
         base = cache_dir or os.path.expanduser("~/.cache/webbee")
         self.git_dir = os.path.join(base, "shadow", repo_key)
         self.available = False
-        self.auto_ok = True   # latched False after a failed AUTO snapshot (F8)
+        self.auto_ok = True        # auto-checkpointing enabled (F8 latch below)
+        self._auto_fail_streak = 0  # consecutive failed AUTO snapshots
 
     def _git(self, *args: str) -> "subprocess.CompletedProcess":
         cmd = (["git", "--git-dir", self.git_dir, "--work-tree", self.root]
@@ -202,12 +203,32 @@ class ShadowGit:
                  f"was saved first as checkpoint cp-{(undo or {}).get('n', '?')} "
                  f"({(undo or {}).get('id', '?')}), so this rollback is itself undoable.")}
 
+    _AUTO_FAIL_LATCH = 3   # consecutive AUTO failures before pausing auto-checkpointing
+
+    def note_auto_result(self, ok: bool) -> None:
+        """Record an AUTO (pre-write) snapshot outcome. A single transient
+        failure must NOT disable the session's time machine (final-review F8):
+        latch auto-checkpointing OFF only after _AUTO_FAIL_LATCH CONSECUTIVE
+        failures; any success resets the streak and re-enables it."""
+        if ok:
+            self._auto_fail_streak = 0
+            self.auto_ok = True
+        else:
+            self._auto_fail_streak += 1
+            if self._auto_fail_streak >= self._AUTO_FAIL_LATCH:
+                self.auto_ok = False
+
     def describe(self) -> str:
         """One printable block for the /checkpoints command."""
         if not self.available:
             return "Reversibility is off (git unavailable)."
         rows = self.list_checkpoints(limit=10)
         if not rows:
-            return "No checkpoints yet."
-        lines = [f"cp-{r['n']}  {r['id']}  {r['when']:>16}  {r['label']}" for r in rows]
-        return "Checkpoints (newest first) — /rollback <id|cp-N|N>:\n" + "\n".join(lines)
+            body = "No checkpoints yet."
+        else:
+            lines = [f"cp-{r['n']}  {r['id']}  {r['when']:>16}  {r['label']}" for r in rows]
+            body = "Checkpoints (newest first) — /rollback <id|cp-N|N>:\n" + "\n".join(lines)
+        if not self.auto_ok:
+            body = ("⚠ Auto-checkpointing is paused after repeated shadow errors — "
+                     "manual /checkpoint + /rollback still work.\n") + body
+        return body

{webbee-0.3.0 → webbee-0.3.1}/src/webbee/tools.py

@@ -36,16 +36,20 @@ class LocalToolExecutor:
             args = {}
         if (tool in _WRITE_TIER and self.shadow is not None
                 and getattr(self.shadow, "auto_ok", True)):
-            # The time machine snapshots BEFORE every mutation -- and must
-            # never block or fail the actual work. One failed AUTO snapshot
-            # latches auto-checkpointing OFF for this session (final-review
-            # F8: a huge un-ignored tree would otherwise re-stall every write
-            # tool); manual checkpoint/rollback still try.
+            # The time machine snapshots BEFORE every mutation -- and must never
+            # block or fail the actual work. A SINGLE transient failure must not
+            # disable the session (final-review F8): note_auto_result latches
+            # auto-checkpointing OFF only after several CONSECUTIVE failures; a
+            # success re-enables it. Manual checkpoint/rollback always try.
             try:
-                if self.shadow.checkpoint(f"pre:{tool}") is None:
-                    self.shadow.auto_ok = False
+                _cp = self.shadow.checkpoint(f"pre:{tool}")
+                _note = getattr(self.shadow, "note_auto_result", None)
+                if _note is not None:
+                    _note(_cp is not None)
             except Exception:
-                self.shadow.auto_ok = False
+                _note = getattr(self.shadow, "note_auto_result", None)
+                if _note is not None:
+                    _note(False)
         try:
             fn = getattr(self, f"_t_{tool}", None)
             if fn is None:

{webbee-0.3.0 → webbee-0.3.1}/tests/test_checkpoints.py

@@ -249,3 +249,30 @@ def test_failed_add_never_fakes_a_checkpoint(tmp_path, monkeypatch):
 def test_shadow_dir_is_private(tmp_path):
     sg, _root = _sg(tmp_path)
     assert (os.stat(sg.git_dir).st_mode & 0o777) == 0o700
+
+
+def test_auto_latch_survives_a_single_transient_failure(tmp_path):
+    sg, _root = _sg(tmp_path)
+    sg.note_auto_result(False)          # one transient miss
+    assert sg.auto_ok is True           # NOT disabled on a single failure
+    sg.note_auto_result(True)           # a success clears the streak
+    assert sg.auto_ok is True and sg._auto_fail_streak == 0
+
+
+def test_auto_latch_trips_after_consecutive_failures(tmp_path):
+    sg, _root = _sg(tmp_path)
+    for _ in range(sg._AUTO_FAIL_LATCH):
+        sg.note_auto_result(False)
+    assert sg.auto_ok is False          # latched after N consecutive
+    sg.note_auto_result(True)           # recovery re-enables
+    assert sg.auto_ok is True
+
+
+def test_describe_surfaces_paused_autocheckpoint(tmp_path):
+    sg, root = _sg(tmp_path)
+    _write(root, "a.txt", "x"); sg.checkpoint("c1")
+    for _ in range(sg._AUTO_FAIL_LATCH):
+        sg.note_auto_result(False)
+    out = sg.describe()
+    assert out.startswith("⚠ Auto-checkpointing is paused")
+    assert "cp-1" in out                # the list still follows the warning

{webbee-0.3.0 → webbee-0.3.1}/tests/test_tools.py

@@ -205,6 +205,8 @@ class _FakeShadow:
     def checkpoint(self, label=""):
         self.labels.append(label)
         return {"id": "abc1234", "n": len(self.labels), "label": label, "changed": True}
+    def note_auto_result(self, ok):
+        pass
     def diff(self, since=""):
         return f"DIFF since={since or 'HEAD'}"
     def rollback(self, to):
@@ -265,21 +267,43 @@ def test_reversibility_tools_honest_without_shadow(tmp_path):
         assert not r["ok"] and "unavailable" in r["content"]
 
 
-def test_auto_checkpoint_latches_off_after_failure(tmp_path):
+def test_auto_checkpoint_latches_off_after_consecutive_failures(tmp_path):
+    # Adapted from the P4 latch test (final-review F8): a SINGLE failed AUTO
+    # snapshot must no longer latch auto-checkpointing off; it now takes
+    # _AUTO_FAIL_LATCH CONSECUTIVE failures, driven through the real
+    # ShadowGit.note_auto_result via the executor.
     from webbee.tools import LocalToolExecutor
+    from webbee.checkpoints import ShadowGit
 
-    class _Flaky:
-        def __init__(self):
-            self.calls = 0
-            self.auto_ok = True
-        def checkpoint(self, label=""):
-            self.calls += 1
-            return None                      # simulated add/commit failure
-
-    sh = _Flaky()
-    ex = LocalToolExecutor(str(tmp_path), shadow=sh)
-    ex.run("write_file", {"path": "a.txt", "content": "1"})
-    ex.run("write_file", {"path": "b.txt", "content": "2"})
-    ex.run("write_file", {"path": "c.txt", "content": "3"})
-    assert sh.calls == 1                     # latched after the first failure
-    assert sh.auto_ok is False
+    sg = ShadowGit(str(tmp_path), "rk_f8_latch", cache_dir=str(tmp_path / "c3"))
+    assert sg.ensure()
+    calls = {"n": 0}
+    def _always_fails(label=""):
+        calls["n"] += 1
+        return None                          # every AUTO snapshot fails
+    sg.checkpoint = _always_fails
+    ex = LocalToolExecutor(str(tmp_path), shadow=sg)
+
+    for i in range(sg._AUTO_FAIL_LATCH - 1):
+        ex.run("write_file", {"path": f"f{i}.txt", "content": str(i)})
+        assert sg.auto_ok is True             # still enabled before the Nth failure
+
+    ex.run("write_file", {"path": "final.txt", "content": "x"})
+    assert calls["n"] == sg._AUTO_FAIL_LATCH  # latched only after N consecutive failures
+    assert sg.auto_ok is False
+
+
+def test_executor_single_transient_does_not_latch(tmp_path):
+    from webbee.tools import LocalToolExecutor
+    from webbee.checkpoints import ShadowGit
+    sg = ShadowGit(str(tmp_path), "rk_f8", cache_dir=str(tmp_path / "c"))
+    assert sg.ensure()
+    calls = {"n": 0}
+    def _flaky(label=""):
+        calls["n"] += 1
+        return None if calls["n"] == 1 else {"id": "x", "n": calls["n"], "label": label, "changed": True}
+    sg.checkpoint = _flaky
+    ex = LocalToolExecutor(str(tmp_path), shadow=sg)
+    ex.run("write_file", {"path": "a.txt", "content": "1"})   # transient miss
+    ex.run("write_file", {"path": "b.txt", "content": "2"})   # success -> streak reset
+    assert sg.auto_ok is True                                  # still enabled

webbee-0.3.0/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.0"