@tiens.nguyen/gu-cli 1.0.832 → 1.0.833

package/gonext_agent_chat.py

@@ -8024,7 +8024,9 @@ def _run_command_prompt_line(shell, windows=None):
             "interactive input() CLI fails with EOFError. A server or GUI app is left RUNNING — "
             "stop_server closes it. " + _BG_LINE)
     return (
-        "    run_command IS A SHELL (bash): pipes, redirects, `;`, `||`, `$( )`, globs and heredocs "
+        "    run_command IS A SHELL (bash), and it KEEPS its folder and exported variables from one "
+        "call to the next in this turn (`cd sub`, then `npm test` runs in sub; an explicit workdir "
+        "wins). Pipes, redirects, `;`, `||`, `$( )`, globs and heredocs "
         "work, so put a whole sequence in ONE call — dependent steps with &&, independent ones with "
         "`;` (e.g. `cd app && npm test 2>&1 | tail -40`); a multi-line command goes in a "
         "triple-quoted string.\n"
@@ -8037,6 +8039,13 @@ def _run_command_prompt_line(shell, windows=None):
         "    GITHUB: use `gh`. Multi-line text goes as a heredoc on stdin — "
         "`gh issue comment 12 --body-file - <<'EOF'` … `EOF` (same for gh issue create / gh pr "
         "create) — never write a body file first, and do not run `gh auth status` first.\n"
+        # #362: how Claude Code checks work — scripts as heredocs, the one function not the app,
+        # cheapest check first, and never a pipe between a test run and the decision it feeds.
+        "    CHECKS: a Python/Node script goes as a heredoc — `python3 - <<'EOF'` … `EOF` (node: "
+        "`node --input-type=module - <<'EOF'`) — never `python3 -c` built from joined strings. To "
+        "check one function, load its module and call it with real input instead of running the "
+        "app. Order: syntax check → the ONE test → the suite once. Test output arrives with a TEST "
+        "SUMMARY of each failure first, so never pipe it into tail/grep (a pipe hides the exit code).\n"
         "    Read and search FILES with read_file_lines / grep_repo, not cat/grep/sed. `sudo`/`su` "
         "are blocked; piping into sh/python and writing or deleting outside the project ask the "
         "user first; an interactive input() CLI fails with EOFError. A server or GUI app is left "
@@ -8156,9 +8165,28 @@ def _test_commands_line(root: str) -> str:
     cmds = _project_test_commands(root) if root else []
     if not cmds:
         return ""
-    return ("  TEST COMMANDS, from this project's own manifests — use these, never guess a runner "
+    line = ("  TEST COMMANDS, from this project's own manifests — use these, never guess a runner "
             "(a missing pytest fails silently behind a pipe): "
             + "; ".join(f"{d} → {c}" for d, c in cmds) + "\n")
+    try:
+        import gu_test_digest as _td
+        forms = _td.one_test_forms(c for _, c in cmds)
+    except Exception:  # noqa: BLE001
+        forms = []
+    if forms:
+        # #362: check a fix with ONE test (seconds), run the suite once at the end.
+        line += ("  ONE TEST while fixing (the suite once at the end): " + " · ".join(forms) + "\n")
+    return line
+
+
+def _test_digest(output: str, cwd: str = "") -> str:
+    """gu_test_digest.digest, or "" if the module is missing — a summary must never fail a command."""
+    try:
+        import gu_test_digest as _td
+        return _td.digest(output or "", cwd or "")
+    except Exception as e:  # noqa: BLE001
+        _log(f"test digest skip: {e}")
+        return ""
 
 
 # bash's words for a line whose quotes do not pair up.
@@ -9051,10 +9079,10 @@ def _ws_cap_servers(max_live: int = 3) -> list:
 # running" link and the Shell details view (shell-details.mjs).
 #
 # THE EXIT CODE OUTLIVES THE AGENT. The agent is one process per turn; a build that ends after the
-# turn has no parent left to wait() on it. So a shell line runs as `"$0" -c "$1"; rc=$?; echo $rc
-# > "$2"; exit $rc` — the command text untouched, its exit code written to `exit_file` AND passed
-# on (without the `exit $rc` every failure read as EXITED 0). The argv-only path (Windows)
-# has no such wrapper and says "exit code unknown" instead of guessing.
+# turn has no parent left to wait() on it. So a shell line runs as `eval "$1"` under an EXIT trap
+# that writes its exit code to `exit_file` AND exits with it (without that every failure read as
+# EXITED 0) — see _run_state_wrapper, which also keeps the folder and exports for the next call.
+# The argv-only path has no such wrapper and says "exit code unknown" instead of guessing.
 _SHELLS_KEEP = 20            # newest records kept, running or not
 _SHELLS_KEEP_DONE_S = 86400  # a finished shell is listed for a day
 
@@ -9301,6 +9329,77 @@ def _shells_context_line(shells: list, now=None) -> str:
             + ". Read one with shell_output(<id>); stop one with stop_server(<id>).\n")
 
 
+# THE SHELL KEEPS ITS FOLDER AND EXPORTS BETWEEN CALLS (#362), the way Claude Code's Bash tool does.
+# Every run_command was a fresh bash, so `cd tools/x` or `source .venv/bin/activate` lasted one call
+# and every line started `cd … &&`. Not a long-lived pty (a hung one would wedge the turn): each
+# line runs in the outer shell via `eval`, and an EXIT trap — which also fires on `exit 3` — saves
+# `export -p` and `pwd` to this turn's state file; the next call sources it and starts in that
+# folder. One turn only: the file is removed when the agent exits. An explicit workdir wins.
+_RUN_STATE = {"path": ""}
+# Builtins that change the shell itself. As argv they run nothing (`export` is no program; macOS's
+# /usr/bin/cd exits 0 having changed nothing) — with a shell, a line using one goes to bash.
+_SHELL_STATE_BUILTINS = {"cd", "export", "source", ".", "set", "unset", "alias", "unalias", "pushd",
+                         "popd", "umask", "shopt", "declare", "typeset", "readonly", "trap", "ulimit",
+                         "hash", "eval"}
+_RUN_STATE_SKIP = r"^declare -x (PWD|OLDPWD|SHLVL|_)="
+
+
+def _run_state_path() -> str:
+    import atexit
+    import time as _t
+    if not _RUN_STATE["path"]:
+        d = os.path.join(os.path.expanduser("~"), ".gonext", "run-state")
+        os.makedirs(d, exist_ok=True)
+        # A background shell that ends after its turn rewrites its file; sweep day-old ones.
+        try:
+            for n in os.listdir(d):
+                fp = os.path.join(d, n)
+                if _t.time() - os.path.getmtime(fp) > 86400:
+                    os.remove(fp)
+        except OSError:
+            pass
+        _RUN_STATE["path"] = os.path.join(d, f"{os.getpid()}.sh")
+
+        def _clean(base=_RUN_STATE["path"]):
+            for ext in ("", ".cwd", ".tmp"):
+                try:
+                    os.remove(base + ext)
+                except OSError:
+                    pass
+        atexit.register(_clean)
+    return _RUN_STATE["path"]
+
+
+def _run_state_cwd() -> str:
+    """The folder the last shell line ended in, this turn — or ""."""
+    p = _RUN_STATE["path"]
+    if not p:
+        return ""
+    try:
+        with open(p + ".cwd", encoding="utf-8") as fh:
+            return fh.read().strip()
+    except OSError:
+        return ""
+
+
+def _run_state_set_cwd(cwd: str) -> None:
+    """Record the folder an && chain ended in — the chain runs its `cd` itself, not in bash."""
+    try:
+        with open(_run_state_path() + ".cwd", "w", encoding="utf-8") as fh:
+            fh.write(cwd)
+    except OSError:
+        pass
+
+
+def _run_state_wrapper() -> str:
+    """The outer script: $1 the line, $2 the exit file, $3 the state file."""
+    return ('[ -f "$3" ] && . "$3" >/dev/null 2>&1; '
+            "trap '__gu_rc=$?; echo $__gu_rc > \"$2\"; "
+            f"export -p | grep -vE \"{_RUN_STATE_SKIP}\" > \"$3.tmp\" 2>/dev/null && mv -f \"$3.tmp\" \"$3\"; "
+            "pwd > \"$3.cwd\"; exit $__gu_rc' EXIT; "
+            'eval "$1"')
+
+
 def _ws_scrubbed_env() -> dict:
     """Minimal child env for run_command. The worker process env holds secrets
     (GONEXT_WORKER_KEY etc. via worker.env) — a repo's test script must NEVER see
@@ -14684,6 +14783,14 @@ def run_agent_chat(cfg):
                             if os.path.isdir(os.path.join(_active, _stripped)):
                                 _wd_in = _stripped
                 wd = _rag_read_allowed(_wd_in or _default_ws_root())
+                _wd_before = wd
+                if not _wd_in and _run_shell_bin():
+                    _kept = _run_state_cwd()
+                    if _kept and os.path.isdir(_kept):
+                        try:
+                            wd = _rag_read_allowed(_kept)
+                        except Exception:  # noqa: BLE001 — left the allowed folders: start over
+                            wd = _wd_before
                 w = _ws_for_path(wd)
                 if w is None or not w.get("allowRun"):
                     # Contextual nudge (task #102): the #1 reason the model shells out here is
@@ -14707,7 +14814,12 @@ def run_agent_chat(cfg):
                            + (_HEREDOC_HINT if "quote" in str(_scan["error"]) else ""))
                     _last_obs["text"] = msg
                     return msg
-                _use_shell = bool(_scan) and _shell_needed(_scan)
+                # Once this turn has shell state (a cd, an activated venv), every line goes through
+                # the shell so it starts from that state — not only lines with shell syntax.
+                _words = [c["argv"][0] for c in _shell_commands(_scan["tokens"]) if c["argv"]] if _scan else []
+                _builtin = sorted({w for w in _words if w in _SHELL_STATE_BUILTINS})
+                _use_shell = bool(_scan) and (_shell_needed(_scan) or bool(_builtin) or bool(
+                    _RUN_STATE["path"] and os.path.exists(_RUN_STATE["path"])))
                 _bg_err = _shell_background_error(_scan) if _use_shell else None
                 if _bg_err:
                     _last_obs["text"] = _bg_err
@@ -14720,7 +14832,10 @@ def run_agent_chat(cfg):
                 # AN `&&` CHAIN IS ONE STEP (task #274): each part runs through THIS function —
                 # allowlist, risk gate, approval, server detection, all of it — in order, and
                 # the first failure stops the rest. `cd DIR` sets the folder for what follows.
-                _chain = _and_chain_parts(command)
+                # A chain runs each part as a program; `export`/`source` in it would run nothing,
+                # so with a shell such a line goes to bash whole. (`cd` the chain does itself.)
+                _chain = None if (_use_shell and [b for b in _builtin if b != "cd"]) \
+                    else _and_chain_parts(command)
                 if _chain:
                     _chain_start = _t.time()
                     _cur_wd = wd
@@ -14764,6 +14879,10 @@ def run_agent_chat(cfg):
                                 + (": " + " && ".join(_rest) if _rest else "")
                                 if _stopped else f"CHAIN DONE — all {len(_chain)} parts ran")
                     result = _summary + "\n" + "\n".join(_outs)
+                    if _shell_bin and _cur_wd != wd:
+                        _run_state_set_cwd(_cur_wd)  # the next call starts where the chain ended
+                        result += (f"\n(the shell is now in {_cur_wd} — the next run_command "
+                                   "without a workdir starts there)")
                     _last_obs["text"] = result
                     return result
                 # REFUSE SHELL SYNTAX BEFORE SPAWNING (task #204). Without this, `cd X && Y`
@@ -14884,12 +15003,13 @@ def run_agent_chat(cfg):
                 if _use_shell:
                     _cmd_text, _attrib_note = _with_attribution_text(
                         command, _scan, _attribution_settings(wd))
-                    # The exit code is written to a file so it outlives this turn's process —
-                    # the line itself runs untouched as $1 (see BACKGROUND SHELLS).
+                    # The exit code is written to a file so it outlives this turn's process, and
+                    # the folder + exports are kept for the next call — the line itself runs
+                    # untouched as $1 (see BACKGROUND SHELLS, _run_state_wrapper).
                     # Git Bash reads C:/x, not C:\x, inside the line it runs.
                     _fs = (lambda x: x.replace("\\", "/")) if _IS_WINDOWS else (lambda x: x)
-                    argv = [_shell_bin, "-c", '"$0" -c "$1"; rc=$?; echo $rc > "$2"; exit $rc',
-                            _fs(_shell_bin), _cmd_text, _fs(exit_path)]
+                    argv = [_shell_bin, "-c", _run_state_wrapper(),
+                            _fs(_shell_bin), _cmd_text, _fs(exit_path), _fs(_run_state_path())]
                 else:
                     argv, _attrib_note = _with_attribution(argv, _attribution_settings(wd))
                 if _attrib_note:
@@ -14939,7 +15059,11 @@ def run_agent_chat(cfg):
                 while True:
                     rc = proc.poll()
                     if rc is not None:
-                        out = _ws_distill_output(_read_log())
+                        _raw = _read_log()
+                        out = _ws_distill_output(_raw)
+                        # The result FIRST (#362): counts and each failure with file:line, read
+                        # from the WHOLE output — the observation below is capped, this is not.
+                        _digest = _test_digest(_raw, wd)
                         # Task #90 Phase 1 — truthful perception: never claim success the
                         # tool didn't observe. exit 0 is a FACT about the process, not
                         # proof of the GOAL (e.g. `npm start` exits 0 when its port is
@@ -14962,7 +15086,7 @@ def run_agent_chat(cfg):
                         # what `cd X && Y` used to do — and the model read the silence as a
                         # clean pass. An absence cannot be reasoned about; a stated fact can.
                         result = (
-                            f"{status}\n{out}" if out.strip()
+                            f"{status}\n" + (f"{_digest}\n\n" if _digest else "") + out if out.strip()
                             else f"{status}\nNO OUTPUT: the command printed nothing on stdout or "
                                  "stderr. If you expected output, it probably did not do what "
                                  "you intended — check the command before repeating it."
@@ -14982,6 +15106,11 @@ def run_agent_chat(cfg):
                                    f"Command failed behind a pipe → {_trim_words(_hidden)}"})
                         if rc != 0 and _use_shell and _SHELL_QUOTE_ERR_RE.search(out or ""):
                             result += _HEREDOC_HINT
+                        # Say where the shell now is, so a next `cd sub` is not done twice (#362).
+                        _now = _run_state_cwd() if _use_shell else ""
+                        if _now and os.path.realpath(_now) != os.path.realpath(wd):
+                            result += (f"\n(the shell is now in {_now} — the next run_command "
+                                       "without a workdir starts there)")
                         if rc != 0 and _WS_PERM_ERR_RE.search(out or ""):
                             _f = _ws_access_facts()
                             result = f"{result}\n\n{_ws_access_report(_f, _ws_paths_in(command))}"
@@ -15197,6 +15326,14 @@ def run_agent_chat(cfg):
                 if st["state"] == "exited":
                     head += ("\nexit 0 alone does NOT prove the intended effect happened — check "
                              "the output and VERIFY.")
+                if st["state"] != "running":
+                    try:
+                        with open(sh.get("log") or "", encoding="utf-8", errors="replace") as fh:
+                            _dg = _test_digest(fh.read(), str(sh.get("workdir") or ""))
+                    except OSError:
+                        _dg = ""
+                    if _dg:
+                        head += "\n" + _dg
                 tail_note = ""
                 if not new.strip() and int(sh.get("read_offset") or 0) == 0:
                     lf = _shell_log_file(str(sh.get("command") or ""), str(sh.get("workdir") or ""))

package/gu_test_digest.py

@@ -0,0 +1,352 @@
+"""Test-result digest for run_command (task #362, GitHub #142) — PURE.
+
+THE MODEL READ TEST OUTPUT THROUGH `| tail` AND `| grep`. Measured 2026-09-23 → 10-14 in local
+Mongo: 84 of 397 turns ran tests, 32 of them spent 4+ steps doing it, and test output was piped
+into tail/head/grep to find the result — the pipe that hid `No module named pytest` and let a
+commit go in untested (#140 review). The answer is not a smaller window onto the output; it is
+the result first: the counts, then each failing test with its message and file:line, computed
+from the WHOLE output (the observation itself is capped, a digest never is).
+
+One parser per runner, each recognising its own summary line, so a line that runs two runners
+(`python3 -m unittest … && node --test`, this repo's npm test) gets both. Nothing recognised →
+"" and the output is shown exactly as before. Names are the ones the runner prints, which are the
+ones its run-one-test form takes (unittest's dotted id, pytest's node id, go's TestName…).
+"""
+from __future__ import annotations
+
+import os
+import re
+
+MAX_FAILURES = 10      # per runner; the rest are counted
+MAX_MESSAGE = 220      # chars of one failure's message
+
+
+def _clip(text: str, n: int = MAX_MESSAGE) -> str:
+    # Line breaks become one space; runs of spaces INSIDE a line stay — 'GU  AGENT' vs 'GU AGENT'
+    # is the whole failure, and collapsing it printed two identical strings.
+    text = re.sub(r"[ \t]*\n[ \t]*", " ", (text or "").strip())
+    return text if len(text) <= n else text[: n - 1] + "…"
+
+
+def _rel(path: str, cwd: str) -> str:
+    path = (path or "").strip().strip("'\"")
+    if path.startswith("file://"):
+        path = path[7:]
+    if cwd:
+        for base in {cwd, os.path.realpath(cwd)}:
+            if base and path.startswith(base.rstrip("/") + "/"):
+                return path[len(base.rstrip("/")) + 1:]
+    return path
+
+
+def _fail(name, message="", where="") -> dict:
+    return {"name": _clip(name, 160), "message": _clip(message), "where": where}
+
+
+# ---- node --test, spec reporter (the default) ---------------------------------------------------
+_NODE_SPEC_SUM = re.compile(r"^ℹ (tests|pass|fail|skipped|todo|cancelled) (\d+)\s*$", re.M)
+
+
+def _node_spec(out: str, cwd: str):
+    counts = {}
+    for k, v in _NODE_SPEC_SUM.findall(out):
+        counts[k] = counts.get(k, 0) + int(v)
+    if "tests" not in counts:
+        return None
+    fails = []
+    block = out.split("✖ failing tests:", 1)
+    if len(block) == 2:
+        # "test at FILE:L:C" / "✖ name (ms)" / indented message lines, until the next "test at".
+        for m in re.finditer(r"^test at (\S+?):(\d+):\d+\n✖ (.+?) \([\d.]+m?s\)[^\n]*\n((?:[ \t].*\n?|\n)*)",
+                             block[1], re.M):
+            body = [ln.strip() for ln in m.group(4).splitlines()]
+            msg = []
+            for ln in body:
+                if ln.startswith("at ") or ln.startswith("{") or ln.startswith("generatedMessage"):
+                    break
+                if ln and ln not in ("+ actual - expected", "^"):
+                    msg.append(ln)
+            text = " ".join(msg[:5])
+            if text.strip("'\"") == "test failed":
+                # A FILE that failed to load: the runner only says 'test failed'; the cause
+                # (ERR_MODULE_NOT_FOUND, a SyntaxError) was printed above the summary.
+                err = re.search(r"^(\w*Error\b[^\n]*)$", out, re.M)
+                text = _rel_in(err.group(1), cwd) if err else text
+            fails.append(_fail(m.group(3), text, f"{_rel(m.group(1), cwd)}:{m.group(2)}"))
+    else:
+        # A file that crashed before any test ran: "✖ tests/c.test.mjs (78ms)", the error above it.
+        err = re.search(r"^(\w*Error\b[^\n]*)$", out, re.M)
+        for m in re.finditer(r"^✖ (.+?) \([\d.]+m?s\)", out, re.M):
+            fails.append(_fail(m.group(1), _rel_in(err.group(1), cwd) if err else ""))
+    return {"runner": "node --test", "passed": counts.get("pass", 0), "failed": counts.get("fail", 0),
+            "skipped": counts.get("skipped", 0) + counts.get("todo", 0), "errors": counts.get("cancelled", 0),
+            "failures": fails}
+
+
+def _rel_in(text: str, cwd: str) -> str:
+    """Absolute paths under cwd inside a message, shortened."""
+    if not cwd:
+        return text
+    for base in {cwd.rstrip("/"), os.path.realpath(cwd).rstrip("/")}:
+        text = text.replace("file://" + base + "/", "").replace(base + "/", "")
+    return text
+
+
+# ---- node --test / anything TAP ------------------------------------------------------------------
+_TAP_SUM = re.compile(r"^# (tests|pass|fail|skipped|todo|cancelled) (\d+)\s*$", re.M)
+
+
+def _tap(out: str, cwd: str):
+    counts = {}
+    for k, v in _TAP_SUM.findall(out):
+        counts[k] = counts.get(k, 0) + int(v)
+    if "tests" not in counts or "TAP version" not in out and "# Subtest" not in out:
+        return None
+    fails = []
+    for m in re.finditer(r"^[ \t]*not ok \d+ - (.+?)(?: # .*)?\n((?:[ \t]{2,}.*\n?|[ \t]*\n)*)", out, re.M):
+        yaml = m.group(2)
+        loc = re.search(r"location: '([^']+?):(\d+):\d+'", yaml)
+        err = re.search(r"error: \|-?\n((?:[ \t]{4,}.*\n?|[ \t]*\n)+)", yaml) or re.search(r"error: '([^']*)'", yaml)
+        msg = ""
+        if err:
+            msg = " ".join(ln.strip() for ln in err.group(1).splitlines()
+                           if ln.strip() and ln.strip() not in ("+ actual - expected", "^"))
+        fails.append(_fail(m.group(1), msg, f"{_rel(loc.group(1), cwd)}:{loc.group(2)}" if loc else ""))
+    return {"runner": "node --test (TAP)", "passed": counts.get("pass", 0), "failed": counts.get("fail", 0),
+            "skipped": counts.get("skipped", 0) + counts.get("todo", 0), "errors": counts.get("cancelled", 0),
+            "failures": fails}
+
+
+# ---- python unittest ------------------------------------------------------------------------------
+def _unittest(out: str, cwd: str):
+    ran = re.findall(r"^Ran (\d+) tests? in [\d.]+s\s*$", out, re.M)
+    if not ran:
+        return None
+    total = sum(int(x) for x in ran)
+    failures = errors = skipped = 0
+    for line in re.findall(r"^(?:OK|FAILED)(?: \((.*)\))?\s*$", out, re.M):
+        for k, v in re.findall(r"(\w[\w ]*?)=(\d+)", line or ""):
+            k = k.strip()
+            if k == "failures":
+                failures += int(v)
+            elif k == "errors":
+                errors += int(v)
+            elif k == "skipped":
+                skipped += int(v)
+    fails = []
+    for m in re.finditer(r"^(FAIL|ERROR): (\S+) \((\S+?)\)[^\n]*\n-{20,}\n(.*?)(?=^={20,}|^-{20,}\nRan |\Z)",
+                         out, re.M | re.S):
+        kind, short, dotted, body = m.groups()
+        lines = [ln for ln in body.rstrip().splitlines() if ln.strip()]
+        msg = lines[-1].strip() if lines else kind
+        locs = [(f, ln) for f, ln in re.findall(r'File "([^"]+)", line (\d+)', body)
+                if "/lib/python" not in f and "unittest/" not in f]
+        where = f"{_rel(locs[-1][0], cwd)}:{locs[-1][1]}" if locs else ""
+        fails.append(_fail(dotted if "." in dotted else short, msg, where))
+    return {"runner": "unittest", "passed": max(0, total - failures - errors - skipped), "failed": failures,
+            "skipped": skipped, "errors": errors, "failures": fails}
+
+
+# ---- pytest ---------------------------------------------------------------------------------------
+_PYTEST_SUM = re.compile(r"^=+ ((?:\d+ \w+(?:, )?)+) in [\d.]+s(?: \([^)]*\))? =+\s*$", re.M)
+
+
+def _pytest(out: str, cwd: str):
+    sums = _PYTEST_SUM.findall(out)
+    if not sums:
+        return None
+    c = {}
+    for k_v in ", ".join(sums).split(", "):
+        m = re.match(r"(\d+) (\w+)", k_v.strip())
+        if m:
+            c[m.group(2)] = c.get(m.group(2), 0) + int(m.group(1))
+    fails = []
+    for m in re.finditer(r"^(FAILED|ERROR) (\S+?)(?: - (.*))?$", out, re.M):
+        nodeid = m.group(2)
+        loc = re.search(rf"^({re.escape(nodeid.split('::')[0])}):(\d+): ", out, re.M)
+        fails.append(_fail(nodeid, m.group(3) or m.group(1), f"{loc.group(1)}:{loc.group(2)}" if loc else ""))
+    return {"runner": "pytest", "passed": c.get("passed", 0), "failed": c.get("failed", 0),
+            "skipped": c.get("skipped", 0) + c.get("xfailed", 0), "errors": c.get("error", 0) + c.get("errors", 0),
+            "failures": fails}
+
+
+# ---- jest / vitest --------------------------------------------------------------------------------
+def _jest(out: str, cwd: str):
+    m = re.search(r"^Tests:\s+(.*\d+ total)\s*$", out, re.M)
+    if not m:
+        return None
+    c = {k: int(v) for v, k in re.findall(r"(\d+) (\w+)", m.group(1))}
+    fails = []
+    for f in re.finditer(r"^\s*● (.+?)\n\n((?:.*\n){1,6})", out, re.M):
+        if f.group(1).startswith("Console"):
+            continue
+        msg = next((ln.strip() for ln in f.group(2).splitlines() if ln.strip()), "")
+        loc = re.search(r"\(([^()\s]+?):(\d+):\d+\)", f.group(2)) or re.search(r"at .*?([\w./-]+\.\w+):(\d+):\d+", out)
+        fails.append(_fail(f.group(1).replace(" › ", " > "), msg, f"{_rel(loc.group(1), cwd)}:{loc.group(2)}" if loc else ""))
+    return {"runner": "jest", "passed": c.get("passed", 0), "failed": c.get("failed", 0),
+            "skipped": c.get("skipped", 0) + c.get("todo", 0), "errors": 0, "failures": fails}
+
+
+def _vitest(out: str, cwd: str):
+    m = re.search(r"^\s*Tests\s+(.*?)\s*\((\d+)\)\s*$", out, re.M)
+    if not m or "|" not in m.group(1) and not re.search(r"\d+ (passed|failed)", m.group(1)):
+        return None
+    c = {k: int(v) for v, k in re.findall(r"(\d+) (\w+)", m.group(1))}
+    fails = []
+    for f in re.finditer(r"^[ \t]*FAIL[ \t]+(\S+) > (.+?)\n((?:.*\n){0,4})", out, re.M):
+        msg = next((ln.strip() for ln in f.group(3).splitlines() if re.search(r"Error|expected", ln)), "")
+        loc = re.search(r"❯ (\S+?):(\d+):\d+", f.group(3))
+        fails.append(_fail(f"{f.group(1)} > {f.group(2).strip()}", msg,
+                           f"{loc.group(1)}:{loc.group(2)}" if loc else f.group(1)))
+    if not fails:  # no "Failed Tests" section (a reporter without it): the × lines
+        for f in re.finditer(r"^[ \t]*× (.+?)(?:[ \t]+\d+ms)?\n[ \t]*→ (.*)$", out, re.M):
+            fails.append(_fail(f.group(1), f.group(2)))
+    return {"runner": "vitest", "passed": c.get("passed", 0), "failed": c.get("failed", 0),
+            "skipped": c.get("skipped", 0) + c.get("todo", 0), "errors": 0, "failures": fails}
+
+
+# ---- go test ---------------------------------------------------------------------------------------
+def _gotest(out: str, cwd: str):
+    pkgs = re.findall(r"^(ok|FAIL|---? FAIL)\s+(\S+)\s+(?:[\d.]+s|\(cached\)|\[)", out, re.M)
+    fails_raw = list(re.finditer(r"^[ \t]*--- FAIL: (\S+) \([\d.]+s\)", out, re.M))
+    if not pkgs and not fails_raw:
+        return None
+    passed = len(re.findall(r"^\s*--- PASS: ", out, re.M))
+    skipped = len(re.findall(r"^\s*--- SKIP: ", out, re.M))
+    fails = []
+    for f in fails_raw:
+        # Since Go 1.14 a test's t.Error lines are printed between its "=== RUN" and "--- FAIL".
+        run = re.search(rf"^=== RUN\s+{re.escape(f.group(1))}\n((?:[ \t]{{4,}}.*\n)*)", out, re.M)
+        first = next((ln.strip() for ln in (run.group(1) if run else "").splitlines() if ln.strip()), "")
+        loc = re.match(r"([\w./-]+\.go):(\d+): (.*)", first)
+        fails.append(_fail(f.group(1), loc.group(3) if loc else first, f"{loc.group(1)}:{loc.group(2)}" if loc else ""))
+    ok_pkgs = sum(1 for k, _ in pkgs if k == "ok")
+    bad_pkgs = sum(1 for k, _ in pkgs if k == "FAIL")
+    return {"runner": "go test", "passed": passed, "failed": len(fails_raw) or bad_pkgs, "skipped": skipped,
+            "errors": 0, "failures": fails,
+            "note": f"{ok_pkgs} package(s) ok, {bad_pkgs} FAIL" if pkgs else ""}
+
+
+# ---- cargo test ------------------------------------------------------------------------------------
+def _cargo(out: str, cwd: str):
+    res = re.findall(r"^test result: (?:ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored", out, re.M)
+    if not res:
+        return None
+    p = sum(int(a) for a, _, _ in res)
+    f = sum(int(b) for _, b, _ in res)
+    s = sum(int(c) for _, _, c in res)
+    fails = []
+    for m in re.finditer(r"^---- (\S+) stdout ----\n((?:.*\n){1,4})", out, re.M):
+        body = m.group(2)
+        loc = re.search(r"panicked at ([^\s:]+):(\d+):\d+", body)
+        msg = [ln.strip() for ln in body.splitlines() if ln.strip() and "panicked at" not in ln]
+        fails.append(_fail(m.group(1), msg[0] if msg else "panicked", f"{loc.group(1)}:{loc.group(2)}" if loc else ""))
+    return {"runner": "cargo test", "passed": p, "failed": f, "skipped": s, "errors": 0, "failures": fails}
+
+
+# ---- tsc / eslint (checks, not tests — same shape: count, then the first problems) ----------------
+def _tsc(out: str, cwd: str):
+    errs = re.findall(r"^(.+?)\((\d+),\d+\): error (TS\d+): (.+)$", out, re.M)
+    if not errs:
+        return None
+    fails = [_fail(code, msg, f"{_rel(f, cwd)}:{ln}") for f, ln, code, msg in errs]
+    return {"runner": "tsc", "check": True, "errors": len(errs),
+            "files": len({e[0] for e in errs}), "failures": fails}
+
+
+def _eslint(out: str, cwd: str):
+    m = re.search(r"^✖ (\d+) problems? \((\d+) errors?, (\d+) warnings?\)", out, re.M)
+    if not m:
+        return None
+    fails, cur = [], ""
+    for ln in out.splitlines():
+        if ln and not ln.startswith(" ") and not ln.startswith("✖"):
+            cur = _rel(ln.strip(), cwd)
+            continue
+        e = re.match(r"^\s+(\d+):\d+\s+error\s+(.+?)\s{2,}(\S+)\s*$", ln)
+        if e and cur:
+            fails.append(_fail(e.group(3), e.group(2), f"{cur}:{e.group(1)}"))
+    return {"runner": "eslint", "check": True, "errors": int(m.group(2)), "warnings": int(m.group(3)),
+            "failures": fails}
+
+
+_PARSERS = (_unittest, _pytest, _node_spec, _tap, _jest, _vitest, _gotest, _cargo, _tsc, _eslint)
+
+
+def parse(output: str, cwd: str = "") -> list[dict]:
+    """Every runner whose summary appears in `output`, in that order. Never raises."""
+    found = []
+    for p in _PARSERS:
+        try:
+            r = p(output or "", cwd)
+        except Exception:  # noqa: BLE001 — a digest must never break a command result
+            r = None
+        if r:
+            found.append(r)
+    return found
+
+
+def _counts(r: dict) -> str:
+    if r.get("check"):
+        bits = [f"{r['errors']} error{'s' if r['errors'] != 1 else ''}"]
+        if r.get("warnings"):
+            bits.append(f"{r['warnings']} warning{'s' if r['warnings'] != 1 else ''}")
+        return " · ".join(bits)
+    bits = [f"{r['passed']} passed"]
+    if r["failed"]:
+        bits.append(f"{r['failed']} failed")
+    if r.get("errors"):
+        bits.append(f"{r['errors']} error{'s' if r['errors'] != 1 else ''}")
+    if r.get("skipped"):
+        bits.append(f"{r['skipped']} skipped")
+    if r.get("note"):
+        bits.append(r["note"])
+    return " · ".join(bits)
+
+
+def digest(output: str, cwd: str = "") -> str:
+    """The block run_command puts ABOVE the output: counts per runner, then each failure as
+    `✗ name — message (file:line)`. "" when no runner was recognised."""
+    runs = parse(output, cwd)
+    if not runs:
+        return ""
+    bad = [r for r in runs if r.get("failed") or r.get("errors") or r.get("failures")]
+    if not bad:
+        return "TEST SUMMARY: " + " · ".join(f"{r['runner']} {_counts(r)}" for r in runs) + " — all passed."
+    lines = ["TEST SUMMARY (from the whole output — read this before the log below):"]
+    for r in runs:
+        lines.append(f"  {r['runner']}: {_counts(r)}")
+        for f in r["failures"][:MAX_FAILURES]:
+            tail = f" ({f['where']})" if f["where"] else ""
+            lines.append(f"    ✗ {f['name']}" + (f" — {f['message']}" if f["message"] else "") + tail)
+        if len(r["failures"]) > MAX_FAILURES:
+            lines.append(f"    … and {len(r['failures']) - MAX_FAILURES} more")
+    return "\n".join(lines)
+
+
+# ---- running ONE test ------------------------------------------------------------------------------
+# Per runner, the form that runs a single test — what the model needs after the first full run, so
+# a fix is checked in seconds and the suite runs once at the end. Keyed on what the project's own
+# test command contains.
+ONE_TEST = (
+    (r"\bnode --test\b", "node --test --test-name-pattern='<name>' <file>"),
+    (r"\bunittest\b", "python3 -m unittest <module>.<Class>.<test_name>"),
+    (r"\bpytest\b", "python3 -m pytest '<file>::<test>' -x"),
+    (r"\bvitest\b", "npx vitest run <file> -t '<name>'"),
+    (r"\bjest\b", "npx jest <file> -t '<name>'"),
+    (r"\bgo test\b", "go test -run '^<TestName>$' ./<pkg>"),
+    (r"\bcargo test\b", "cargo test <name>"),
+    (r"\bmvn\b.*\btest\b", "mvn test -Dtest=<Class>#<method>"),
+    (r"\bgradlew?\b.*\btest\b", "./gradlew test --tests '<Class.method>'"),
+    (r"\brspec\b", "bundle exec rspec <file>:<line>"),
+)
+
+
+def one_test_forms(commands) -> list[str]:
+    """Distinct run-one-test forms for the runners named in these test commands."""
+    seen = []
+    for cmd in commands or []:
+        for pat, form in ONE_TEST:
+            if re.search(pat, cmd or "") and form not in seen:
+                seen.append(form)
+    return seen

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.832",
+  "version": "1.0.833",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -135,6 +135,7 @@
     "gonext_agent_chat.py",
     "gu_mcp.py",
     "gu_skills.py",
+    "gu_test_digest.py",
     "gu_hooks.py",
     "prompt_scaffold_check.py",
     "gonext_transcribe.py",