errlore 0.2.0__tar.gz → 0.2.2__tar.gz

{errlore-0.2.0 → errlore-0.2.2}/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.2] - 2026-07-11
+
+### Fixed
+- `__version__` (and `errlore --version`) now reads the installed package
+  metadata instead of a hardcoded string — 0.2.0/0.2.1 wheels reported
+  themselves as 0.1.4.
+
+## [0.2.1] - 2026-07-11
+
+### Fixed
+- **Claude Code integration: failed Bash commands are now actually captured.**
+  Current Claude Code routes tool failures to the dedicated
+  `PostToolUseFailure` event (`PostToolUse` fires only on success), so the
+  previous hook never saw a failure — the loop was silently inert. New
+  `post_tool_use_failure()` handler parses the real payload (top-level `error`
+  string, `is_interrupt` guard); `errlore init claude-code` now installs and
+  registers all three hooks. The legacy PostToolUse handler stays for older
+  Claude Code versions. Verified against the official hooks reference; example
+  shims and `settings.json.example` updated to match.
+- `errlore stats` / `errlore lessons` now print the resolved data dir (to
+  stderr) — running them next to a quickstart `./agent_memory` while the
+  default points at `~/.errlore/claude-code` silently showed zeros.
+
+### Changed
+- Docs/site model placeholder refreshed `gpt-5.5` → `gpt-5.6` (released
+  2026-07-09); site JSON-LD `softwareVersion` unstuck from 0.1.4.
+
 ## [0.2.0] - 2026-07-11 — "The Proof Release"
 
 The headline benchmark is now proven on all three generality axes:

{errlore-0.2.0 → errlore-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: errlore
-Version: 0.2.0
+Version: 0.2.2
 Summary: Memory for AI agents that learns from failures: lessons, known-issues injection, and per-model trust — embedded, file-based, no server.
 Project-URL: Homepage, https://errlore.com
 Project-URL: Repository, https://github.com/Ma4etaSS/errlore
@@ -50,7 +50,7 @@ Your agent keeps making the same mistakes. errlore fixes that:
 
 - **Lessons** -- every resolved failure becomes a lesson; relevant lessons are injected
   into the prompt for similar future tasks.
-- **Known issues** -- per-model weakness tracking ("gpt-5.5 keeps hallucinating dates in
+- **Known issues** -- per-model weakness tracking ("gpt-5.6 keeps hallucinating dates in
   extraction tasks") injected as warnings.
 - **Trust** *(experimental)* -- Bayesian per-model, per-domain trust weights: a starting
   point for which model to pick per job, based on observed outcomes. Needs a spread of
@@ -88,14 +88,14 @@ from errlore import AgentMemory
 mem = AgentMemory("./agent_memory")
 
 # 1. Agent failed -- record it
-err_id = mem.log_error("gpt-5.5", "extraction", error="hallucinated dates")
+err_id = mem.log_error("gpt-5.6", "extraction", error="hallucinated dates")
 
 # 2. You fixed it -- extract a lesson
 mem.resolve(err_id, "Added date format validation",
             lesson="For date extraction, demand ISO-8601 and verify against source")
 
 # 3. Next similar task -- lessons + known issues injected automatically
-inj = mem.inject_for("extract dates from contract", model="gpt-5.5",
+inj = mem.inject_for("extract dates from contract", model="gpt-5.6",
                       task_type="extraction")
 prompt = f"Your task: extract dates\n{inj.text}"
 print(prompt)
@@ -107,7 +107,7 @@ mem.report_outcome(inj, success=True)
 print(mem.stats())
 # {'errors_total': 1, 'errors_resolved': 1, 'errors_unresolved': 0,
 #  'lessons_total': 1, 'lessons_applied': 1, 'pending_injections': 0,
-#  'trust': {'gpt-5.5': 0.5522...}}
+#  'trust': {'gpt-5.6': 0.5522...}}
 ```
 
 No API keys needed. errlore itself never calls any LLM -- it manages local

{errlore-0.2.0 → errlore-0.2.2}/README.md

@@ -16,7 +16,7 @@ Your agent keeps making the same mistakes. errlore fixes that:
 
 - **Lessons** -- every resolved failure becomes a lesson; relevant lessons are injected
   into the prompt for similar future tasks.
-- **Known issues** -- per-model weakness tracking ("gpt-5.5 keeps hallucinating dates in
+- **Known issues** -- per-model weakness tracking ("gpt-5.6 keeps hallucinating dates in
   extraction tasks") injected as warnings.
 - **Trust** *(experimental)* -- Bayesian per-model, per-domain trust weights: a starting
   point for which model to pick per job, based on observed outcomes. Needs a spread of
@@ -54,14 +54,14 @@ from errlore import AgentMemory
 mem = AgentMemory("./agent_memory")
 
 # 1. Agent failed -- record it
-err_id = mem.log_error("gpt-5.5", "extraction", error="hallucinated dates")
+err_id = mem.log_error("gpt-5.6", "extraction", error="hallucinated dates")
 
 # 2. You fixed it -- extract a lesson
 mem.resolve(err_id, "Added date format validation",
             lesson="For date extraction, demand ISO-8601 and verify against source")
 
 # 3. Next similar task -- lessons + known issues injected automatically
-inj = mem.inject_for("extract dates from contract", model="gpt-5.5",
+inj = mem.inject_for("extract dates from contract", model="gpt-5.6",
                       task_type="extraction")
 prompt = f"Your task: extract dates\n{inj.text}"
 print(prompt)
@@ -73,7 +73,7 @@ mem.report_outcome(inj, success=True)
 print(mem.stats())
 # {'errors_total': 1, 'errors_resolved': 1, 'errors_unresolved': 0,
 #  'lessons_total': 1, 'lessons_applied': 1, 'pending_injections': 0,
-#  'trust': {'gpt-5.5': 0.5522...}}
+#  'trust': {'gpt-5.6': 0.5522...}}
 ```
 
 No API keys needed. errlore itself never calls any LLM -- it manages local

{errlore-0.2.0 → errlore-0.2.2}/examples/claude-code/README.md

@@ -2,9 +2,12 @@
 
 Give your coding agent a memory of its own failures across sessions:
 
-- **PostToolUse hook** — every failed Bash command is logged into errlore.
-  Resolve the ones you fixed (`mem.resolve(err_id, ..., lesson=...)`) or use
-  `mem.add_lesson()` to capture takeaways directly.
+- **PostToolUseFailure hook** — every failed Bash command is logged into
+  errlore. Current Claude Code reports tool failures on this dedicated event
+  (PostToolUse fires only on success); a legacy PostToolUse hook is installed
+  too for older versions. Resolve the ones you fixed
+  (`mem.resolve(err_id, ..., lesson=...)`) or use `mem.add_lesson()` to
+  capture takeaways directly.
 - **SessionStart hook** — each new session begins with a briefing block of
   relevant lessons and per-tool KNOWN ISSUES, printed into the context.
 
@@ -16,7 +19,7 @@ errlore init claude-code            # global (~/.claude/settings.json)
 errlore init claude-code --project  # or this repo only (./.claude/settings.json)
 ```
 
-That writes the two hook scripts (to `~/.errlore/hooks/`) and merges them into
+That writes the three hook scripts (to `~/.errlore/hooks/`) and merges them into
 your `settings.json` — idempotently, preserving any hooks you already have.
 Restart Claude Code (or open a new session) to pick them up. Options:
 `--data-dir` (where the memory lives, default `~/.errlore/claude-code`) and
@@ -26,12 +29,13 @@ Handy afterwards: `errlore stats` and `errlore lessons` to see what it learned.
 
 ### Manual setup (if you'd rather wire it yourself)
 
-The scripts in this folder (`errlore_posttooluse.py`, `errlore_sessionstart.py`)
-plus `settings.json.example` show the shape: copy them somewhere stable, fix the
+The scripts in this folder (`errlore_posttoolusefailure.py`,
+`errlore_posttooluse.py`, `errlore_sessionstart.py`) plus
+`settings.json.example` show the shape: copy them somewhere stable, fix the
 paths, and merge into `.claude/settings.json`. `export ERRLORE_DATA=...` picks
 the memory dir.
 
 Notes: hook event field names can differ between Claude Code versions —
-the PostToolUse script reads them defensively and never breaks the agent
+both failure scripts read them defensively and never break the agent
 loop (exit 0 on anything unexpected). Check `claude --help` / the hooks
 docs for your version if events don't arrive.

errlore-0.2.2/examples/claude-code/errlore_posttoolusefailure.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""Claude Code PostToolUseFailure hook: failed Bash commands become errlore errors.
+
+Current Claude Code routes tool FAILURES to this dedicated event (PostToolUse
+fires only on success). The payload carries `tool_name`, `tool_input` and a
+top-level `error` string — no `tool_response`, no structured exit code.
+Pair with errlore_sessionstart.py, which briefs the next session on them.
+"""
+
+import json
+import os
+import sys
+
+from errlore import AgentMemory
+
+DATA_DIR = os.environ.get("ERRLORE_DATA", os.path.expanduser("~/.errlore/claude-code"))
+
+
+def main() -> int:
+    try:
+        event = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        return 0  # never break the agent loop
+
+    if event.get("tool_name", "") != "Bash":
+        return 0
+    if bool(event.get("is_interrupt")):
+        return 0  # user pressed Esc — not a failure worth learning from
+
+    command = str((event.get("tool_input") or {}).get("command", ""))[:160]
+    error = str(event.get("error") or "")[:200]
+    if not command and not error:
+        return 0
+    mem = AgentMemory(DATA_DIR)
+    mem.log_error("claude-code", "bash", f"CommandFailed: {command} :: {error}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{errlore-0.2.0 → errlore-0.2.2}/examples/claude-code/settings.json.example

@@ -11,6 +11,17 @@
         ]
       }
     ],
+    "PostToolUseFailure": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 /path/to/errlore_posttoolusefailure.py"
+          }
+        ]
+      }
+    ],
     "SessionStart": [
       {
         "hooks": [

{errlore-0.2.0 → errlore-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "errlore"
-version = "0.2.0"
+version = "0.2.2"
 description = "Memory for AI agents that learns from failures: lessons, known-issues injection, and per-model trust — embedded, file-based, no server."
 readme = "README.md"
 license = "MIT"

{errlore-0.2.0 → errlore-0.2.2}/site/index.html

@@ -32,7 +32,7 @@
   "url": "https://errlore.com/",
   "downloadUrl": "https://pypi.org/project/errlore/",
   "installUrl": "https://pypi.org/project/errlore/",
-  "softwareVersion": "0.1.4",
+  "softwareVersion": "0.2.1",
   "license": "https://opensource.org/licenses/MIT",
   "programmingLanguage": "Python",
   "codeRepository": "https://github.com/Ma4etaSS/errlore",
@@ -227,7 +227,7 @@
 mem = AgentMemory(<span class="c-str">"./agent_memory"</span>)
 
 <span class="c-com"># 1. agent failed — record it</span>
-err = mem.log_error(<span class="c-str">"gpt-5.5"</span>, <span class="c-str">"extraction"</span>, error=<span class="c-str">"hallucinated dates"</span>)
+err = mem.log_error(<span class="c-str">"gpt-5.6"</span>, <span class="c-str">"extraction"</span>, error=<span class="c-str">"hallucinated dates"</span>)
 
 <span class="c-com"># 2. you fixed it — extract the lesson</span>
 mem.resolve(err, <span class="c-str">"added validation"</span>,
@@ -235,7 +235,7 @@ mem.resolve(err, <span class="c-str">"added validation"</span>,
 
 <span class="c-com"># 3. next similar task — memory speaks up</span>
 task = <span class="c-str">"extract dates from contract"</span>
-inj = mem.inject_for(task, model=<span class="c-str">"gpt-5.5"</span>, task_type=<span class="c-str">"extraction"</span>)
+inj = mem.inject_for(task, model=<span class="c-str">"gpt-5.6"</span>, task_type=<span class="c-str">"extraction"</span>)
 prompt = task + <span class="c-str">"\n\n"</span> + inj.text
 <span class="c-out"># [LESSONS FROM PAST FAILURES]
 # - UnclassifiedError: hallucinated dates -> For date extraction,

errlore-0.2.2/src/errlore/__init__.py

@@ -0,0 +1,24 @@
+"""errlore -- memory for AI agents that learns from failures."""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+
+try:
+    # Single source of truth: installed package metadata (pyproject version).
+    # A hardcoded string here shipped 0.2.x wheels reporting themselves 0.1.4.
+    __version__ = _pkg_version("errlore")
+except PackageNotFoundError:  # source tree without an install
+    __version__ = "0.0.0.dev0"
+
+from errlore.facade import AgentMemory, Injection
+from errlore.lessons.store import LessonStore
+from errlore.trust import FeedbackSignal, TrustEngine
+
+__all__ = [
+    "AgentMemory",
+    "FeedbackSignal",
+    "Injection",
+    "LessonStore",
+    "TrustEngine",
+    "__version__",
+]

{errlore-0.2.0 → errlore-0.2.2}/src/errlore/cli.py

@@ -76,13 +76,16 @@ def _cmd_init_claude_code(args: argparse.Namespace) -> int:
     hooks_dir.mkdir(parents=True, exist_ok=True)
 
     post = hooks_dir / "errlore_posttooluse.py"
+    failure = hooks_dir / "errlore_posttoolusefailure.py"
     session = hooks_dir / "errlore_sessionstart.py"
     _write_hook(post, "post_tool_use", data_dir)
+    _write_hook(failure, "post_tool_use_failure", data_dir)
     _write_hook(session, "session_start", data_dir)
 
     # Same interpreter that runs the CLI -> the one where errlore is installed.
     py = sys.executable or "python3"
     cmd_post = f"{py} {post}"
+    cmd_failure = f"{py} {failure}"
     cmd_session = f"{py} {session}"
 
     settings_path = (
@@ -110,7 +113,11 @@ def _cmd_init_claude_code(args: argparse.Namespace) -> int:
         print(f"error: {settings_path} 'hooks' is not an object; not touching it", file=sys.stderr)
         return 1
 
+    # PostToolUseFailure is where current Claude Code reports failed tool
+    # calls (PostToolUse fires only on success). The PostToolUse hook stays
+    # registered for older Claude Code versions.
     added_post = _ensure_hook(hooks, "PostToolUse", cmd_post, matcher="Bash")
+    added_failure = _ensure_hook(hooks, "PostToolUseFailure", cmd_failure, matcher="Bash")
     added_session = _ensure_hook(hooks, "SessionStart", cmd_session)
 
     settings_path.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
@@ -119,7 +126,7 @@ def _cmd_init_claude_code(args: argparse.Namespace) -> int:
     print(f"  hooks written to : {hooks_dir}")
     print(f"  memory data dir  : {data_dir}")
     print(f"  settings updated : {settings_path}")
-    if not (added_post and added_session):
+    if not (added_post and added_failure and added_session):
         print("  (hooks were already present — nothing duplicated)")
     print("\nRestart Claude Code (or start a new session) to pick them up.")
     print("Failed Bash commands now become lessons; each new session is briefed on past pitfalls.")
@@ -132,7 +139,16 @@ def _open_memory(data_dir: str):  # type: ignore[no-untyped-def]
     return AgentMemory(os.path.expanduser(data_dir))
 
 
+def _print_data_dir(data_dir: str) -> None:
+    """Always show WHERE we read from — the #1 confusion is running `errlore
+    stats` next to a quickstart ./agent_memory dir while the CLI default
+    points at ~/.errlore/claude-code and silently prints zeros."""
+    resolved = os.path.abspath(os.path.expanduser(data_dir))
+    print(f"data dir: {resolved}  (change with --data-dir PATH)", file=sys.stderr)
+
+
 def _cmd_stats(args: argparse.Namespace) -> int:
+    _print_data_dir(args.data_dir)
     stats = _open_memory(args.data_dir).stats()
     if args.json:
         print(json.dumps(stats, indent=2))
@@ -150,6 +166,7 @@ def _cmd_stats(args: argparse.Namespace) -> int:
 
 
 def _cmd_lessons(args: argparse.Namespace) -> int:
+    _print_data_dir(args.data_dir)
     lessons = _open_memory(args.data_dir).lessons(limit=args.limit)
     if not lessons:
         print("(no lessons yet)")

{errlore-0.2.0 → errlore-0.2.2}/src/errlore/integrations/claude_code.py

@@ -4,8 +4,14 @@
 functions here, so the real (tested) logic lives in the package instead of in
 copy-pasted example files:
 
-* :func:`post_tool_use` -- a PostToolUse hook: a failed Bash command becomes an
-  errlore error.
+* :func:`post_tool_use_failure` -- a PostToolUseFailure hook: a failed Bash
+  command becomes an errlore error. Current Claude Code routes tool failures
+  to this dedicated event (PostToolUse fires only on SUCCESS) with a top-level
+  ``error`` string and no ``tool_response``.
+* :func:`post_tool_use` -- legacy PostToolUse handler, kept for older Claude
+  Code versions whose PostToolUse payload carried ``exit_code``/``is_error``.
+  On current versions a failed command never reaches PostToolUse, so this
+  stays a harmless no-op.
 * :func:`session_start` -- a SessionStart hook: print the lessons + KNOWN ISSUES
   briefing to stdout (Claude Code adds hook stdout to the session context).
 
@@ -73,6 +79,49 @@ def post_tool_use(event_json: str | None = None) -> int:
     return 0
 
 
+def post_tool_use_failure(event_json: str | None = None) -> int:
+    """Log a failed Bash command from a PostToolUseFailure event.
+
+    Current Claude Code fires this dedicated event when a tool call fails
+    (PostToolUse only fires on success). The payload carries ``tool_name``,
+    ``tool_input`` and a top-level ``error`` string — there is no
+    ``tool_response`` and no structured exit code.
+
+    Args:
+        event_json: The raw hook-event JSON. ``None`` reads ``sys.stdin``
+            (the real hook path); tests pass a string.
+
+    Returns:
+        Always ``0`` -- a hook must never break the agent loop.
+    """
+    raw = event_json if event_json is not None else sys.stdin.read()
+    try:
+        event: Any = json.loads(raw)
+    except (json.JSONDecodeError, TypeError, ValueError):
+        return 0
+    if not isinstance(event, dict):
+        return 0
+
+    if event.get("tool_name", "") != "Bash":
+        return 0
+    # A user hitting Esc is not a failure worth learning from.
+    if bool(event.get("is_interrupt")):
+        return 0
+
+    tool_input = event.get("tool_input") or {}
+    command = str(tool_input.get("command", "") if isinstance(tool_input, dict) else "")[:160]
+    error = str(event.get("error") or "")[:200]
+    if not command and not error:
+        return 0
+    try:
+        AgentMemory(data_dir()).log_error(
+            "claude-code", "bash", f"CommandFailed: {command} :: {error}",
+        )
+    except Exception:  # never break the agent loop
+        return 0
+    return 0
+
+
 def session_start() -> int:
     """Print the lessons + KNOWN ISSUES briefing for the new session.
 

{errlore-0.2.0 → errlore-0.2.2}/tests/test_cli.py

@@ -9,7 +9,11 @@ import pytest
 
 from errlore import AgentMemory
 from errlore.cli import main
-from errlore.integrations.claude_code import post_tool_use, session_start
+from errlore.integrations.claude_code import (
+    post_tool_use,
+    post_tool_use_failure,
+    session_start,
+)
 
 # --------------------------------------------------------------------------
 # Claude Code hook logic
@@ -42,6 +46,45 @@ def test_post_tool_use_ignores_success_nonbash_and_junk(
     assert AgentMemory(tmp_path).stats()["errors_total"] == 0
 
 
+def test_post_tool_use_failure_logs_failed_bash(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The payload shape current Claude Code actually sends for a failed
+    command — PostToolUseFailure with a top-level `error` string and no
+    tool_response (verbatim from the hooks reference docs)."""
+    monkeypatch.setenv("ERRLORE_DATA", str(tmp_path))
+    event = json.dumps({
+        "hook_event_name": "PostToolUseFailure",
+        "tool_name": "Bash",
+        "tool_input": {"command": "npm test", "description": "Run test suite"},
+        "error": "Command exited with non-zero status code 1",
+        "is_interrupt": False,
+        "duration_ms": 4187,
+    })
+    assert post_tool_use_failure(event) == 0
+    mem = AgentMemory(tmp_path)
+    assert mem.stats()["errors_total"] == 1
+
+
+def test_post_tool_use_failure_ignores_interrupt_nonbash_and_junk(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("ERRLORE_DATA", str(tmp_path))
+    # user pressed Esc — not a failure worth learning from
+    interrupted = json.dumps({
+        "tool_name": "Bash", "tool_input": {"command": "sleep 100"},
+        "error": "interrupted", "is_interrupt": True,
+    })
+    assert post_tool_use_failure(interrupted) == 0
+    # non-Bash tool failure
+    nonbash = json.dumps({"tool_name": "Read", "error": "file not found"})
+    assert post_tool_use_failure(nonbash) == 0
+    # junk — must never raise
+    assert post_tool_use_failure("not json") == 0
+    assert post_tool_use_failure("[]") == 0
+    assert AgentMemory(tmp_path).stats()["errors_total"] == 0
+
+
 def test_session_start_briefs_and_is_silent_when_empty(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
 ) -> None:
@@ -79,20 +122,26 @@ def test_init_claude_code_writes_hooks_and_merges_settings(
 
     # hook shims written + executable
     post = hooks_dir / "errlore_posttooluse.py"
+    failure = hooks_dir / "errlore_posttoolusefailure.py"
     session = hooks_dir / "errlore_sessionstart.py"
-    assert post.exists() and session.exists()
+    assert post.exists() and failure.exists() and session.exists()
     assert "post_tool_use" in post.read_text()
+    assert "post_tool_use_failure" in failure.read_text()
     assert str(data_dir) in post.read_text()  # data dir pinned into the shim
 
     # settings.json wired
     settings = json.loads((tmp_path / ".claude" / "settings.json").read_text())
     ptu = settings["hooks"]["PostToolUse"]
+    ptuf = settings["hooks"]["PostToolUseFailure"]
     ss = settings["hooks"]["SessionStart"]
     assert any("errlore_posttooluse.py" in h["command"]
                for g in ptu for h in g["hooks"])
+    assert any("errlore_posttoolusefailure.py" in h["command"]
+               for g in ptuf for h in g["hooks"])
     assert any("errlore_sessionstart.py" in h["command"]
                for g in ss for h in g["hooks"])
     assert ptu[0]["matcher"] == "Bash"
+    assert ptuf[0]["matcher"] == "Bash"
 
 
 def test_init_claude_code_is_idempotent(
@@ -106,6 +155,7 @@ def test_init_claude_code_is_idempotent(
     settings = json.loads((tmp_path / ".claude" / "settings.json").read_text())
     # no duplicated hook entries
     assert len(settings["hooks"]["PostToolUse"]) == 1
+    assert len(settings["hooks"]["PostToolUseFailure"]) == 1
     assert len(settings["hooks"]["SessionStart"]) == 1
 
 

errlore-0.2.0/src/errlore/__init__.py

@@ -1,16 +0,0 @@
-"""errlore -- memory for AI agents that learns from failures."""
-
-__version__ = "0.1.4"
-
-from errlore.facade import AgentMemory, Injection
-from errlore.lessons.store import LessonStore
-from errlore.trust import FeedbackSignal, TrustEngine
-
-__all__ = [
-    "AgentMemory",
-    "FeedbackSignal",
-    "Injection",
-    "LessonStore",
-    "TrustEngine",
-    "__version__",
-]