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

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

@@ -4,6 +4,19 @@ All notable changes to this project are recorded here. The format follows [Keep
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-11-06
+
+### Fixed
+- A fix job whose change verb and PR number are in different sentences ("Fix the gaps. ... PR #7") is still recognised as a fix job, so its owner pushing to the PR is not counted as a stalled or moved head.
+
+## [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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hubkit-cli
-Version: 0.2.0
+Version: 0.2.2
 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.2}/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.2}/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.2}/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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hubkit-cli"
-version = "0.2.0"
+version = "0.2.2"
 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.2}/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.2}/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.2/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}"]