hubkit-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project are recorded here. The format follows [Keep
 
 ## [Unreleased]
 
+## [0.2.1] - 2026-11-06
+
+### Added
+- `hubkit find WORD [--since]` and, in `digest` and `eod`, the PRs the user's account opened plus what each peer session was asked (`hubcore/ledger.py`; read only on peers, prompts redacted, `gh` failures shown).
+
+### Changed
+- The unpushed-work Stop reason only counts files changed, and commits made, since the turn began; older dirt in the checkout no longer holds a report.
+
 ## [0.2.0] - 2026-11-06
 
 ### Added

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hubkit-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Session supervisor for Claude Code: hooks-based multi-agent orchestration with order clocks, routed-work tracking, a watchdog and a stop gate, standard library only.
 Project-URL: Repository, https://github.com/ankitkpandey1/hubkit
 Project-URL: Documentation, https://github.com/ankitkpandey1/hubkit/tree/main/docs
@@ -47,7 +47,7 @@ In a live hub, the prompt hook opens that order itself from your sentence, and t
 - **Watchdog and wake-up.** `hubkit tick` (cron) and `hubkit watch` (a background process) raise alerts with back-off; a watch exit wakes an idle hub.
 - **Stop gate.** The Stop hook refuses to let the turn end while the hub owes something (no watch running, a stalled item, an unbacked verdict, a question to you that blocks nothing, a "tests pass" claim with no command run, a PR number with no link, an approval on red CI, built work not pushed).
 - **Tool guards.** An optional warn-only PreToolUse hook (`hubkit hooks --merge-guard`) warns about an unordered merge, a post without your typed yes, a banned command, stopping an agent and an unmarked decision card. It never denies.
-- **Status, digest, end-of-day review.** A status block at session start and on each prompt, a daily archive, `hubkit digest` for when you come back, `hubkit eod`, a per-class `hubkit trust` ledger, and `hubkit inbound ingest` to track asks from other people so none goes unanswered.
+- **Status, digest, end-of-day review.** A status block at session start and on each prompt, a daily archive, `hubkit digest` for when you come back (it also lists the PRs your account opened and what each peer session was asked), `hubkit find WORD` to search orders, work, asks, peer prompts and your PRs, `hubkit eod`, a per-class `hubkit trust` ledger, and `hubkit inbound ingest` to track asks from other people so none goes unanswered.
 
 `SKILL.md` is the behaviour contract the hub session reads. This file is the operator view.
 
@@ -113,6 +113,7 @@ hubkit order open --kind hotfix --quote "hotfix the billing bug now"   # or let
 hubkit order ls
 hubkit work add --kind active --title "triage the flaky test"
 hubkit status                                                          # the status block
+hubkit find billing --since 2d                                         # search orders, asks, peer prompts, your PRs
 python3 ~/.claude/skills/hub/scripts/learn.py add --class ask-before-merge --gate G5 \
     --quote "I told you to wait for the review" --situation "..." --wrong "..." --right "..." --evidence "..."
 ```

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/README.md

@@ -33,7 +33,7 @@ In a live hub, the prompt hook opens that order itself from your sentence, and t
 - **Watchdog and wake-up.** `hubkit tick` (cron) and `hubkit watch` (a background process) raise alerts with back-off; a watch exit wakes an idle hub.
 - **Stop gate.** The Stop hook refuses to let the turn end while the hub owes something (no watch running, a stalled item, an unbacked verdict, a question to you that blocks nothing, a "tests pass" claim with no command run, a PR number with no link, an approval on red CI, built work not pushed).
 - **Tool guards.** An optional warn-only PreToolUse hook (`hubkit hooks --merge-guard`) warns about an unordered merge, a post without your typed yes, a banned command, stopping an agent and an unmarked decision card. It never denies.
-- **Status, digest, end-of-day review.** A status block at session start and on each prompt, a daily archive, `hubkit digest` for when you come back, `hubkit eod`, a per-class `hubkit trust` ledger, and `hubkit inbound ingest` to track asks from other people so none goes unanswered.
+- **Status, digest, end-of-day review.** A status block at session start and on each prompt, a daily archive, `hubkit digest` for when you come back (it also lists the PRs your account opened and what each peer session was asked), `hubkit find WORD` to search orders, work, asks, peer prompts and your PRs, `hubkit eod`, a per-class `hubkit trust` ledger, and `hubkit inbound ingest` to track asks from other people so none goes unanswered.
 
 `SKILL.md` is the behaviour contract the hub session reads. This file is the operator view.
 
@@ -99,6 +99,7 @@ hubkit order open --kind hotfix --quote "hotfix the billing bug now"   # or let
 hubkit order ls
 hubkit work add --kind active --title "triage the flaky test"
 hubkit status                                                          # the status block
+hubkit find billing --since 2d                                         # search orders, asks, peer prompts, your PRs
 python3 ~/.claude/skills/hub/scripts/learn.py add --class ask-before-merge --gate G5 \
     --quote "I told you to wait for the review" --situation "..." --wrong "..." --right "..." --evidence "..."
 ```

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/docs/architecture.md

@@ -114,11 +114,11 @@ The Stop hook blocks the end of the turn, with the exact next action, while any
 5. A blocker is not being solved (no fix running, fix past its limit), a STOP-LOSS has no result since, or the final message calls an open order blocked/down/failed/waiting while no order has a fix on record.
 6. The final message says done while his newest prompt is newer than the last `work done` and the last `hubkit asks ls`; or it calls something gone/lost/absent, or "a person's call", with no Read/Grep/Glob/Bash call in the turn (transcript read).
 7. The final message ends on a question (or holds a `stop_guard.phrases` phrase) and no `ask` work item says anything really waits on the user. A question that is really blocked on him must use the card tool, not prose. An `ask` item asked 3 times with no answer also holds the turn: take the safest default and record it.
-8. The final message says "tests pass", "it works" or "is deployed" (`[stop_gate] verified_words`) but the turn ran no Bash command; names a PR or issue number with no link (`[stop_gate] full_links`); approves a PR while CI at its head is not green; or reports built work while the repo at the hook's `cwd` has uncommitted changes or unpushed commits.
+8. The final message says "tests pass", "it works" or "is deployed" (`[stop_gate] verified_words`) but the turn ran no Bash command; names a PR or issue number with no link (`[stop_gate] full_links`); approves a PR while CI at its head is not green; or reports built work while the repo at the hook's `cwd` has uncommitted changes or unpushed commits made since the turn began (older dirt in the checkout does not count).
 
 ## Digest and trust
 
-`hubkit digest [--since 12h]` prints what finished, which orders closed, the latest alerts and what waits on the user. `hubkit trust record --class C --outcome accept|edit|reject` appends to `trust.jsonl`; `trust ls` shows each class as `auto` (enough accepts and nothing else) or `ask` (propose first), and the session status block names the classes that earned `auto` and those he rejected.
+`hubkit digest [--since 12h]` prints what finished, which orders closed, the latest alerts, what waits on the user, the PRs his account opened and what each peer session was asked (`ledger.py`: peer transcripts are read only and prompts are redacted; a `gh` failure is shown, not hidden). `hubkit find WORD` searches the same record plus orders, work, the archive and his asks. `hubkit trust record --class C --outcome accept|edit|reject` appends to `trust.jsonl`; `trust ls` shows each class as `auto` (enough accepts and nothing else) or `ask` (propose first), and the session status block names the classes that earned `auto` and those he rejected.
 
 ## The learn loop
 

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/docs/commands.md

@@ -16,10 +16,11 @@
 | `hubkit order open --kind K --quote "..." [--unconfirmed]` | Open an order by hand. |
 | `hubkit order confirm ID` | Turn an unconfirmed order into an open one. |
 | `hubkit order move ID --note "..." [--estimate N]` | Record real movement. The first move also records the order's estimate (N minutes, else the usual time for its kind; printed when defaulted). |
-| `hubkit digest [--since 12h]` | What finished, which orders closed, the latest alerts and what waits on the user, for a user coming back. |
+| `hubkit digest [--since 12h]` | What finished, which orders closed, the latest alerts, what waits on the user, the PRs his account opened and what each peer session was asked, for a user coming back. |
 | `hubkit inbound ingest [--file F]` | Turns the inbox watcher's lines into `reply` work items (one per asker, no duplicates). |
 | `hubkit trust record --class C --outcome O` / `trust ls` | Per-class record of approved and corrected outcomes; a class with repeated corrections is shown as ask-first. |
 | `hubkit work verify ID` | Stamp the item as checked against reality just now. An `active` or `priority` item not verified for `watcher.verify_stale_min` raises an alert. It runs no check itself. |
+| `hubkit find WORD [--since 2d]` | Searches orders, work, the archive, his asks, peer session prompts and the PRs his account opened (title, body, changed file paths). Needs `gh` for the PR part; a `gh` failure is printed as UNKNOWN, never skipped. Read only on peer sessions; prompts are redacted. |
 | `hubkit asks ls [--since 12h]` | His recent prompts (from `recent-prompts.jsonl`), one line each, newest last. Marks the asks as re-read for the Stop gate. |
 | `hubkit order block ID --on "..." [--fix "..."] [--holder who]` | Record what blocks an order and the fix running now (a second call with the same `--on` adds the fix). No fix, or a fix older than `blocker_fix_min` with no result, alerts and holds the Stop gate. |
 | `hubkit order result ID --note "..."` | Record the result of an action: movement, clears the blocker and any STOP-LOSS. Notes from `order move` do neither. |
@@ -37,7 +38,7 @@
 | `hubkit work ls` | List live items. |
 | `hubkit tick [--if-bound] [--no-notify]` | One watchdog pass; prints `ALERT ...` lines. `--if-bound` is a no-op unless a hub is bound or an order is open (for cron). |
 | `hubkit watch [--interval S] [--max-cycles N]` | Loop `tick` (defaults 300 s, 12 cycles). Exits 0 printing `ALERT ...`, 3 after the cycles, 4 if another watch runs. |
-| `hubkit eod [--day D] [--note ".."]` | Write and print the end-of-day review. |
+| `hubkit eod [--day D] [--note ".."]` | Write and print the end-of-day review, including the day's PRs and what each peer session was asked. |
 | `hubkit doctor [--check-clean]` | Print config, state, bind, hook heartbeats, ledger health and a count of secret-shaped strings in state. Warns when your `intents.toml` lacks keys the example has, when a hubkit hook is registered twice in `settings.json` (read only), and when no scheduler entry runs `hubkit eod`. `--check-clean` also lists checkout files containing a `private.terms` word. Exit 1 on a problem. |
 | `hubkit hook EVENT` | Run one hook (`session`, `prompt`, `answer`, `routed`, `stop`, `record`, `pretool`); reads the payload from stdin. For Claude Code, not for people. |
 

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hubkit-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "Session supervisor for Claude Code: hooks-based multi-agent orchestration with order clocks, routed-work tracking, a watchdog and a stop gate, standard library only."
 readme = "README.md"
 requires-python = ">=3.14"

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/scripts/hubcore/cli.py

@@ -11,7 +11,7 @@ import time
 import tomllib
 from pathlib import Path
 
-from . import compat, config, hooks, inbound, install, lessons, routed, status, store, trust, watcher
+from . import compat, config, hooks, inbound, install, ledger, lessons, routed, status, store, trust, watcher
 from .orders import Orders
 from .redact import count_hits_text
 
@@ -265,6 +265,9 @@ def main(argv: list[str] | None = None) -> int:
 
     st = sub.add_parser("status")
     st.add_argument("--json", action="store_true")
+    fd = sub.add_parser("find")
+    fd.add_argument("word")
+    fd.add_argument("--since", default="2d", help="how far back for asks, peer prompts and PRs, for example 12h, 2d")
     dg = sub.add_parser("digest")
     dg.add_argument("--since", default="12h", help="how far back, for example 30m, 12h, 2d")
     e = sub.add_parser("eod")
@@ -308,6 +311,8 @@ def main(argv: list[str] | None = None) -> int:
         elif a.cmd == "status":
             st_ = status.write_status(cfg)
             print(json.dumps(st_, indent=1) if a.json else status.render_block(cfg, Orders(cfg), st_))
+        elif a.cmd == "find":
+            print("\n".join(ledger.find(cfg, a.word, a.since)))
         elif a.cmd == "digest":
             print("\n".join(status.digest(cfg, a.since)))
         elif a.cmd == "eod":

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/scripts/hubcore/gate.py

@@ -147,7 +147,7 @@ def stop_reasons(cfg: dict, last: str, now: float | None = None, transcript: str
     ci_bad = ci_not_green(cfg, last)  # before prompt_lines: a reviewed item closes there
     reasons = routed.prompt_lines(cfg, now)
     reasons += blocker_reasons(cfg, last, now)
-    if r := lessons.unpushed_work(last, cwd):
+    if r := lessons.unpushed_work(last, cwd, transcript):
         reasons.append(r)
     reasons += [r for r in (lessons.unswept_asks(cfg, last, now), lessons.unchecked_claim(cfg, last, transcript), lessons.unrun_claim(cfg, last, transcript)) if r]
     if refs := lessons.bare_refs(cfg, last):

hubkit_cli-0.2.1/scripts/hubcore/ledger.py

@@ -0,0 +1,248 @@
+"""The day's whole record, not only what the hub routed: PRs the user's account opened, what each peer session was asked,
+and a word search over all of it. Read-only on peers; a gh failure is shown, never swallowed.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import os
+import subprocess
+import time
+from datetime import datetime
+from pathlib import Path
+
+from . import config, hooks, routed, store
+from .orders import Orders
+from .redact import redact
+from .status import work_load
+
+PRS_TTL_S = 600
+SKIP_PREFIXES = ("<task-notification", "<system-reminder", "<command-")
+
+
+def _gh_json(cfg: dict, args: list[str]) -> object:
+    """Run gh and parse its JSON; raises RuntimeError with the reason when gh is missing, fails or prints no JSON."""
+    exe = routed._gh(cfg)
+    if exe is None:
+        raise RuntimeError("gh not found (set [tools] gh)")
+    try:
+        r = subprocess.run(
+            [exe, *args],
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=30,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError) as e:
+        raise RuntimeError(f"gh did not run: {e}") from e
+    if r.returncode != 0:
+        raise RuntimeError(f"gh {args[0]} failed: {redact(r.stderr.strip())[0][:160]}")
+    try:
+        return json.loads(r.stdout)
+    except ValueError as e:
+        raise RuntimeError(f"gh {args[0]} printed no JSON") from e
+
+
+def fetch_prs(cfg: dict, day: str) -> dict:
+    """PRs the user's account opened on or after `day`: number, title, url, body, changed file paths. {'prs': [...], 'error': str}."""
+    try:
+        found = _gh_json(
+            cfg,
+            [
+                "search",
+                "prs",
+                "--author",
+                "@me",
+                "--created",
+                f">={day}",
+                "--limit",
+                "50",
+                "--json",
+                "number,title,url,body,repository,createdAt",
+            ],
+        )
+        prs = []
+        for p in found if isinstance(found, list) else []:
+            view = _gh_json(cfg, ["pr", "view", p["url"], "--json", "files"])
+            files = (
+                [f.get("path", "") for f in view.get("files") or []]
+                if isinstance(view, dict)
+                else []
+            )
+            prs.append(
+                {
+                    "number": p["number"],
+                    "title": p["title"],
+                    "url": p["url"],
+                    "body": p.get("body") or "",
+                    "files": files,
+                }
+            )
+        return {"prs": prs, "error": ""}
+    except RuntimeError as e:
+        return {"prs": [], "error": str(e)}
+
+
+def prs_since(cfg: dict, day: str) -> dict:
+    """fetch_prs cached for ten minutes in the state dir (the cache file is per day)."""
+    cache = store.state(cfg) / f"ledger-prs-{day}.json"
+    try:
+        hit = json.loads(cache.read_text(encoding="utf-8"))
+        if time.time() - hit["at"] < PRS_TTL_S and not hit["data"]["error"]:
+            return hit["data"]
+    except OSError, ValueError, KeyError:
+        pass
+    data = fetch_prs(cfg, day)
+    store.write_atomic(
+        cache, json.dumps({"at": time.time(), "data": redact_obj_safe(data)})
+    )
+    return data
+
+
+def redact_obj_safe(data: dict) -> dict:
+    """The PR text goes through the same redaction as state before it is written."""
+    from .redact import redact_obj
+
+    return redact_obj(data, limit=4000)
+
+
+def _text(msg: object) -> str:
+    content = (msg or {}).get("content") if isinstance(msg, dict) else None
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(
+            str(b.get("text", ""))
+            for b in content
+            if isinstance(b, dict) and b.get("type") == "text"
+        )
+    return ""
+
+
+def _names(cfg: dict) -> dict[str, str]:
+    out: dict[str, str] = {}
+    for f in config.sessions_dir(cfg).glob("*.json"):
+        try:
+            d = json.loads(f.read_text(encoding="utf-8"))
+            out[str(d.get("sessionId"))] = str(d.get("name") or "")
+        except OSError, ValueError:
+            continue
+    return out
+
+
+def peer_prompts(cfg: dict, since: float) -> list[dict]:
+    """What each other session was asked since `since` (epoch): {ts, session, text}, redacted, oldest first. Reads transcripts only."""
+    bind = hooks.read_bind(cfg) or {}
+    own, names, out = str(bind.get("sessionId") or ""), _names(cfg), []
+    for f in glob.glob(os.path.expanduser(cfg["paths"]["transcripts_glob"])):
+        sid = Path(f).stem
+        try:
+            if sid == own or os.stat(f).st_mtime < since:
+                continue
+            lines = Path(f).read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            continue
+        for line in lines:
+            try:
+                o = json.loads(line)
+                ts = datetime.fromisoformat(
+                    str(o["timestamp"]).replace("Z", "+00:00")
+                ).timestamp()
+            except KeyError, ValueError:
+                continue
+            text = _text(o.get("message")).strip() if o.get("type") == "user" else ""
+            if ts >= since and text and not text.startswith(SKIP_PREFIXES):
+                out.append(
+                    {
+                        "ts": ts,
+                        "session": names.get(sid) or sid[:8],
+                        "text": redact(" ".join(text.split()))[0][:300],
+                    }
+                )
+    return sorted(out, key=lambda r: r["ts"])
+
+
+def day_start(cfg: dict, day: str) -> float:
+    """Epoch of 00:00 on `day` in the configured timezone."""
+    return (
+        datetime.strptime(day, "%Y-%m-%d").replace(tzinfo=store.tzinfo(cfg)).timestamp()
+    )
+
+
+def day_lines(cfg: dict, day: str) -> list[str]:
+    """The ledger lines for a day: the user's PRs and what each peer session was asked."""
+    data = prs_since(cfg, day)
+    out = [f"PRs opened by the user's account since {day}: {len(data['prs'])}"]
+    out += [
+        f"  #{p['number']} {p['title'][:80]} ({len(p['files'])} files) {p['url']}"
+        for p in data["prs"]
+    ]
+    if data["error"]:
+        out.append(f"  PRs UNKNOWN: {data['error']}")
+    peers = peer_prompts(cfg, day_start(cfg, day))
+    out.append(f"Peer session prompts since {day}: {len(peers)}")
+    seen: dict[str, int] = {}
+    for r in peers:
+        seen[r["session"]] = seen.get(r["session"], 0) + 1
+        if seen[r["session"]] <= 3:
+            out.append(
+                f"  {store.clock(cfg, r['ts'])} {r['session']}: {r['text'][:110]}"
+            )
+    out += [f"  {s}: {n - 3} more" for s, n in seen.items() if n > 3]
+    return out
+
+
+def _snip(text: str, word: str) -> str:
+    i = text.lower().find(word.lower())
+    return redact(" ".join(text[max(0, i - 40) : i + 80].split()))[0]
+
+
+def find(cfg: dict, word: str, span: str = "2d") -> list[str]:
+    """Lines `[source] id: ...text...` for every record that holds `word` (case-insensitive): orders, work, the archive,
+    the user's asks, peer session prompts, and the user's PRs (title, body, changed file paths).
+    """
+    from .lessons import parse_span
+
+    sd, now = store.state(cfg), time.time()
+    since = now - parse_span(span)
+    hits: list[str] = []
+
+    def check(source: str, ident: str, *texts: str) -> None:
+        for t in texts:
+            if t and word.lower() in t.lower():
+                hits.append(f"[{source}] {ident}: {_snip(t, word)}")
+                return
+
+    for o in Orders(cfg).all().values():
+        check("order", o["id"], o.get("quote", ""), o.get("kind", ""))
+    for i in work_load(sd):
+        check("work", i["id"], i.get("title", ""), i.get("note", ""))
+    for f in sorted(glob.glob(str(sd / "archive" / "archive_*.jsonl"))):
+        for r in store.read_rows(Path(f))[0]:
+            check(
+                "archive",
+                str(r.get("id", "?")),
+                str(r.get("title", "")),
+                str(r.get("note", "")),
+                str(r.get("done_note", "")),
+                str(r.get("quote", "")),
+            )
+    for r in store.read_rows(sd / "recent-prompts.jsonl")[0]:
+        if r["ts"] >= since:
+            check("ask", store.clock(cfg, r["ts"]), r.get("text", ""))
+    for r in peer_prompts(cfg, since):
+        check("peer", f"{r['session']} {store.clock(cfg, r['ts'])}", r["text"])
+    data = prs_since(cfg, store.day_of(cfg, since))
+    for p in data["prs"]:
+        check(
+            "pr",
+            f"#{p['number']} {p['url']}",
+            p["title"],
+            p["body"],
+            " ".join(p["files"]),
+        )
+    if data["error"]:
+        hits.append(f"[pr] UNKNOWN, PRs could not be searched: {data['error']}")
+    return hits or [f"no record holds {word!r} in the last {span}"]

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/scripts/hubcore/lessons.py

@@ -1,12 +1,15 @@
 """Checks that come from repeated corrections: re-reading the user's asks, unchecked claims, briefs that forbid the
-fix, and an unasked merge. Every check is a warning or a Stop reason; none denies a tool call."""
+fix, and an unasked merge. Every check is a warning or a Stop reason; none denies a tool call.
+"""
 
 from __future__ import annotations
 
 import json
+import os
 import re
 import subprocess
 import time
+from datetime import datetime
 from pathlib import Path
 
 from . import store
@@ -28,6 +31,8 @@ DONE_CLAIM = re.compile(
 def claims_done(text: str) -> bool:
     """True when a sentence of the message says the user's work is finished."""
     return any(DONE_CLAIM.search(s) for s in re.split(r"(?<=[.!?])\s+|\n", text))
+
+
 SPAN = re.compile(r"^(\d+)\s*([mhd])$")
 
 
@@ -35,7 +40,9 @@ def parse_span(text: str) -> float:
     """`30m`, `12h` or `2d` as seconds; raises ValueError otherwise."""
     m = SPAN.match(text.strip().lower())
     if not m:
-        raise ValueError(f"--since takes a number and m, h or d (for example 12h), not {text!r}")
+        raise ValueError(
+            f"--since takes a number and m, h or d (for example 12h), not {text!r}"
+        )
     return int(m[1]) * {"m": 60, "h": 3600, "d": 86400}[m[2]]
 
 
@@ -50,14 +57,18 @@ def asks_lines(cfg: dict, span: str) -> list[str]:
     """`HH:MM  words` per prompt, newest last. Reading them marks the asks as swept for the Stop gate."""
     rows = recent_prompts(cfg, parse_span(span))
     store.write_atomic(store.state(cfg) / "asks-swept", str(time.time()))
-    return [f"{store.clock(cfg, r['ts'])}  {r['text']}" for r in rows] or ["(no prompts in that span)"]
+    return [f"{store.clock(cfg, r['ts'])}  {r['text']}" for r in rows] or [
+        "(no prompts in that span)"
+    ]
 
 
 def _last_work_done(cfg: dict, now: float) -> float:
     last = 0.0
     for back in (0, 1):
         day = store.day_of(cfg, now - back * 86400)
-        for r in store.read_rows(store.state(cfg) / "archive" / f"archive_{day}.jsonl")[0]:
+        for r in store.read_rows(store.state(cfg) / "archive" / f"archive_{day}.jsonl")[
+            0
+        ]:
             if r.get("type") == "work" and r.get("outcome") == "done":
                 last = max(last, float(r["ts"]))
     return last
@@ -74,18 +85,34 @@ def unswept_asks(cfg: dict, last: str, now: float | None = None) -> str | None:
         return None
     try:
         swept = float((store.state(cfg) / "asks-swept").read_text(encoding="utf-8"))
-    except (OSError, ValueError):
+    except OSError, ValueError:
         swept = 0.0
     if prompts[-1]["ts"] <= max(swept, _last_work_done(cfg, now)):
         return None
-    return ("hubkit: you say it is done but have not re-read his words since his last prompt. NEXT: hubkit asks ls --since 12h; "
-            "list every requirement in them and tick each with evidence before saying done")
+    return (
+        "hubkit: you say it is done but have not re-read his words since his last prompt. NEXT: hubkit asks ls --since 12h; "
+        "list every requirement in them and tick each with evidence before saying done"
+    )
 
 
 # ---- claims that need a lookup in the same turn ----
 
-UNCHECKED_WORDS = ["gone", "lost", "absent", "vanished", "disappeared", "does not exist", "doesn't exist", "never written", "was never there",
-                   "a person's call", "needs your call", "needs his call", "needs her call", "needs a human decision"]
+UNCHECKED_WORDS = [
+    "gone",
+    "lost",
+    "absent",
+    "vanished",
+    "disappeared",
+    "does not exist",
+    "doesn't exist",
+    "never written",
+    "was never there",
+    "a person's call",
+    "needs your call",
+    "needs his call",
+    "needs her call",
+    "needs a human decision",
+]
 LOOKUP_TOOLS = ("Read", "Grep", "Glob", "Bash")
 
 
@@ -94,7 +121,9 @@ def tools_this_turn(transcript: str | Path | None) -> list[str] | None:
     if not transcript:
         return None
     try:
-        lines = Path(transcript).read_text(encoding="utf-8", errors="replace").splitlines()
+        lines = (
+            Path(transcript).read_text(encoding="utf-8", errors="replace").splitlines()
+        )
     except OSError:
         return None
     names: list[str] = []
@@ -105,8 +134,11 @@ def tools_this_turn(transcript: str | Path | None) -> list[str] | None:
             continue
         c = (o.get("message") or {}).get("content")
         blocks = [b for b in c if isinstance(b, dict)] if isinstance(c, list) else []
-        if o.get("type") == "user" and (isinstance(c, str) or any(b.get("type") == "text" for b in blocks)) \
-                and (o.get("origin") or {}).get("kind", "human") == "human":
+        if (
+            o.get("type") == "user"
+            and (isinstance(c, str) or any(b.get("type") == "text" for b in blocks))
+            and (o.get("origin") or {}).get("kind", "human") == "human"
+        ):
             break
         if o.get("type") == "assistant":
             names += [str(b.get("name")) for b in blocks if b.get("type") == "tool_use"]
@@ -131,28 +163,62 @@ def unchecked_claim(cfg: dict, last: str, transcript: str | Path | None) -> str
     """A reason when the message calls something gone/lost/absent, or a person's call, and this turn made no lookup."""
     from .gate import _asserted
 
-    words = Orders(cfg).intents.get("stop_gate", {}).get("unchecked_words", UNCHECKED_WORDS)
-    hit = next((s.strip()[:100] for s in re.split(r"(?<=[.!?])\s+|\n", last) if any(_asserted(s.lower(), w.lower()) for w in words)), None)
+    words = (
+        Orders(cfg).intents.get("stop_gate", {}).get("unchecked_words", UNCHECKED_WORDS)
+    )
+    hit = next(
+        (
+            s.strip()[:100]
+            for s in re.split(r"(?<=[.!?])\s+|\n", last)
+            if any(_asserted(s.lower(), w.lower()) for w in words)
+        ),
+        None,
+    )
     if not hit or lookups_this_turn(transcript) != 0:
         return None
-    return (f"hubkit: your message claims {hit!r} but this turn read nothing. A report that something is gone, or is a person's call, "
-            "is checked, not relayed. NEXT: read the code or record that writes it (or what he already decided), then say it")
-
-
-VERIFIED_WORDS = ["tests pass", "tests passed", "all tests pass", "all green", "ci is green", "it works", "now works", "is deployed", "was deployed", "is live now", "fixed and verified"]
+    return (
+        f"hubkit: your message claims {hit!r} but this turn read nothing. A report that something is gone, or is a person's call, "
+        "is checked, not relayed. NEXT: read the code or record that writes it (or what he already decided), then say it"
+    )
+
+
+VERIFIED_WORDS = [
+    "tests pass",
+    "tests passed",
+    "all tests pass",
+    "all green",
+    "ci is green",
+    "it works",
+    "now works",
+    "is deployed",
+    "was deployed",
+    "is live now",
+    "fixed and verified",
+]
 
 
 def unrun_claim(cfg: dict, last: str, transcript: str | Path | None) -> str | None:
     """A reason when the message says tests pass, it works or it is deployed and this turn ran no command (no Bash call)."""
     from .gate import _asserted
 
-    words = Orders(cfg).intents.get("stop_gate", {}).get("verified_words", VERIFIED_WORDS)
-    hit = next((s.strip()[:100] for s in re.split(r"(?<=[.!?])\s+|\n", last) if any(_asserted(s.lower(), w.lower()) for w in words)), None)
+    words = (
+        Orders(cfg).intents.get("stop_gate", {}).get("verified_words", VERIFIED_WORDS)
+    )
+    hit = next(
+        (
+            s.strip()[:100]
+            for s in re.split(r"(?<=[.!?])\s+|\n", last)
+            if any(_asserted(s.lower(), w.lower()) for w in words)
+        ),
+        None,
+    )
     names = tools_this_turn(transcript)
     if not hit or names is None or "Bash" in names:
         return None
-    return (f"hubkit: your message says {hit!r} but this turn ran no command to show it. A pass, a fix or a deploy is shown by a run, not remembered. "
-            "NEXT: run the check now and quote its result, or drop the claim")
+    return (
+        f"hubkit: your message says {hit!r} but this turn ran no command to show it. A pass, a fix or a deploy is shown by a run, not remembered. "
+        "NEXT: run the check now and quote its result, or drop the claim"
+    )
 
 
 LINK_REF = re.compile(r"(?<![\w/])(?:[\w.-]+/[\w.-]+)?#\d{4,6}\b")
@@ -160,34 +226,74 @@ LINK_REF = re.compile(r"(?<![\w/])(?:[\w.-]+/[\w.-]+)?#\d{4,6}\b")
 
 def bare_refs(cfg: dict, last: str) -> list[str]:
     """PR/issue numbers like `#7457` named in the message while it holds no link at all: the user must be able to click."""
-    if not Orders(cfg).intents.get("stop_gate", {}).get("full_links", True) or "http" in last:
+    if (
+        not Orders(cfg).intents.get("stop_gate", {}).get("full_links", True)
+        or "http" in last
+    ):
         return []
     return sorted(set(LINK_REF.findall(re.sub(r"`[^`]*`", "", last))))
 
 
 # ---- a brief must not forbid the step that clears a blocker ----
 
-FORBID = re.compile(r"(?i)\b(do not|don't|dont|never|must not|mustn't|not allowed|forbidden|banned)\b")
-STOP_WORDS = {"with", "that", "this", "from", "have", "been", "when", "then", "than", "into", "does", "host", "need", "needs", "start",
-              "running", "after", "before", "about", "their", "there", "which", "would", "could", "should"}
+FORBID = re.compile(
+    r"(?i)\b(do not|don't|dont|never|must not|mustn't|not allowed|forbidden|banned)\b"
+)
+STOP_WORDS = {
+    "with",
+    "that",
+    "this",
+    "from",
+    "have",
+    "been",
+    "when",
+    "then",
+    "than",
+    "into",
+    "does",
+    "host",
+    "need",
+    "needs",
+    "start",
+    "running",
+    "after",
+    "before",
+    "about",
+    "their",
+    "there",
+    "which",
+    "would",
+    "could",
+    "should",
+}
 
 
 def _keys(text: str) -> set[str]:
-    return {w for w in re.findall(r"[a-z][a-z0-9_-]{3,}", text.lower()) if w not in STOP_WORDS}
+    return {
+        w
+        for w in re.findall(r"[a-z][a-z0-9_-]{3,}", text.lower())
+        if w not in STOP_WORDS
+    }
 
 
 def brief_forbids_fix(cfg: dict, brief: str) -> str | None:
     """The line of a brief that forbids a step an open order is blocked on (shares a key word with its blocker or fix)."""
-    blockers = [(o["id"], b) for o in Orders(cfg).live() if o["state"] == "open" and (b := o.get("blocker"))]
+    blockers = [
+        (o["id"], b)
+        for o in Orders(cfg).live()
+        if o["state"] == "open" and (b := o.get("blocker"))
+    ]
     for line in brief.splitlines():
         if not FORBID.search(line):
             continue
         for oid, b in blockers:
             shared = _keys(line) & _keys(b["on"] + " " + b["fix"])
             if shared:
-                return (f"hubkit WARNING: this brief says {line.strip()[:100]!r}, which touches what {oid} is blocked on ({b['on'][:60]}; "
-                        f"shared: {', '.join(sorted(shared)[:3])}). A brief must not forbid the one action that clears the blocker. "
-                        "NEXT: reword it, or allow that step explicitly")
+                return (
+                    f"hubkit WARNING: this brief says {line.strip()[:100]!r}, which touches what {oid} is blocked on ({b['on'][:60]}; "
+                    f"shared: {', '.join(sorted(shared)[:3])}). A brief must not forbid the one action that clears the blocker. "
+                    "NEXT: reword it, or allow that step explicitly"
+                )
     return None
 
 
@@ -212,39 +318,57 @@ def merge_warning(cfg: dict, command: str, now: float | None = None) -> str | No
         return None
     now = now or time.time()
     for o in Orders(cfg).live():
-        if o["state"] == "open" and (re.search(rf"(?<!\d){num}(?!\d)", " ".join([o["quote"], *o["refs"]])) if num else o["kind"] == "merge"):
+        if o["state"] == "open" and (
+            re.search(rf"(?<!\d){num}(?!\d)", " ".join([o["quote"], *o["refs"]]))
+            if num
+            else o["kind"] == "merge"
+        ):
             return None
     for r in recent_prompts(cfg, 7200, now):
-        if re.search(r"(?i)\bmerge", r["text"]) and (not num or re.search(rf"(?<!\d){num}(?!\d)", r["text"])):
+        if re.search(r"(?i)\bmerge", r["text"]) and (
+            not num or re.search(rf"(?<!\d){num}(?!\d)", r["text"])
+        ):
             return None
     what = f"#{num}" if num else "a PR"
-    return (f"hubkit WARNING: merging {what} with no live order and none of his typed words naming it. A merge is done on his order only. "
-            "NEXT: stop unless he ordered it; if he did, open the order: hubkit order open --kind merge --quote \"<his words>\"")
+    return (
+        f"hubkit WARNING: merging {what} with no live order and none of his typed words naming it. A merge is done on his order only. "
+        'NEXT: stop unless he ordered it; if he did, open the order: hubkit order open --kind merge --quote "<his words>"'
+    )
 
 
 # ---- warn-only checks before a tool call: posts, banned commands, stopping an agent ----
 
-POST_CMD = re.compile(r"(?i)\b(?:mep\s+(?:send|reply|post)|chat\S*\s+send|gh\s+(?:pr|issue)\s+(?:comment|review)|gh\s+api\b[^\n]*\b(?:comments|reviews)\b|slack\S*\s+(?:post|send))")
+POST_CMD = re.compile(
+    r"(?i)\b(?:mep\s+(?:send|reply|post)|chat\S*\s+send|gh\s+(?:pr|issue)\s+(?:comment|review)|gh\s+api\b[^\n]*\b(?:comments|reviews)\b|slack\S*\s+(?:post|send))"
+)
 BANNED_CMD = re.compile(
     r"(?i)(?:\brm\s+-\w*r\w*f|\brm\s+-\w*f\w*r|\bpkill\b|\bgit\s+reset\s+--hard|\bgit\s+stash\b|\bgit\s+clean\b"
     r"|\bgit\s+push\b[^\n;&|]*\s(?:--force\b|--force-with-lease\b|-f\b)|\bgit\s+checkout\s+\S+\s+--\s)"
 )
-YES_WORD = re.compile(r"(?i)\b(yes|yep|go|go ahead|send it|post it|approved?|ok|okay|do it|ship it)\b")
+YES_WORD = re.compile(
+    r"(?i)\b(yes|yep|go|go ahead|send it|post it|approved?|ok|okay|do it|ship it)\b"
+)
 STOP_WORD = re.compile(r"(?i)\b(kill|stop|cancel|abort|terminate)\b")
 
 
-def _typed_recently(cfg: dict, pattern: re.Pattern[str], seconds: float, now: float) -> bool:
+def _typed_recently(
+    cfg: dict, pattern: re.Pattern[str], seconds: float, now: float
+) -> bool:
     return any(pattern.search(r["text"]) for r in recent_prompts(cfg, seconds, now))
 
 
-def tool_warning(cfg: dict, tool: str, tool_input: dict, now: float | None = None) -> str | None:
+def tool_warning(
+    cfg: dict, tool: str, tool_input: dict, now: float | None = None
+) -> str | None:
     """A warning for one tool call, else None. Never denies. Merges, posts, banned commands and TaskStop."""
     now = now or time.time()
     if tool == "TaskStop":
         if _typed_recently(cfg, STOP_WORD, 1800, now):
             return None
-        return ("hubkit WARNING: stopping a running agent that he did not ask to stop. Its half-done work is lost. "
-                "NEXT: let it finish and harvest the result, or SendMessage it to redirect; stop it only on his word")
+        return (
+            "hubkit WARNING: stopping a running agent that he did not ask to stop. Its half-done work is lost. "
+            "NEXT: let it finish and harvest the result, or SendMessage it to redirect; stop it only on his word"
+        )
     if tool == "AskUserQuestion":
         return card_warning(tool_input)
     command = str(tool_input.get("command") or "")
@@ -257,39 +381,130 @@ def tool_warning(cfg: dict, tool: str, tool_input: dict, now: float | None = Non
     if m := BANNED_CMD.search(command):
         return f"hubkit WARNING: {m[0].strip()!r} is a banned command. NEXT: use the safe form (revert with a new commit, remove one named file, send a normal push) or ask him"
     if POST_CMD.search(command) and not _typed_recently(cfg, YES_WORD, 600, now):
-        return ("hubkit WARNING: posting to a person or a thread with no typed yes of his in the last 10 minutes. A message goes out on his word, "
-                "from the right account. NEXT: show him the draft and send on his yes")
+        return (
+            "hubkit WARNING: posting to a person or a thread with no typed yes of his in the last 10 minutes. A message goes out on his word, "
+            "from the right account. NEXT: show him the draft and send on his yes"
+        )
     return merge_warning(cfg, command, now)
 
 
 # ---- delivery: a report on built work with the work still only on this machine ----
 
-BUILT_WORDS = re.compile(r"(?i)\b(built|implemented|fixed|committed|ready|shipped|finished|completed|done)\b")
-LOCAL_OK = re.compile(r"(?i)\b(not (yet )?pushed|unpushed|local only|uncommitted|not committed|before (the )?push)\b")
+BUILT_WORDS = re.compile(
+    r"(?i)\b(built|implemented|fixed|committed|ready|shipped|finished|completed|done)\b"
+)
+LOCAL_OK = re.compile(
+    r"(?i)\b(not (yet )?pushed|unpushed|local only|uncommitted|not committed|before (the )?push)\b"
+)
 
 
-def unpushed_work(last: str, cwd: str | None) -> str | None:
-    """A reason when the message reports built work while the repo at `cwd` has uncommitted changes or commits no remote has."""
+def turn_start(transcript: str | Path | None) -> float | None:
+    """Epoch time of the last typed prompt in the transcript (when this turn began), or None when unknown."""
+    if not transcript:
+        return None
+    try:
+        lines = (
+            Path(transcript).read_text(encoding="utf-8", errors="replace").splitlines()
+        )
+    except OSError:
+        return None
+    for line in reversed(lines):
+        try:
+            o = json.loads(line)
+        except ValueError:
+            continue
+        c = (o.get("message") or {}).get("content")
+        blocks = [b for b in c if isinstance(b, dict)] if isinstance(c, list) else []
+        if (
+            o.get("type") == "user"
+            and (isinstance(c, str) or any(b.get("type") == "text" for b in blocks))
+            and (o.get("origin") or {}).get("kind", "human") == "human"
+        ):
+            try:
+                return datetime.fromisoformat(
+                    str(o["timestamp"]).replace("Z", "+00:00")
+                ).timestamp()
+            except KeyError, ValueError:
+                return None
+    return None
+
+
+def _touched_since(cwd: str, porcelain: list[str], since: float) -> list[str]:
+    """The changed files of `git status --porcelain` lines whose mtime is at or after `since` (a deleted file counts as old)."""
+    out = []
+    for ln in porcelain:
+        path = ln[3:].split(" -> ")[-1].strip().strip('"')
+        try:
+            if os.stat(Path(cwd) / path).st_mtime >= since:
+                out.append(path)
+        except OSError:
+            continue
+    return out
+
+
+def _unpushed_since(cwd: str, since: float) -> int:
+    """Unpushed commits made at or after `since`."""
+    try:
+        r = subprocess.run(
+            ["git", "-C", cwd, "log", "@{u}..HEAD", "--format=%ct"],
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=5,
+            check=False,
+        )
+    except OSError, subprocess.SubprocessError:
+        return 0
+    return sum(1 for x in r.stdout.split() if x.isdigit() and float(x) >= since)
+
+
+def unpushed_work(
+    last: str, cwd: str | None, transcript: str | Path | None = None
+) -> str | None:
+    """A reason when the message reports built work while the repo at `cwd` has changes or commits from this turn that
+    no remote has. With the turn's start known (the transcript), older dirt is not this turn's work and does not hold.
+    """
     if not cwd or not BUILT_WORDS.search(last) or LOCAL_OK.search(last):
         return None
     try:
-        r = subprocess.run(["git", "-C", cwd, "status", "--porcelain", "-b"], capture_output=True, encoding="utf-8", errors="replace", timeout=5, check=False)
-    except (OSError, subprocess.SubprocessError):
+        r = subprocess.run(
+            ["git", "-C", cwd, "status", "--porcelain", "-b"],
+            capture_output=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=5,
+            check=False,
+        )
+    except OSError, subprocess.SubprocessError:
         return None
     lines = r.stdout.splitlines()
     if r.returncode != 0 or not lines:
         return None
     dirty = [ln for ln in lines[1:] if not ln.startswith("??")]
     ahead = re.search(r"\[ahead (\d+)", lines[0])
-    if not dirty and not ahead:
+    n_ahead = int(ahead[1]) if ahead else 0
+    since = turn_start(transcript)
+    if since is not None:
+        dirty = _touched_since(cwd, dirty, since)
+        n_ahead = _unpushed_since(cwd, since) if n_ahead else 0
+    if not dirty and not n_ahead:
         return None
-    what = ", ".join([*([f"{len(dirty)} changed file(s) not committed"] if dirty else []), *([f"{ahead[1]} commit(s) not pushed"] if ahead else [])])
+    what = ", ".join(
+        [
+            *([f"{len(dirty)} changed file(s) not committed"] if dirty else []),
+            *([f"{n_ahead} commit(s) not pushed"] if n_ahead else []),
+        ]
+    )
     return f"hubkit: you report the work as built but this checkout has {what}. A report on work only on this machine is not delivery. NEXT: commit and push it (or say plainly it is local only)"
 
 
 # ---- briefs: required lines and the agent cap ----
 
-BRIEF_LINES = {"Done-when": re.compile(r"(?i)done[- ]when"), "Output": re.compile(r"(?i)\boutput\b"), "Estimate": re.compile(r"(?i)\bestimate\b")}
+BRIEF_LINES = {
+    "Done-when": re.compile(r"(?i)done[- ]when"),
+    "Output": re.compile(r"(?i)\boutput\b"),
+    "Estimate": re.compile(r"(?i)\bestimate\b"),
+}
 
 
 def brief_missing(cfg: dict, text: str) -> str | None:
@@ -299,10 +514,20 @@ def brief_missing(cfg: dict, text: str) -> str | None:
     if len(text) < int(routed.opts(cfg)["min_chars"]) or routed.ACK.match(text):
         return None
     missing = [k for k, rx in BRIEF_LINES.items() if not rx.search(text)]
-    if len(missing) == len(BRIEF_LINES) and not (routed.DELIVERABLE.search(text) or routed.DIRECTIVE.search(text) or routed.REQUEST.search(text)):
+    if len(missing) == len(BRIEF_LINES) and not (
+        routed.DELIVERABLE.search(text)
+        or routed.DIRECTIVE.search(text)
+        or routed.REQUEST.search(text)
+    ):
         return None  # not an ask
-    return (f"hubkit WARNING: this brief has no {', '.join(missing)} line. An agent without a done-when never stops, one without an output shape returns prose, "
-            "one without an estimate cannot be judged slow. NEXT: add the missing line(s) and re-send") if missing else None
+    return (
+        (
+            f"hubkit WARNING: this brief has no {', '.join(missing)} line. An agent without a done-when never stops, one without an output shape returns prose, "
+            "one without an estimate cannot be judged slow. NEXT: add the missing line(s) and re-send"
+        )
+        if missing
+        else None
+    )
 
 
 def agent_cap_warning(cfg: dict) -> str | None:
@@ -319,7 +544,9 @@ def agent_cap_warning(cfg: dict) -> str | None:
 # ---- repeating the same command, full test runs, cards without a recommendation ----
 
 
-def repeat_warning(cfg: dict, command: str, now: float, limit: int = 3, window_s: float = 600.0) -> str | None:
+def repeat_warning(
+    cfg: dict, command: str, now: float, limit: int = 3, window_s: float = 600.0
+) -> str | None:
     """A warning when the same command has run `limit` times within the window (the ledger is the state file `commands.jsonl`)."""
     p = store.state(cfg) / "commands.jsonl"
     rows = [r for r in store.read_rows(p)[0] if now - r["ts"] <= window_s][-50:]

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/scripts/hubcore/status.py

@@ -566,7 +566,9 @@ def digest(cfg: dict, span: str = "12h", now: float | None = None) -> list[str]:
     out += [f"  alert: {r.get('msg', '')}" for r in alerts[-5:]]
     out += [f"  waits on you {i['id']}: {i.get('title', '')}" for i in asks] or ["  nothing waits on you"]
     out.append(f"  still live: {len(live) - len(asks)} job(s)")
-    return out
+    from . import ledger
+
+    return out + ledger.day_lines(cfg, store.day_of(cfg, since))
 
 
 def reflection(cfg: dict, day: str) -> list[str]:
@@ -594,7 +596,9 @@ def eod(cfg: dict, day: str, note: str = "") -> Path:
     """Write and return the end-of-day review file for `day`."""
     sd = store.state(cfg)
     Orders(cfg).repair_archive()
-    body = glance(cfg, day) + [""] + reflection(cfg, day)
+    from . import ledger
+
+    body = glance(cfg, day) + [""] + ledger.day_lines(cfg, day) + [""] + reflection(cfg, day)
     if note:
         body += ["", "Self-improvement note:", "  " + learnings.clean(note)]
     out = sd / "eod" / f"eod_{day}.md"

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/tests/run_reverts.py

@@ -343,6 +343,13 @@ REVERTS = [
     ('unrun claim needs Bash', 'hubcore/lessons.py', 'if not hit or names is None or "Bash" in names:', 'if True:', 'tests/test_tool_guards.py::test_a_claim_that_tests_pass_needs_a_command_run_this_turn'),
     ('bare PR refs held', 'hubcore/lessons.py', '"http" in last:', '"http" in last or True:', 'tests/test_tool_guards.py::test_a_report_naming_a_pr_number_with_no_link_is_held'),
     ('approval on red CI held', 'hubcore/gate.py', 'if info and info.get("ci") in ("failing", "pending"):', 'if False:', 'tests/test_tool_guards.py::test_an_approval_relayed_while_ci_is_red_at_the_head_is_held'),
+    ('older dirt does not hold', 'hubcore/lessons.py', '    if since is not None:\n        dirty =', '    if False:\n        dirty =', 'tests/test_tool_guards.py::test_dirt_older_than_the_turn_does_not_hold_a_report_but_a_file_touched_in_the_turn_does'),
+    ('find searches PR files', 'hubcore/ledger.py', '" ".join(p["files"]),', '"",', 'tests/test_ledger.py::test_find_searches_pr_title_body_files_and_peer_prompts_not_only_routed_work'),
+    ('find searches peer prompts', 'hubcore/ledger.py', 'for r in peer_prompts(cfg, since):\n        check(', 'for r in []:\n        check(', 'tests/test_ledger.py::test_find_searches_pr_title_body_files_and_peer_prompts_not_only_routed_work'),
+    ('find shows gh failure', 'hubcore/ledger.py', '    if data["error"]:\n        hits.append', '    if False:\n        hits.append', 'tests/test_ledger.py::test_find_shows_a_gh_failure_instead_of_swallowing_it'),
+    ('peer prompts redacted', 'hubcore/ledger.py', '"text": redact(" ".join(text.split()))[0][:300]', '"text": " ".join(text.split())[:300]', 'tests/test_ledger.py::test_peer_prompts_are_redacted_like_state'),
+    ('eod lists PRs and peers', 'hubcore/status.py', 'glance(cfg, day) + [""] + ledger.day_lines(cfg, day)', 'glance(cfg, day)', 'tests/test_ledger.py::test_digest_and_eod_list_todays_prs_and_what_each_peer_was_asked'),
+    ('digest lists PRs and peers', 'hubcore/status.py', 'return out + ledger.day_lines(cfg, store.day_of(cfg, since))', 'return out', 'tests/test_ledger.py::test_digest_and_eod_list_todays_prs_and_what_each_peer_was_asked'),
 ]
 
 

hubkit_cli-0.2.1/tests/test_ledger.py

@@ -0,0 +1,61 @@
+"""The day's whole record: the user's PRs, peer session prompts, and one search over all of it."""
+
+import json
+import time
+
+from test_hubkit import iso
+
+SECRET = "AKIA" + "ABCDEFGHIJKLMNOP"
+
+
+def fake_gh_by_verb(env, fail=False):
+    """A gh stand-in that answers `search prs` and `pr view` differently (the one boundary the tests fake)."""
+    gh = env.root / "gh"
+    search = json.dumps([{"number": 7457, "title": "Add the helpdesk agent", "url": "https://github.com/acme/repo/pull/7457", "body": "Answers questions from the docs.", "createdAt": "x"}])
+    view = json.dumps({"files": [{"path": "api/agents/helpdesk/handlers.py"}]})
+    (env.root / "search.json").write_text(search)
+    (env.root / "view.json").write_text(view)
+    body = 'echo boom >&2; exit 1' if fail else f'case "$1" in search) cat {env.root / "search.json"};; pr) cat {env.root / "view.json"};; esac'
+    gh.write_text(f"#!/bin/sh\n{body}\n")
+    gh.chmod(0o755)
+    env.cfg.write_text(env.cfg.read_text() + f'[tools]\ngh="{gh}"\n')
+
+
+def peer_session(env, name="peer-e8", text="build the helpdesk agent for me"):
+    (env.sessions / "9991.json").write_text(json.dumps({"pid": 9991, "sessionId": "peer-sid-1", "name": name}))
+    lines = [json.dumps({"type": "user", "timestamp": iso(time.time() - 60), "message": {"content": text}})]
+    (env.transcripts / "peer-sid-1.jsonl").write_text("\n".join(lines) + "\n")
+
+
+def test_find_searches_pr_title_body_files_and_peer_prompts_not_only_routed_work(env):
+    fake_gh_by_verb(env)
+    peer_session(env)
+    env.bind()
+    out = env.run("find", "helpdesk").stdout
+    assert "[pr] #7457" in out and "[peer] peer-e8" in out
+    assert "[pr] #7457" in env.run("find", "docs").stdout  # found in the PR body
+    assert "[pr] #7457" in env.run("find", "handlers.py").stdout  # found in a changed file path
+    assert "no record holds" in env.run("find", "zebra").stdout
+
+
+def test_find_shows_a_gh_failure_instead_of_swallowing_it(env):
+    fake_gh_by_verb(env, fail=True)
+    env.bind()
+    out = env.run("find", "anything").stdout
+    assert "UNKNOWN" in out and "gh search failed" in out
+
+
+def test_peer_prompts_are_redacted_like_state(env):
+    fake_gh_by_verb(env)
+    peer_session(env, text=f"use the key {SECRET} to build the helpdesk agent")
+    env.bind()
+    for out in (env.run("find", "use the key").stdout, env.run("digest", "--since", "12h").stdout):
+        assert "use the key" in out and SECRET not in out
+
+
+def test_digest_and_eod_list_todays_prs_and_what_each_peer_was_asked(env):
+    fake_gh_by_verb(env)
+    peer_session(env)
+    env.bind()
+    for out in (env.run("digest", "--since", "12h").stdout, env.run("eod").stdout):
+        assert "#7457 Add the helpdesk agent" in out and "peer-e8: build the helpdesk agent" in out

{hubkit_cli-0.2.0 → hubkit_cli-0.2.1}/tests/test_tool_guards.py

@@ -133,3 +133,28 @@ def test_an_approval_relayed_while_ci_is_red_at_the_head_is_held(env):
     data["statusCheckRollup"] = [{"conclusion": "SUCCESS"}]
     (env.root / "gh.json").write_text(json.dumps(data))
     assert stop(env, last_assistant_message="#101 is approved.") is None
+
+
+def test_dirt_older_than_the_turn_does_not_hold_a_report_but_a_file_touched_in_the_turn_does(env, tmp_path):
+    import os
+    import subprocess
+    import time
+
+    env_git = {"GIT_AUTHOR_NAME": "t", "GIT_AUTHOR_EMAIL": "t@t", "GIT_COMMITTER_NAME": "t", "GIT_COMMITTER_EMAIL": "t@t", "PATH": "/usr/bin:/bin:/usr/local/bin"}
+    work = tmp_path / "work"
+    work.mkdir()
+    for a in (["init", "-b", "main"], ):
+        subprocess.run(["git", *a], cwd=work, check=True, capture_output=True, env=env_git)
+    (work / "old.txt").write_text("one\n")
+    subprocess.run(["git", "add", "old.txt"], cwd=work, check=True, capture_output=True, env=env_git)
+    subprocess.run(["git", "commit", "-m", "one"], cwd=work, check=True, capture_output=True, env=env_git)
+    (work / "old.txt").write_text("two\n")
+    long_ago = time.time() - 7200
+    os.utime(work / "old.txt", (long_ago, long_ago))
+    env.bind()
+    msg = {"last_assistant_message": "The role change is built and ready.", "cwd": str(work)}
+    assert stop(env, transcript_path=transcript(env, ["Read"]), **msg) is None  # dirt from before the turn
+    (work / "new.txt").write_text("x\n")
+    subprocess.run(["git", "add", "new.txt"], cwd=work, check=True, capture_output=True, env=env_git)
+    held = stop(env, transcript_path=transcript(env, ["Read"]), **msg)
+    assert held and "1 changed file(s) not committed" in held["reason"]