agent-notes 2.25.0__tar.gz → 2.26.0__tar.gz

{agent_notes-2.25.0 → agent_notes-2.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.25.0
+Version: 2.26.0
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT

agent_notes-2.26.0/agent_notes/VERSION

@@ -0,0 +1 @@
+2.26.0

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes/commands/memory/notes.py

@@ -45,8 +45,10 @@ def do_add(title: str, body: str, note_type: str = "context", agent: str = "", p
         )
         print(f"{Color.GREEN}Note saved: {note_path}{Color.NC}")
     else:
-        print("The `add` subcommand is for obsidian or wiki storage.")
-        print("For local storage, write files directly to the agent subdirectory.")
+        import sys
+        print("The `add` subcommand is for obsidian or wiki storage.", file=sys.stderr)
+        print("For local storage, write files directly to the agent subdirectory.", file=sys.stderr)
+        sys.exit(1)
 
 
 def do_list() -> None:

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes/data/agents/shared/cost_reporting.md

@@ -4,7 +4,7 @@ At the END of every response, run `agent-notes cost-report` and include the outp
 
 **Session cost** (cumulative for the entire conversation):
 
-Render every column the `agent-notes cost-report` CLI emits — `agent(model)`, `in/out/cache`, `time`, `actual`, `vs Claude Opus 4.7` — in that order. Do not split, drop, or rename columns. Preserve the data verbatim.
+Render every column the `agent-notes cost-report` CLI emits — `agent(model)`, `in/out/cache`, `time`, `actual`, `vs Claude Opus 4.8` — in that order. Do not split, drop, or rename columns. Preserve the data verbatim.
 
 **On failure or skip — never fabricate.** If `agent-notes cost-report` returns non-zero, errors, or you skip running it, do NOT render a placeholder table or invent rows like `(cost report unavailable — agent-notes cost-report not run)`. Instead, print one plain line under the heading:
 

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes/data/agents/shared/hard_limits.md

@@ -13,7 +13,7 @@ You MUST NOT directly:
 - Run installs, builds, migrations, or destructive commands — dispatch `devops`
 - Use `bash` for anything beyond the read-only verification list above
 
-If you feel the urge to "just quickly check a file" — STOP. Dispatch `explorer`. Every file read by the lead is a budget leak (Opus tokens are 30× Haiku).
+If you feel the urge to "just quickly check a file" — STOP. Dispatch `explorer`. Every file read by the lead is a budget leak (Opus tokens are 5× Haiku).
 
 Exception: trivial requests (factual questions, conversational replies, single-line answers) may be handled inline with no tools.
 

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes/data/pricing.yaml

@@ -1,5 +1,5 @@
 baseline:
-  label: Claude Opus 4.7
+  label: Claude Opus 4.8
   price:
     in: 5.00
     out: 25.00
@@ -16,8 +16,8 @@ providers:
         match: "*sonnet*"
         price: {in: 3.00, out: 15.00, cache: 0.30}
         updated_at: "2026-04"
-      - name: Claude Opus 4.7 / 4.6 / 4.5
-        match: ["*opus-4.7*", "*opus-4.6*", "*opus-4.5*"]
+      - name: Claude Opus 4.8 / 4.7 / 4.6 / 4.5
+        match: ["*opus-4.8*", "*opus-4.7*", "*opus-4.6*", "*opus-4.5*"]
         price: {in: 5.00, out: 25.00, cache: 0.50}
         updated_at: "2026-04"
       - name: Claude Opus (legacy)

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes/scripts/_claude_backend.py

@@ -6,8 +6,7 @@ from pathlib import Path
 
 from . import _pricing
 from ._formatting import (
-    BOLD, DIM, GREEN, YELLOW, NC,
-    tier_color, fmt_tokens, fmt_cost, fmt_time,
+    fmt_time, render_cost_table,
 )
 from ..services.state_store import state_file as _state_file, load_state as _load_state
 
@@ -279,66 +278,15 @@ def run(since: float | None = None, session_id: str | None = None) -> int:
             ms = agent_time_ms.get(label, 0)
         return fmt_time(ms / 1000) if ms > 0 else "n/a"
 
-    agent_col_w = max(len(f"{a}({m})") for a, m, *_ in costs) + 2
-    tok_col_w = max(
-        max(len(fmt_tokens(i, o, c)) for _, _, i, o, c, *_ in costs),
-        len(fmt_tokens(
-            sum(i for _, _, i, *_ in costs),
-            sum(o for _, _, _, o, *_ in costs),
-            sum(c for _, _, _, _, c, *_ in costs),
-        ))
-    ) + 2
-    all_time_strs = [_time_str_for(a) for a, *_ in costs]
-    time_col_w = max(len(s) for s in all_time_strs) + 2
-    W = (agent_col_w, tok_col_w, time_col_w, 12, 12)
-
-    bl_label = _pricing.baseline_label()
-    header = (
-        f"{'agent(model)':<{W[0]}}"
-        f" {'in/out/cache':<{W[1]}}"
-        f" {'time':<{W[2]}}"
-        f" {'actual':<{W[3]}}"
-        f" {f'vs {bl_label}':<{W[4]}}"
+    total_time_ms = sum(
+        lead_time_ms if agent == "lead" else agent_time_ms.get(agent, 0)
+        for agent, *_ in costs
     )
-    print(BOLD + header + NC)
-    print(DIM + "-" * len(header) + NC)
-
-    total_inp = total_outp = total_cache = 0
-    total_actual = total_vs = 0.0
-    total_time_ms = 0
-
-    for agent, model, inp, outp, cache, actual, vs in costs:
-        label = f"{agent}({model})"
-        col = tier_color(model)
-        t_str = _time_str_for(agent)
-        print(
-            col + f"{label:<{W[0]}}" + NC
-            + f" {fmt_tokens(inp, outp, cache):<{W[1]}}"
-            + f" {t_str:<{W[2]}}"
-            + f" {fmt_cost(actual):<{W[3]}}"
-            + f" {fmt_cost(vs):<{W[4]}}"
-        )
-        total_inp += inp
-        total_outp += outp
-        total_cache += cache
-        total_actual += actual
-        total_vs += vs
-        if agent == "lead":
-            total_time_ms += lead_time_ms
-        else:
-            total_time_ms += agent_time_ms.get(agent, 0)
-
-    saved_pct = round((1 - total_actual / total_vs) * 100) if total_vs else 0
-    total_label = f"TOTAL (saved {saved_pct}%)"
     total_time_str = fmt_time(total_time_ms / 1000) if total_time_ms > 0 else "n/a"
-    col = GREEN if total_actual <= 5 else YELLOW
-    print(
-        col + BOLD
-        + f"{total_label:<{W[0]}}"
-        + f" {fmt_tokens(total_inp, total_outp, total_cache):<{W[1]}}"
-        + f" {total_time_str:<{W[2]}}"
-        + f" {fmt_cost(total_actual):<{W[3]}}"
-        + f" {fmt_cost(total_vs):<{W[4]}}"
-        + NC
-    )
+
+    rows = [
+        (f"{agent}({model})", model, inp, outp, cache, _time_str_for(agent), actual, vs)
+        for agent, model, inp, outp, cache, actual, vs in costs
+    ]
+    render_cost_table(rows, total_time_str, _pricing.baseline_label())
     return 0

agent_notes-2.26.0/agent_notes/scripts/_formatting.py

@@ -0,0 +1,120 @@
+"""ANSI color constants and shared formatting helpers."""
+import os
+import sys
+
+_USE_COLOR = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+
+BOLD   = "\033[1m"   if _USE_COLOR else ""
+DIM    = "\033[2m"   if _USE_COLOR else ""
+YELLOW = "\033[0;33m" if _USE_COLOR else ""
+GREEN  = "\033[0;32m" if _USE_COLOR else ""
+CYAN   = "\033[0;36m" if _USE_COLOR else ""
+NC     = "\033[0m"   if _USE_COLOR else ""
+
+
+def tier_color(model_id: str) -> str:
+    if not _USE_COLOR:
+        return ""
+    if "opus" in model_id:
+        return YELLOW
+    if "sonnet" in model_id:
+        return CYAN
+    return DIM
+
+
+def fmt_num(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.2f}m"
+    if n >= 1_000:
+        return f"{n / 1_000:.2f}k"
+    return str(n)
+
+
+def fmt_tokens(inp, outp, cache) -> str:
+    return f"{fmt_num(inp)}/{fmt_num(outp)}/{fmt_num(cache)}"
+
+
+def fmt_time(sec: float) -> str:
+    s = int(round(sec))
+    if s < 60:
+        return f"{s}s"
+    m, s = divmod(s, 60)
+    if m < 60:
+        return f"{m}m {s}s" if s else f"{m}m"
+    h, m = divmod(m, 60)
+    return f"{h}h {m}m" if m else f"{h}h"
+
+
+def fmt_cost(c: float) -> str:
+    return f"${c:.4f}"
+
+
+def render_cost_table(
+    rows: list[tuple],
+    total_time_str: str,
+    baseline_label: str,
+) -> None:
+    """Print a cost table to stdout.
+
+    Each row must be a tuple of:
+        (label: str, model: str, inp: int, outp: int, cache: int,
+         time_str: str, actual: float, vs: float)
+
+    total_time_str  — pre-formatted total time (backends compute it differently)
+    baseline_label  — label for the rightmost "vs" column header
+    """
+    agent_col_w = max(len(label) for label, *_ in rows) + 2
+    tok_col_w = max(
+        max(len(fmt_tokens(i, o, c)) for _, _, i, o, c, *_ in rows),
+        len(fmt_tokens(
+            sum(i for _, _, i, *_ in rows),
+            sum(o for _, _, _, o, *_ in rows),
+            sum(c for _, _, _, _, c, *_ in rows),
+        ))
+    ) + 2
+    time_col_w = max(
+        max(len(t) for _, _, _, _, _, t, *_ in rows),
+        len(total_time_str)
+    ) + 2
+    W = (agent_col_w, tok_col_w, time_col_w, 12, 12)
+
+    header = (
+        f"{'agent(model)':<{W[0]}}"
+        f" {'in/out/cache':<{W[1]}}"
+        f" {'time':<{W[2]}}"
+        f" {'actual':<{W[3]}}"
+        f" {f'vs {baseline_label}':<{W[4]}}"
+    )
+    print(BOLD + header + NC)
+    print(DIM + "-" * len(header) + NC)
+
+    total_inp = total_outp = total_cache = 0
+    total_actual = total_vs = 0.0
+
+    for label, model, inp, outp, cache, time_str, actual, vs in rows:
+        col = tier_color(model)
+        print(
+            col + f"{label:<{W[0]}}" + NC
+            + f" {fmt_tokens(inp, outp, cache):<{W[1]}}"
+            + f" {time_str:<{W[2]}}"
+            + f" {fmt_cost(actual):<{W[3]}}"
+            + f" {fmt_cost(vs):<{W[4]}}"
+        )
+        total_inp += inp
+        total_outp += outp
+        total_cache += cache
+        total_actual += actual
+        total_vs += vs
+
+    saved_pct = round((1 - total_actual / total_vs) * 100) if total_vs else 0
+    total_label = f"TOTAL (saved {saved_pct}%)"
+    col = GREEN if total_actual <= 5 else YELLOW
+    print(
+        col + BOLD
+        + f"{total_label:<{W[0]}}"
+        + f" {fmt_tokens(total_inp, total_outp, total_cache):<{W[1]}}"
+        + f" {total_time_str:<{W[2]}}"
+        + f" {fmt_cost(total_actual):<{W[3]}}"
+        + f" {fmt_cost(total_vs):<{W[4]}}"
+        + NC
+    )

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes/scripts/_opencode_backend.py

@@ -3,10 +3,7 @@ import sqlite3
 from pathlib import Path
 
 from . import _pricing
-from ._formatting import (
-    BOLD, DIM, GREEN, YELLOW, NC,
-    tier_color, fmt_tokens, fmt_time, fmt_cost,
-)
+from ._formatting import fmt_time, render_cost_table
 
 DB = Path.home() / ".local/share/opencode/opencode.db"
 
@@ -63,7 +60,7 @@ def run() -> int:
         return 0
 
     records = [
-        (agent, model or "unknown", inp or 0, outp or 0, cache or 0, sec or 0)
+        (agent, _pricing.normalize_model(model or "unknown"), inp or 0, outp or 0, cache or 0, sec or 0)
         for agent, model, inp, outp, cache, sec in rows
     ]
 
@@ -74,68 +71,13 @@ def run() -> int:
         for agent, model, inp, outp, cache, sec in records
     ]
 
-    _total_inp  = sum(i for _, _, i, *_ in costs)
-    _total_outp = sum(o for _, _, _, o, *_ in costs)
-    _total_cache = sum(c for _, _, _, _, c, *_ in costs)
-    _max_sec    = max(s for _, _, _, _, _, s, *_ in costs)
-    _total_sec  = sum(s for _, _, _, _, _, s, *_ in costs)
-    _total_time = f"{fmt_time(_max_sec)} / {fmt_time(_total_sec)} seq"
-
-    agent_col_w = max(len(f"{a}({m})") for a, m, *_ in costs) + 2
-    tok_col_w = max(
-        max(len(fmt_tokens(i, o, c)) for _, _, i, o, c, *_ in costs),
-        len(fmt_tokens(_total_inp, _total_outp, _total_cache))
-    ) + 2
-    time_col_w = max(
-        max(len(fmt_time(s)) for _, _, _, _, _, s, *_ in costs),
-        len(_total_time)
-    ) + 2
-    W = (agent_col_w, tok_col_w, time_col_w, 12, 12)
-
-    bl_label = _pricing.baseline_label()
-    header = (
-        f"{'agent(model)':<{W[0]}}"
-        f" {'in/out/cache':<{W[1]}}"
-        f" {'time':<{W[2]}}"
-        f" {'actual':<{W[3]}}"
-        f" {f'vs {bl_label}':<{W[4]}}"
-    )
-    print(BOLD + header + NC)
-    print(DIM + "-" * len(header) + NC)
+    max_sec = max(s for _, _, _, _, _, s, *_ in costs)
+    total_sec = sum(s for _, _, _, _, _, s, *_ in costs)
+    total_time_str = f"{fmt_time(max_sec)} / {fmt_time(total_sec)} seq"
 
-    total_inp = total_outp = total_cache = 0
-    total_actual = total_vs = max_sec = total_sec = 0.0
-
-    for agent, model, inp, outp, cache, sec, actual, vs in costs:
-        label = f"{agent}({model})"
-        time_str = fmt_time(sec)
-        col = tier_color(model)
-        print(
-            col + f"{label:<{W[0]}}" + NC
-            + f" {fmt_tokens(inp, outp, cache):<{W[1]}}"
-            + f" {time_str:<{W[2]}}"
-            + f" {fmt_cost(actual):<{W[3]}}"
-            + f" {fmt_cost(vs):<{W[4]}}"
-        )
-        total_inp += inp
-        total_outp += outp
-        total_cache += cache
-        total_actual += actual
-        total_vs += vs
-        max_sec = max(max_sec, sec)
-        total_sec += sec
-
-    saved_pct = round((1 - total_actual / total_vs) * 100) if total_vs else 0
-    total_label = f"TOTAL (saved {saved_pct}%)"
-    total_time = _total_time
-    col = GREEN if total_actual <= 5 else YELLOW
-    print(
-        col + BOLD
-        + f"{total_label:<{W[0]}}"
-        + f" {fmt_tokens(total_inp, total_outp, total_cache):<{W[1]}}"
-        + f" {total_time:<{W[2]}}"
-        + f" {fmt_cost(total_actual):<{W[3]}}"
-        + f" {fmt_cost(total_vs):<{W[4]}}"
-        + NC
-    )
+    rows = [
+        (f"{agent}({model})", model, inp, outp, cache, fmt_time(sec), actual, vs)
+        for agent, model, inp, outp, cache, sec, actual, vs in costs
+    ]
+    render_cost_table(rows, total_time_str, _pricing.baseline_label())
     return 0

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-notes
-Version: 2.25.0
+Version: 2.26.0
 Summary: AI agent configuration manager for Claude Code, OpenCode, and Copilot
 Author-email: Eugene Naumov <min.verkligheten@gmail.com>
 License-Expression: MIT

{agent_notes-2.25.0 → agent_notes-2.26.0}/agent_notes.egg-info/SOURCES.txt

@@ -206,6 +206,7 @@ tests/functional/commands/test_regenerate_command.py
 tests/functional/commands/test_uninstall_command.py
 tests/functional/commands/test_validate_command.py
 tests/functional/memory/__init__.py
+tests/functional/memory/test_memory_add_local_backend.py
 tests/functional/memory/test_memory_command.py
 tests/functional/scripts/__init__.py
 tests/functional/scripts/test_release_script.py
@@ -241,6 +242,7 @@ tests/unit/scripts/__init__.py
 tests/unit/scripts/test_cost_report.py
 tests/unit/scripts/test_cost_report_scoping.py
 tests/unit/scripts/test_formatting_tty.py
+tests/unit/scripts/test_opencode_backend_pricing.py
 tests/unit/scripts/test_time_aggregation.py
 tests/unit/services/__init__.py
 tests/unit/services/test_build_functions.py

agent_notes-2.26.0/tests/functional/memory/test_memory_add_local_backend.py

@@ -0,0 +1,55 @@
+"""Regression test: memory add on local backend exits non-zero and prints to stderr.
+
+Previously the command printed guidance to stdout and returned silently (exit 0),
+causing callers to believe the note was saved when nothing was written.
+"""
+import pytest
+
+
+class TestMemoryAddLocalBackendExitsNonZero:
+    def test_local_backend_add_exits_nonzero(self, tmp_path, monkeypatch, capsys):
+        """memory add on local backend must exit non-zero — not silently succeed."""
+        mem_dir = tmp_path / "memory"
+
+        import agent_notes.commands.memory as mem_mod
+        monkeypatch.setattr(mem_mod._common, "_load_memory_config", lambda: ("local", mem_dir))
+
+        from agent_notes.commands.memory import memory
+        with pytest.raises(SystemExit) as exc_info:
+            memory(action="add", name="My Note", extra=["Body text", "context", "lead"])
+
+        assert exc_info.value.code != 0, (
+            "memory add on local backend must exit non-zero so callers detect the failure"
+        )
+
+    def test_local_backend_add_prints_guidance_to_stderr(self, tmp_path, monkeypatch, capsys):
+        """Guidance message must go to stderr, not stdout, so pipelines can separate it."""
+        mem_dir = tmp_path / "memory"
+
+        import agent_notes.commands.memory as mem_mod
+        monkeypatch.setattr(mem_mod._common, "_load_memory_config", lambda: ("local", mem_dir))
+
+        from agent_notes.commands.memory import memory
+        with pytest.raises(SystemExit):
+            memory(action="add", name="My Note", extra=["Body text", "context", "lead"])
+
+        captured = capsys.readouterr()
+        assert captured.out == "", f"Expected no stdout output, got: {captured.out!r}"
+        assert "local storage" in captured.err.lower() or "directly" in captured.err.lower(), (
+            f"Expected guidance in stderr, got: {captured.err!r}"
+        )
+
+    def test_local_backend_add_writes_nothing(self, tmp_path, monkeypatch):
+        """No file should be created in MEMORY_DIR when local backend is used."""
+        mem_dir = tmp_path / "memory"
+        mem_dir.mkdir()
+
+        import agent_notes.commands.memory as mem_mod
+        monkeypatch.setattr(mem_mod._common, "_load_memory_config", lambda: ("local", mem_dir))
+
+        from agent_notes.commands.memory import memory
+        with pytest.raises(SystemExit):
+            memory(action="add", name="My Note", extra=["Body text", "context", "lead"])
+
+        written = list(mem_dir.rglob("*"))
+        assert written == [], f"Expected no files written, found: {written}"

agent_notes-2.26.0/tests/unit/scripts/test_opencode_backend_pricing.py

@@ -0,0 +1,100 @@
+"""Regression test: OpenCode backend normalizes dash-form model IDs before pricing lookup.
+
+Without normalization, `claude-opus-4-8` fails the `*opus-4.8*` fnmatch glob and
+falls through to the legacy `*opus*` catch-all ($15/M in instead of $5/M in).
+"""
+import sqlite3
+import pytest
+from pathlib import Path
+from unittest.mock import patch
+
+from agent_notes.scripts import _pricing
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _make_opencode_db(tmp_path: Path, model: str, inp: int = 1_000_000, outp: int = 1_000_000) -> Path:
+    """Build a minimal OpenCode SQLite DB with one session and one assistant message."""
+    db_path = tmp_path / "opencode.db"
+    conn = sqlite3.connect(db_path)
+    conn.executescript("""
+        CREATE TABLE session (
+            id TEXT PRIMARY KEY,
+            parent_id TEXT,
+            time_created INTEGER
+        );
+        CREATE TABLE message (
+            id TEXT PRIMARY KEY,
+            session_id TEXT,
+            data TEXT
+        );
+    """)
+
+    import json, time
+    now_ms = int(time.time() * 1000)
+    session_id = "sess-001"
+    conn.execute(
+        "INSERT INTO session VALUES (?, NULL, ?)",
+        (session_id, now_ms),
+    )
+    # assistant message with the raw dash-form model ID
+    msg_data = json.dumps({
+        "role": "assistant",
+        "modelID": model,
+        "tokens": {"input": inp, "output": outp, "cache": {"read": 0}},
+        "time": {"created": now_ms - 1000, "completed": now_ms},
+        "agent": "lead",
+    })
+    conn.execute(
+        "INSERT INTO message VALUES (?, ?, ?)",
+        ("msg-001", session_id, msg_data),
+    )
+    conn.commit()
+    conn.close()
+    return db_path
+
+
+# ── tests ─────────────────────────────────────────────────────────────────────
+
+class TestOpencodeBackendNormalizesModel:
+    def test_opus_dash_form_uses_opus_rate_not_legacy(self, tmp_path):
+        """claude-opus-4-8 (dash form) must resolve to the $5/M Opus rate, not $15/M legacy."""
+        opus_price = _pricing.get_price("claude-opus-4.8")
+        legacy_price = _pricing.get_price("claude-opus-4.1")
+
+        # Sanity: confirm we have distinct pricing tiers to differentiate
+        assert opus_price["in"] < legacy_price["in"], (
+            "Test precondition failed: expected Opus 4.8 cheaper than legacy Opus"
+        )
+
+        # Normalize as the backend should
+        normalized = _pricing.normalize_model("claude-opus-4-8")
+        assert normalized == "claude-opus-4.8"
+
+        actual_price = _pricing.get_price(normalized)
+        assert actual_price["in"] == opus_price["in"], (
+            f"Normalized 'claude-opus-4-8' priced at {actual_price['in']} instead of {opus_price['in']}"
+        )
+
+    def test_opencode_run_uses_normalized_model(self, tmp_path, capsys):
+        """Integration: _opencode_backend.run() prices opus-4-8 at the Opus rate end-to-end."""
+        from agent_notes.scripts import _opencode_backend
+
+        db = _make_opencode_db(tmp_path, model="claude-opus-4-8", inp=1_000_000, outp=0)
+
+        with patch.object(_opencode_backend, "DB", db):
+            rc = _opencode_backend.run()
+
+        assert rc == 0
+        out = capsys.readouterr().out
+
+        # At 1M input tokens:
+        #   Opus rate  ($5/M)  → $5.00
+        #   Legacy rate ($15/M) → $15.00
+        # The output must contain the Opus cost, not the legacy cost.
+        assert "$5.00" in out or "5.00" in out, (
+            f"Expected ~$5.00 (Opus rate) in output, got:\n{out}"
+        )
+        assert "$15.00" not in out and "15.00" not in out.replace("$5.00", ""), (
+            f"Legacy rate ($15.00) appeared in output — normalization not applied:\n{out}"
+        )

agent_notes-2.25.0/agent_notes/VERSION

@@ -1 +0,0 @@
-2.25.0

agent_notes-2.25.0/agent_notes/scripts/_formatting.py

@@ -1,49 +0,0 @@
-"""ANSI color constants and shared formatting helpers."""
-import os
-import sys
-
-_USE_COLOR = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
-
-BOLD   = "\033[1m"   if _USE_COLOR else ""
-DIM    = "\033[2m"   if _USE_COLOR else ""
-YELLOW = "\033[0;33m" if _USE_COLOR else ""
-GREEN  = "\033[0;32m" if _USE_COLOR else ""
-CYAN   = "\033[0;36m" if _USE_COLOR else ""
-NC     = "\033[0m"   if _USE_COLOR else ""
-
-
-def tier_color(model_id: str) -> str:
-    if not _USE_COLOR:
-        return ""
-    if "opus" in model_id:
-        return YELLOW
-    if "sonnet" in model_id:
-        return CYAN
-    return DIM
-
-
-def fmt_num(n: int) -> str:
-    if n >= 1_000_000:
-        return f"{n / 1_000_000:.2f}m"
-    if n >= 1_000:
-        return f"{n / 1_000:.2f}k"
-    return str(n)
-
-
-def fmt_tokens(inp, outp, cache) -> str:
-    return f"{fmt_num(inp)}/{fmt_num(outp)}/{fmt_num(cache)}"
-
-
-def fmt_time(sec: float) -> str:
-    s = int(round(sec))
-    if s < 60:
-        return f"{s}s"
-    m, s = divmod(s, 60)
-    if m < 60:
-        return f"{m}m {s}s" if s else f"{m}m"
-    h, m = divmod(m, 60)
-    return f"{h}h {m}m" if m else f"{h}h"
-
-
-def fmt_cost(c: float) -> str:
-    return f"${c:.4f}"