gitvow 0.1.2__tar.gz → 0.2.0__tar.gz

{gitvow-0.1.2/src/gitvow.egg-info → gitvow-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.1.2
+Version: 0.2.0
 Summary: Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies.
 Author-email: Nikhil Bora <nikhil@wirevow.com>
 License: Apache-2.0

{gitvow-0.1.2 → gitvow-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.1.2"
+version = "0.2.0"
 description = "Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies."
 readme = "README.md"
 license = {text = "Apache-2.0"}

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/cli.py

@@ -5,13 +5,15 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import re
 import sys
 
 from . import __version__
 from .collect import collect, summarize_text
-from .hooks import HANDLERS
+from .hooks import HANDLERS, LEGACY_NOTES_REF, notes_ref
 from .install import install_repo, install_user, uninstall_repo, uninstall_user
 from .policy import PolicyError, evaluate, load_policy
+from .redact import RedactionError, load_rules, redact
 from .state import git
 
 
@@ -70,8 +72,25 @@ def cmd_show(a: argparse.Namespace) -> int:
         print(f"no such commit: {a.commit}", file=sys.stderr)
         return 1
     print(msg)
-    rc, note, _ = git(["notes", "--ref=sessions", "show", a.commit], os.getcwd())
-    print(note if rc == 0 else "(no session note)")
+    m = re.search(r"^Gitvow-Session:\s*(\S+)", msg, re.M)
+    refs = ([notes_ref(m.group(1))] if m else []) + [LEGACY_NOTES_REF]
+    for ref in refs:
+        rc, note, _ = git(["notes", f"--ref={ref}", "show", a.commit], os.getcwd())
+        if rc == 0:
+            print(note)
+            return 0
+    print("(no session note)")
+    return 0
+
+
+def cmd_redact(a: argparse.Namespace) -> int:
+    """Apply the built-in layers plus the rules files to text."""
+    try:
+        rules = load_rules(os.getcwd(), os.path.expanduser("~"))
+    except RedactionError as e:
+        print(f"redaction rules error: {e}", file=sys.stderr)
+        return 2
+    print(redact(" ".join(a.text), rules))
     return 0
 
 
@@ -119,6 +138,9 @@ def main(argv: list[str] | None = None) -> int:
     s = sub.add_parser("show", help="print a commit's trailers and session note")
     s.add_argument("commit", nargs="?", default="HEAD")
     s.set_defaults(f=cmd_show)
+    s = sub.add_parser("redact", help="apply built-in redaction plus your rules files to text")
+    s.add_argument("text", nargs="+")
+    s.set_defaults(f=cmd_redact)
     s = sub.add_parser("collect", help="gather ledger, logs, trailers and notes into one directory")
     s.add_argument("--out", default=os.path.expanduser("~/Desktop"))
     s.set_defaults(f=cmd_collect)

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/collect.py

@@ -43,7 +43,17 @@ def collect(home: str, out_dir: str) -> str:
             shutil.copy(lp, os.path.join(d, "gitvow-hooks.log"))
         for name, args in (
             ("commits-with-trailers.txt", ["log", "--format=%H %ad %s", "--date=short", "--grep=Gitvow-Session:"]),
-            ("notes.txt", ["log", "--show-notes=sessions", "--format=%H%n%N%n----", "--grep=Gitvow-Session:"]),
+            (
+                "notes.txt",
+                [
+                    "-c",
+                    "notes.displayRef=refs/notes/gitvow/*",
+                    "log",
+                    "--show-notes=sessions",
+                    "--format=%H%n%N%n----",
+                    "--grep=Gitvow-Session:",
+                ],
+            ),
             ("remote.txt", ["remote", "get-url", "origin"]),
         ):
             _, out, _ = git(args, r)

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/default_policy.json

@@ -62,8 +62,8 @@
       "reason": "edits CI definitions"
     },
     {
-      "pattern": "(^|/)\\.gitvow/(policy\\.json|hooks/)|(^|/)\\.claude/settings.*\\.json",
-      "reason": "edits the gate policy or the hook configuration"
+      "pattern": "(^|/)\\.gitvow/(policy\\.json|redact-rules\\.json|hooks/|git-hooks/)|(^|/)\\.claude/settings.*\\.json",
+      "reason": "edits gitvow's own policy, redaction rules or hooks"
     },
     {
       "pattern": "(^|/)(auth|authz|authorization|gate|whitelist|allowlist)[^/]*\\.(java|go|py|ts|js|ya?ml)$",
@@ -79,4 +79,4 @@
     "command": "",
     "_doc": "Optional: a command that reads the hook JSON on stdin and prints ALLOW|CONFIRM|DENY <reason>. Used only for calls not matched above."
   }
-}
+}

gitvow-0.2.0/src/gitvow/hooks/__init__.py

@@ -0,0 +1,228 @@
+"""Hook handlers. Each takes the Claude Code hook payload (dict) and returns (exit_code, stderr_message)."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from typing import Any
+
+from ..policy import PolicyError, evaluate, load_policy, message_for
+from ..redact import RedactionError, load_rules, redact
+from ..state import git, load_state, log_event, save_state, toplevel
+from ..transcript import summarize
+
+NOTES_REF_PREFIX = "gitvow"  # refs/notes/gitvow/<session-id>; gitvow 0.1 wrote the single ref refs/notes/sessions
+LEGACY_NOTES_REF = "sessions"
+NOTE_SCHEMA = 2
+COMMIT_RE = re.compile(r"\bgit\s+commit\b")
+EDIT_TOOLS = ("Edit", "Write", "MultiEdit", "NotebookEdit")
+REDACTION_UNAVAILABLE = "redaction rules invalid; nothing written for this event"
+
+
+def notes_ref(session_id: str | None) -> str:
+    sid = re.sub(r"[^A-Za-z0-9._-]", "_", session_id or "unknown")
+    return f"{NOTES_REF_PREFIX}/{sid}"
+
+
+def session_start(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    st = load_state(cwd)
+    st.update(
+        {
+            "session_id": h.get("session_id"),
+            "transcript_path": h.get("transcript_path"),
+            "started": time.strftime("%Y-%m-%dT%H:%M:%S"),
+            "steps": st.get("steps", 0),
+            "agent_blobs": st.get("agent_blobs", {}) if st.get("session_id") == h.get("session_id") else {},
+        }
+    )
+    save_state(cwd, st)
+    log_event(cwd, "session_start", {"session_id": h.get("session_id")})
+    return 0, ""
+
+
+def _rules_or_none(cwd: str, home: str | None) -> tuple[list[tuple[str, str]] | None, str]:
+    try:
+        return load_rules(cwd, home), ""
+    except RedactionError as e:
+        log_event(cwd, "redaction_unavailable", {"error": str(e)[:200]})
+        return None, f"gitvow: {e}. {REDACTION_UNAVAILABLE}."
+
+
+def pre_tool_use(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    tool = h.get("tool_name", "") or ""
+    inp = h.get("tool_input") or {}
+    try:
+        pol = load_policy(cwd, home)
+    except PolicyError as e:
+        return (
+            2,
+            f"BLOCKED: tool policy could not be loaded ({e}); refusing all tool calls until the policy is restored.",
+        )
+    d = evaluate(pol, tool, inp)
+    rules, warn = _rules_or_none(cwd, home)
+    if d.blocks:
+        payload: dict[str, Any] = {"tool": tool, "reason": d.reason, "session_id": h.get("session_id")}
+        if rules is not None:
+            payload["detail"] = redact(d.detail, rules)[:200]
+        log_event(cwd, "blocked" if d.outcome == "deny" else "confirm_required", payload)
+        return 2, message_for(d)
+    if tool == "Bash" and COMMIT_RE.search(inp.get("command", "")):
+        st = load_state(cwd)
+        st["session_id"] = h.get("session_id") or st.get("session_id")
+        st["transcript_path"] = h.get("transcript_path") or st.get("transcript_path")
+        st["steps"] = st.get("steps", 0) + 1
+        save_state(cwd, st)
+    if rules is None:
+        log_event(cwd, "allowed", {"tool": tool})
+        return 0, warn
+    log_event(
+        cwd,
+        "allowed",
+        {"tool": tool, "detail": redact(inp.get("command") or inp.get("file_path") or tool, rules)[:160]},
+    )
+    return 0, ""
+
+
+def _record_agent_blob(cwd: str, file_path: str) -> None:
+    """After an agent edit, remember the blob id of what the agent wrote (repo-relative path -> blob)."""
+    top = toplevel(cwd)
+    if not top:
+        return
+    abs_path = file_path if os.path.isabs(file_path) else os.path.join(cwd, file_path)
+    if not os.path.isfile(abs_path):
+        return
+    rel = os.path.relpath(os.path.realpath(abs_path), os.path.realpath(top))
+    if rel.startswith(".."):
+        return
+    rc, blob, _ = git(["hash-object", "-w", "--", abs_path], top)
+    if rc != 0:
+        return
+    st = load_state(cwd)
+    st.setdefault("agent_blobs", {})[rel] = blob
+    save_state(cwd, st)
+
+
+def _attribution(cwd: str, head: str, agent_blobs: dict[str, str], transcript_written: list[str]) -> dict[str, Any]:
+    _, numstat, _ = git(["show", "--numstat", "--format=", head], cwd)
+    files: list[dict[str, Any]] = []
+    total_added = human_changed = agent_added = 0
+    for ln in numstat.splitlines():
+        parts = ln.split("\t")
+        if len(parts) < 3:
+            continue
+        added = int(parts[0]) if parts[0].isdigit() else 0
+        path = parts[2]
+        total_added += added
+        agent_blob = agent_blobs.get(path)
+        touched = agent_blob is not None or any(path.endswith(w) or w.endswith(path) for w in transcript_written)
+        entry: dict[str, Any] = {"path": path, "agent_wrote": touched, "lines_added_in_commit": added}
+        if agent_blob:
+            rc, committed_out, _ = git(["rev-parse", f"{head}:{path}"], cwd)
+            committed: str | None = committed_out if rc == 0 else None
+            h_add = h_del = 0
+            if committed and committed != agent_blob:
+                rc, d, _ = git(["diff", "--numstat", agent_blob, committed], cwd)
+                if rc == 0 and d:
+                    a, b = d.split("\t")[:2]
+                    h_add, h_del = (int(a) if a.isdigit() else 0), (int(b) if b.isdigit() else 0)
+            human_changed += h_add + h_del
+            agent_added += max(added - h_add, 0)
+            entry.update(
+                {
+                    "human_lines_added": h_add,
+                    "human_lines_removed": h_del,
+                    "agent_blob": agent_blob,
+                    "committed_blob": committed,
+                }
+            )
+        files.append(entry)
+    have_blobs = any("agent_blob" in f for f in files)
+    return {
+        "files_in_commit": len(files),
+        "touched_by_agent": sum(1 for f in files if f["agent_wrote"]),
+        "lines_added_in_commit": total_added,
+        "lines_changed_by_human_after_agent": human_changed,
+        # None when nothing can be attributed: no lines added, or no agent-written blob was recorded
+        "agent_share": round(agent_added / total_added, 2) if total_added and have_blobs else None,
+        "files": files[:50],
+    }
+
+
+def post_tool_use(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    tool = h.get("tool_name")
+    inp = h.get("tool_input") or {}
+    if tool in EDIT_TOOLS:
+        if inp.get("file_path"):
+            _record_agent_blob(cwd, str(inp["file_path"]))
+        return 0, ""
+    if tool != "Bash" or not COMMIT_RE.search(inp.get("command", "")):
+        return 0, ""
+    rc, head, _ = git(["rev-parse", "HEAD"], cwd)
+    if rc != 0:
+        return 0, ""
+    rules, warn = _rules_or_none(cwd, home)
+    if rules is None:
+        return 0, warn
+    st = load_state(cwd)
+    summ = summarize(h.get("transcript_path") or st.get("transcript_path"), rules=rules)
+    _, files, _ = git(["show", "--stat", "--format=", head], cwd)
+    attribution = _attribution(cwd, head, st.get("agent_blobs", {}), summ["files_written"])
+    session_id = h.get("session_id") or st.get("session_id")
+    note = {
+        "schema": NOTE_SCHEMA,
+        "session_id": session_id,
+        "step": st.get("steps"),
+        "committed_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "assistant_turns_so_far": summ["turns"],
+        "tool_calls_so_far": len(summ["tool_calls"]),
+        "tools_used": sorted({t["tool"] for t in summ["tool_calls"] if t.get("tool")}),
+        "last_stated_plan": summ["last_assistant_text"],
+        "files_in_commit": [ln.strip() for ln in files.splitlines()[:-1]][:50] if files else [],
+        "files_written_by_agent_this_session": [f["path"] for f in attribution["files"] if f["agent_wrote"]][:50],
+        "attribution": attribution,
+        "transcript": "kept local; see ledger",
+        "redaction": "secrets/PII patterns, high-entropy tokens and custom rules replaced at write time",
+    }
+    ref = notes_ref(session_id)
+    body = "gitvow-session\n" + json.dumps(note, indent=1)
+    git(["notes", f"--ref={ref}", "add", "-f", "-m", body, head], cwd)
+    log_event(cwd, "note_added", {"commit": head[:12], "session_id": session_id, "step": note["step"]})
+    return 0, f"session note attached to {head[:12]} (refs/notes/{ref})"
+
+
+def stop(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    home = home or os.path.expanduser("~")
+    rules, warn = _rules_or_none(cwd, home)
+    if rules is None:
+        return 0, warn
+    st = load_state(cwd)
+    summ = summarize(h.get("transcript_path") or st.get("transcript_path"), rules=rules)
+    led = os.path.join(home, ".gitvow", "ledger")
+    os.makedirs(led, exist_ok=True)
+    commits: list[str] = []
+    if st.get("started"):
+        rc, out, _ = git(["log", "--format=%H", f"--since={st['started']}"], cwd)
+        commits = out.split() if rc == 0 else []
+    rec = {
+        "session_id": h.get("session_id"),
+        "repo": cwd,
+        "started": st.get("started"),
+        "ended": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "assistant_turns": summ["turns"],
+        "tool_calls": summ["tool_calls"],
+        "commits_during_session": commits,
+        "last_stated_plan": summ["last_assistant_text"],
+    }
+    with open(os.path.join(led, f"{h.get('session_id') or 'unknown'}.json"), "w") as fh:
+        json.dump(rec, fh, indent=1)
+    log_event(cwd, "session_stop", {"session_id": h.get("session_id"), "tool_calls": len(summ["tool_calls"])})
+    return 0, ""
+
+
+HANDLERS = {"SessionStart": session_start, "PreToolUse": pre_tool_use, "PostToolUse": post_tool_use, "Stop": stop}

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/install.py

@@ -22,6 +22,20 @@ SELF="$(cd "$(dirname "$0")" && pwd)"; REPOHOOKS="$(cd "$GD/hooks" 2>/dev/null &
 exit 0
 """
 MARKER = "gitvow hook "
+NOTES_GLOB = "refs/notes/gitvow/*"
+NOTES_KEYS = ("notes.displayRef", "notes.rewriteRef")
+
+
+def _set_notes_config(cwd: str, scope: list[str]) -> None:
+    for key in NOTES_KEYS:
+        rc, cur, _ = git(["config", *scope, "--get-all", key], cwd)
+        if rc != 0 or NOTES_GLOB not in cur.splitlines():
+            git(["config", *scope, "--add", key, NOTES_GLOB], cwd)
+
+
+def _unset_notes_config(cwd: str, scope: list[str]) -> None:
+    for key in NOTES_KEYS:
+        git(["config", *scope, "--unset", key, "^" + NOTES_GLOB.replace("*", "\\*").replace(".", "\\.") + "$"], cwd)
 
 
 def _hook_entries(cmd_prefix: str) -> dict[str, list[dict[str, Any]]]:
@@ -34,7 +48,7 @@ def _hook_entries(cmd_prefix: str) -> dict[str, list[dict[str, Any]]]:
     return {
         "SessionStart": [entry("SessionStart", None)],
         "PreToolUse": [entry("PreToolUse", "Bash|Edit|Write|MultiEdit|NotebookEdit|mcp__.*")],
-        "PostToolUse": [entry("PostToolUse", "Bash")],
+        "PostToolUse": [entry("PostToolUse", "Bash|Edit|Write|MultiEdit|NotebookEdit")],
         "Stop": [entry("Stop", None)],
     }
 
@@ -94,7 +108,12 @@ def install_user(home: str, cmd_prefix: str = "gitvow") -> list[str]:
     _write_git_hook(os.path.join(base, "git-hooks"))
     merge_settings(os.path.join(home, ".claude", "settings.json"), cmd_prefix)
     git(["config", "--global", "core.hooksPath", os.path.join(base, "git-hooks")], home)
-    done += ["hooks merged into ~/.claude/settings.json", "global core.hooksPath → ~/.gitvow/git-hooks"]
+    _set_notes_config(home, ["--global"])
+    done += [
+        "hooks merged into ~/.claude/settings.json",
+        "global core.hooksPath → ~/.gitvow/git-hooks",
+        f"global notes.displayRef / notes.rewriteRef → {NOTES_GLOB}",
+    ]
     return done
 
 
@@ -107,6 +126,7 @@ def uninstall_user(home: str, purge_policy: bool = False, purge_ledger: bool = F
         git(["config", "--global", "--unset", "core.hooksPath"], home)
         done.append("global core.hooksPath unset")
     shutil.rmtree(os.path.join(base, "git-hooks"), ignore_errors=True)
+    _unset_notes_config(home, ["--global"])
     if purge_policy and os.path.exists(os.path.join(base, "policy.json")):
         os.remove(os.path.join(base, "policy.json"))
         done.append("policy removed")
@@ -128,10 +148,12 @@ def install_repo(repo: str, cmd_prefix: str = "gitvow") -> list[str]:
     _write_git_hook(os.path.join(base, "git-hooks"))
     merge_settings(os.path.join(repo, ".claude", "settings.json"), cmd_prefix)
     git(["config", "core.hooksPath", ".gitvow/git-hooks"], repo)
+    _set_notes_config(repo, [])
     return [
         f"policy → {pol}",
         "hooks merged into .claude/settings.json",
         "core.hooksPath → .gitvow/git-hooks",
+        f"notes.displayRef / notes.rewriteRef → {NOTES_GLOB}",
         "commit .gitvow/ and .claude/settings.json to share; teammates run: git config core.hooksPath .gitvow/git-hooks",
     ]
 
@@ -144,6 +166,7 @@ def uninstall_repo(repo: str, purge_notes: bool = False) -> list[str]:
         git(["config", "--unset", "core.hooksPath"], repo)
         done.append("core.hooksPath unset")
     shutil.rmtree(os.path.join(repo, ".gitvow"), ignore_errors=True)
+    _unset_notes_config(repo, [])
     rc, gd, _ = git(["rev-parse", "--git-dir"], repo)
     if rc == 0:
         gd = gd if os.path.isabs(gd) else os.path.join(repo, gd)
@@ -152,7 +175,9 @@ def uninstall_repo(repo: str, purge_notes: bool = False) -> list[str]:
             if os.path.exists(p):
                 os.remove(p)
     if purge_notes:
-        git(["update-ref", "-d", "refs/notes/sessions"], repo)
-        done.append("local refs/notes/sessions deleted (remote copies untouched)")
+        _, refs, _ = git(["for-each-ref", "--format=%(refname)", "refs/notes/sessions", "refs/notes/gitvow/"], repo)
+        for ref in refs.split():
+            git(["update-ref", "-d", ref], repo)
+        done.append(f"{len(refs.split())} local session note ref(s) deleted (remote copies untouched)")
     done.append(".gitvow removed; commit trailers already in history remain")
     return done

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/redact.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import json
 import math
+import os
 import re
 from collections import Counter
 from collections.abc import Callable, Iterable
@@ -69,3 +70,53 @@ def redact(value: object, custom: Iterable[tuple[str, str]] = ()) -> str:
     for rx, rep in PATTERNS:
         s = rx.sub(rep, s)
     return redact_high_entropy(s)
+
+
+class RedactionError(Exception):
+    """A rules file is unreadable or a pattern does not compile. Callers must write nothing."""
+
+
+RULES_FILENAME = "redact-rules.json"
+
+
+def _read_rules(path: str) -> list[tuple[str, str]]:
+    try:
+        with open(path) as fh:
+            data = json.load(fh)
+    except OSError as e:
+        raise RedactionError(f"{path}: {e.strerror or e}") from e
+    except json.JSONDecodeError as e:
+        raise RedactionError(f"{path}: invalid JSON ({e.msg} at line {e.lineno})") from e
+    if isinstance(data, dict):
+        data = data.get("rules", [])
+    if not isinstance(data, list):
+        raise RedactionError(f"{path}: expected a list of rules")
+    out: list[tuple[str, str]] = []
+    for i, r in enumerate(data):
+        if (
+            not isinstance(r, dict)
+            or not isinstance(r.get("pattern"), str)
+            or not isinstance(r.get("replacement"), str)
+        ):
+            raise RedactionError(f"{path}: rule {i} needs string 'pattern' and 'replacement'")
+        try:
+            re.compile(r["pattern"])
+        except re.error as e:
+            raise RedactionError(f"{path}: rule {i} pattern does not compile ({e})") from e
+        out.append((r["pattern"], r["replacement"]))
+    return out
+
+
+def load_rules(cwd: str | None = None, home: str | None = None) -> list[tuple[str, str]]:
+    """Custom rules from <repo>/.gitvow/redact-rules.json then ~/.gitvow/redact-rules.json. Both apply.
+
+    Raises RedactionError on any unreadable or invalid file: callers must then write nothing.
+    """
+    rules: list[tuple[str, str]] = []
+    for base in (cwd, home or os.path.expanduser("~")):
+        if not base:
+            continue
+        path = os.path.join(base, ".gitvow", RULES_FILENAME)
+        if os.path.exists(path):
+            rules += _read_rules(path)
+    return rules

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/selftest.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 import shutil
 import subprocess
@@ -65,20 +66,30 @@ def run() -> int:
                 "deny: destructive MCP tool",
             )
         )
+        with open(os.path.join(repo, "a.txt"), "a") as fh:
+            fh.write("b\n")
+        post_tool_use({**base, "tool_name": "Edit", "tool_input": {"file_path": "a.txt"}}, home)
+        with open(os.path.join(repo, "a.txt"), "a") as fh:
+            fh.write("human\n")
         pre_tool_use({**base, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}}, home)
         hooks_dir = os.path.join(repo, ".gitvow", "git-hooks")
         _write_git_hook(hooks_dir)
         g("config", "core.hooksPath", ".gitvow/git-hooks")
-        with open(os.path.join(repo, "a.txt"), "a") as fh:
-            fh.write("b\n")
+        g("config", "notes.rewriteRef", "refs/notes/gitvow/*")
         g("commit", "-qam", "selftest commit")
         results.append(("Gitvow-Session:" in g("log", "-1", "--format=%B"), "commit trailer added"))
         post_tool_use({**base, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}}, home)
+        note = g("notes", "--ref=gitvow/selftest-session", "show", "HEAD")
+        results.append((note.startswith("gitvow-session"), "session note attached on the session's own ref"))
+        att = json.loads(note.split("\n", 1)[1])["attribution"] if note else {}
+        results.append(
+            (att.get("lines_changed_by_human_after_agent") == 1 and att.get("agent_share") == 0.5, "line attribution")
+        )
+        g("commit", "-q", "--amend", "-m", "amended")
         results.append(
             (
-                g("notes", "--ref=sessions", "list").count("\n") + (1 if g("notes", "--ref=sessions", "list") else 0)
-                == 1,
-                "session note attached",
+                g("notes", "--ref=gitvow/selftest-session", "show", "HEAD").startswith("gitvow-session"),
+                "note follows amend",
             )
         )
         stop(base, home)

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/state.py

@@ -50,3 +50,8 @@ def log_event(cwd: str, kind: str, payload: dict[str, Any]) -> None:
         return
     with open(os.path.join(gd, "gitvow-hooks.log"), "a") as fh:
         fh.write(json.dumps({"ts": time.strftime("%Y-%m-%dT%H:%M:%S"), "kind": kind, **payload}) + "\n")
+
+
+def toplevel(cwd: str) -> str | None:
+    rc, out, _ = git(["rev-parse", "--show-toplevel"], cwd)
+    return out if rc == 0 else None

{gitvow-0.1.2 → gitvow-0.2.0}/src/gitvow/transcript.py

@@ -4,16 +4,18 @@ from __future__ import annotations
 
 import json
 import os
+from collections.abc import Iterable
 from typing import Any
 
 from .redact import redact
 
 
-def summarize(path: str | None, max_tools: int = 500) -> dict[str, Any]:
+def summarize(path: str | None, max_tools: int = 500, rules: Iterable[tuple[str, str]] = ()) -> dict[str, Any]:
     out: dict[str, Any] = {"turns": 0, "tool_calls": [], "last_assistant_text": "", "files_written": []}
     if not path or not os.path.exists(path):
         return out
     written: set[str] = set()
+    rules = list(rules)
     with open(path, errors="ignore") as fh:
         for line in fh:
             try:
@@ -28,7 +30,7 @@ def summarize(path: str | None, max_tools: int = 500) -> dict[str, Any]:
             out["turns"] += 1
             if isinstance(content, str):
                 if content.strip():
-                    out["last_assistant_text"] = redact(content)[:600]
+                    out["last_assistant_text"] = redact(content, rules)[:600]
                 continue
             if not isinstance(content, list):
                 continue
@@ -38,10 +40,10 @@ def summarize(path: str | None, max_tools: int = 500) -> dict[str, Any]:
                 if c.get("type") == "tool_use" and len(out["tool_calls"]) < max_tools:
                     inp = c.get("input") or {}
                     brief = inp.get("command") or inp.get("file_path") or inp.get("query") or inp.get("pattern") or ""
-                    out["tool_calls"].append({"tool": c.get("name"), "arg": redact(str(brief))[:160]})
+                    out["tool_calls"].append({"tool": c.get("name"), "arg": redact(str(brief), rules)[:160]})
                     if c.get("name") in ("Edit", "Write", "MultiEdit", "NotebookEdit") and inp.get("file_path"):
                         written.add(str(inp["file_path"]))
                 elif c.get("type") == "text" and str(c.get("text", "")).strip():
-                    out["last_assistant_text"] = redact(c["text"])[:600]
+                    out["last_assistant_text"] = redact(c["text"], rules)[:600]
     out["files_written"] = sorted(written)
     return out

{gitvow-0.1.2 → gitvow-0.2.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.1.2
+Version: 0.2.0
 Summary: Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies.
 Author-email: Nikhil Bora <nikhil@wirevow.com>
 License: Apache-2.0

{gitvow-0.1.2 → gitvow-0.2.0}/tests/test_collect.py

@@ -19,7 +19,9 @@ def test_collect_and_summarize(repo, home, payload, transcript, tmp_path):
     stop(payload("Stop", transcript=transcript), str(home))
     w = collect(str(home), str(tmp_path / "out"))
     s = summarize(w)
-    assert s["sessions"] == 1 and s["commits_with_trailers"] == 1 and s["notes_attached"] == 1
+    assert (
+        s["sessions"] == 1 and s["commits_with_trailers"] == 1 and s["notes_attached"] == 1
+    )  # read from refs/notes/gitvow/*
     assert s["hook_decisions"]["blocked"] == 1 and s["gate_fired_on"][0]["reason"] == "force push"
     assert "ghp_" not in Path(f"{w}/SUMMARY.txt").read_text()
     led = json.loads(next((tmp_path / "out").rglob("sess-1.json")).read_text())