@tiens.nguyen/gu-cli 1.0.831 → 1.0.833

package/gonext_agent_chat.py

@@ -7711,13 +7711,13 @@ def _shell_commands(tokens):
     while i < len(tokens):
         kind, text, a, b, quoted = tokens[i]
         if kind == "op" and text in _SHELL_SEPARATORS:
-            if cur and (cur["argv"] or cur["redirects"]):
+            if cur and (cur["argv"] or cur["redirects"] or cur["assigns"]):
                 cmds.append(cur)
             cur, sep = None, text
             i += 1
             continue
         if cur is None:
-            cur = {"argv": [], "spans": [], "sep": sep, "redirects": []}
+            cur = {"argv": [], "spans": [], "sep": sep, "redirects": [], "assigns": []}
         if kind == "op":
             nxt = tokens[i + 1] if i + 1 < len(tokens) else None
             tgt = nxt[1] if nxt and nxt[0] == "word" else ""
@@ -7725,16 +7725,73 @@ def _shell_commands(tokens):
             i += 2 if tgt or (nxt and nxt[0] == "word") else 1
             continue
         if not cur["argv"] and re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", text):
+            cur["assigns"].append(tuple(text.split("=", 1)))
             i += 1
             continue
         cur["argv"].append(text)
         cur["spans"].append((a, b))
         i += 1
-    if cur and (cur["argv"] or cur["redirects"]):
+    if cur and (cur["argv"] or cur["redirects"] or cur["assigns"]):
         cmds.append(cur)
     return cmds
 
 
+# A RUNNER IN A VARIABLE THAT THE LINE ITSELF SET (#362). `U=/Applications/…/Unity && $U -batchmode
+# -runTests …` asked "the program to run is only known at run time" — but it is known: the same
+# line assigned it a literal. The check now resolves that case and judges the REAL program, by
+# re-scanning a copy of the line with the literal in place — so every rule (privilege, denylist,
+# allowlist, deletes) sees it: `S=sudo && $S rm -rf /` is still sudo. Only a top-level assignment
+# whose value has no $, `, glob or leading ~, made before the use and not inside a pipeline (a
+# subshell); anything else keeps asking. bash still runs the line exactly as written.
+# Anything else that can set or clear a variable makes the value unknowable from the text.
+_SHELL_VAR_CHANGERS = {"unset", "read", "declare", "typeset", "local", "readonly", "source", ".",
+                       "eval", "for", "select", "mapfile", "readarray", "getopts", "printf", "let"}
+_SHELL_VAR_RUNNER_RE = re.compile(r"^\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))$")
+
+
+def _shell_literal_value(v: str) -> bool:
+    return bool(v) and not re.search(r"[$`*?\[]", v) and not v.startswith("~")
+
+
+def _shell_resolve_runner_vars(command: str, scan) -> str:
+    """`command` with each top-level `$X` runner replaced by X's literal value, or "" when there
+    is nothing this line can resolve. For CHECKING only — never executed."""
+    import shlex as _shlex
+    if not scan or scan.get("error"):
+        return ""
+    cmds = _shell_commands(scan["tokens"])
+    if any(c["argv"] and _shell_prog_name(c["argv"][0]) in _SHELL_VAR_CHANGERS for c in cmds):
+        return ""
+    env, edits = {}, []
+    for k, c in enumerate(cmds):
+        in_pipe = c["sep"] in ("|", "|&") or (k + 1 < len(cmds) and cmds[k + 1]["sep"] in ("|", "|&"))
+        a = c["argv"]
+        pairs = []
+        if not a:
+            pairs = list(c.get("assigns") or [])
+        elif a[0] == "export":
+            pairs = [tuple(x.split("=", 1)) for x in a[1:] if re.match(r"^[A-Za-z_][A-Za-z0-9_]*=", x)]
+        if pairs:
+            for name, val in pairs:
+                if not in_pipe and _shell_literal_value(val):
+                    env[name] = val
+                else:
+                    env.pop(name, None)
+            continue
+        m = _SHELL_VAR_RUNNER_RE.match(a[0]) if a else None
+        if m and (m.group(1) or m.group(2)) in env:
+            start, end = c["spans"][0]
+            val = env[m.group(1) or m.group(2)]
+            # "$U" is one word; a bare $U is WORD-SPLIT by bash — `U="sudo rm" && $U -rf /` runs
+            # sudo. Substituted raw, the re-scan splits it the same way and sees sudo.
+            edits.append(((start, end), _shlex.quote(val) if command[start:end].startswith('"') else val))
+    if not edits:
+        return ""
+    for (start, end), val in sorted(edits, reverse=True):
+        command = command[:start] + val + command[end:]
+    return command
+
+
 def _shell_needed(scan):
     """Does this line need a shell to mean what it says? False → run it as argv, as before."""
     return bool(scan["heredocs"] or scan["substs"] or scan["expands"]
@@ -7967,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"
@@ -7980,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 "
@@ -8099,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.
@@ -8994,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
 
@@ -9164,6 +9249,55 @@ def _shell_or_server(shells: list, servers: list, key: str):
     return max(cands, key=lambda x: float(x.get("started") or 0)) if cands else None
 
 
+# A SHELL THAT WRITES ITS OWN LOG (#362). Unity `-batchmode … -logFile Logs/all.log` prints nothing
+# for its whole 5-minute run — everything goes to that file — so the shell's output read "No output
+# available" until the end. When a shell has no output of its own, the file its command names is
+# the next best thing: an explicit log flag first, then `tee`, then the last `>`/`>>` redirect.
+_LOG_FLAG_RE = re.compile(r"^--?(?:log-?file|logfile|log-path|log)(?:=(.+))?$", re.I)
+
+
+def _shell_log_file(command: str, workdir: str = "") -> str:
+    """The log file a command line writes to, as an absolute path that exists — or ""."""
+    scan = _shell_scan(command or "")
+    if scan.get("error"):
+        return ""
+    flag = tee = redir = ""
+    for c in _shell_commands(scan["tokens"]):
+        a = c["argv"]
+        for i, w in enumerate(a):
+            m = _LOG_FLAG_RE.match(w)
+            if m:
+                flag = m.group(1) or (a[i + 1] if i + 1 < len(a) else "") or flag
+        if a and _shell_prog_name(a[0]) == "tee":
+            files = [x for x in a[1:] if not x.startswith("-")]
+            tee = files[-1] if files else tee
+        for op, tgt in c["redirects"]:
+            if op in (">", ">>", "&>", "&>>", "1>", "1>>") and tgt and not tgt.startswith("&"):
+                redir = tgt
+    for cand in (flag, tee, redir):
+        if not cand or cand in ("/dev/null", "-"):
+            continue
+        path = cand.replace("$PWD", workdir or "").replace("${PWD}", workdir or "")
+        path = os.path.expanduser(path)
+        if not os.path.isabs(path):
+            path = os.path.join(workdir or os.getcwd(), path)
+        if os.path.isfile(path):
+            return os.path.normpath(path)
+    return ""
+
+
+def _file_tail(path: str, max_chars: int = 4000) -> str:
+    try:
+        with open(path, "rb") as fh:
+            fh.seek(0, 2)
+            size = fh.tell()
+            fh.seek(max(0, size - max_chars))
+            text = fh.read().decode("utf-8", errors="replace")
+        return text if size <= max_chars else text.split("\n", 1)[-1]
+    except OSError:
+        return ""
+
+
 def _shell_kill(s: dict) -> None:
     """Stop a shell's whole process group and mark it killed (unless it already finished)."""
     import time as _t
@@ -9195,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
@@ -14578,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
@@ -14601,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
@@ -14614,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
@@ -14658,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`
@@ -14677,8 +14902,11 @@ def run_agent_chat(cfg):
                     # Every simple command in the line, including those inside $( ), gets the
                     # checks an argv command gets — allowlist, privilege, denylist, deletes —
                     # plus the shell-only ones (redirect outside the project, `| sh`).
+                    _resolved = _shell_resolve_runner_vars(command, _scan)
+                    _risk_scan = _shell_scan(_resolved) if _resolved else _scan
                     _refuse, _hard_reason, _ask_reason = _ws_shell_command_risk(
-                        _scan, _WS_RUN_DENYLIST, wd, _WS_RUN_ALLOWLIST)
+                        _risk_scan if not _risk_scan.get("error") else _scan,
+                        _WS_RUN_DENYLIST, wd, _WS_RUN_ALLOWLIST)
                     if _refuse:
                         _last_obs["text"] = _refuse
                         return _refuse
@@ -14775,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:
@@ -14830,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
@@ -14853,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."
@@ -14873,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))}"
@@ -15088,8 +15326,23 @@ 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 ""))
+                    lt = _file_tail(lf).strip() if lf else ""
+                    if lt:
+                        tail_note = (f"\nIt prints nothing itself; the end of the log it writes "
+                                     f"({lf}):\n{lt}")
                 msg = head + "\n" + (f"New output:\n{new}" if new.strip()
-                                     else "No new output since the last read.")
+                                     else "No new output since the last read.") + tail_note
                 _emit({"type": "step", "text":
                        f"Shell {sh.get('id')} {_shell_status_text(st)} → {_trim_words(str(sh.get('command')))}"})
                 _last_obs["text"] = msg

package/gu-repl.mjs

@@ -139,7 +139,7 @@ import {
 import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
 import { isScaffoldStep, isGroupableStep, stepGroupRows, relativizePaths } from "./step-group.mjs";
 import { clearLogsNoticeText } from "./clear-logs.mjs";
-import { killShell, logTail, readShells, renderShellDetails, shellPickerLabel, shellState, shellsNotice } from "./shell-details.mjs";
+import { commandLogFile, killShell, logTail, readShells, renderShellDetails, shellPickerLabel, shellState, shellsNotice } from "./shell-details.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
 import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
@@ -9510,8 +9510,18 @@ function printShellDetails(rec) {
   const width = Math.max(20, process.stdout.columns || 80);
   const st = shellState(rec);
   shellsViewed.add(String(rec.id));
+  // Nothing printed of its own (Unity -batchmode -logFile …)? Show the log its command writes.
+  let output = logTail(rec.log);
+  let outputFrom = "";
+  if (!output.length) {
+    const lf = commandLogFile(rec.command, rec.workdir);
+    if (lf) {
+      output = logTail(lf);
+      outputFrom = lf.startsWith(String(rec.workdir || "\0") + "/") ? lf.slice(String(rec.workdir).length + 1) : lf;
+    }
+  }
   const rows = renderShellDetails({
-    rec, st, output: logTail(rec.log), width: width - 1, gutter: GUTTER,
+    rec, st, output, outputFrom, width: width - 1, gutter: GUTTER,
     style: { title: (t) => bold(accent(t)), label: bold, running: accent, ok: accent, bad: red, dim },
   });
   console.log("\n" + GUTTER + accent("─".repeat(Math.max(10, width - 1 - GUTTER.length))));

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.831",
+  "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",

package/shell-details.mjs

@@ -13,7 +13,7 @@
 
 import { existsSync, openSync, readSync, closeSync, fstatSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join, normalize } from "node:path";
 import { spawnSync } from "node:child_process";
 
 export const shellsPath = (home = homedir()) => join(home, ".gonext", "shells.json");
@@ -135,6 +135,38 @@ export function logTail(path, { lines = 15, maxBytes = 64 * 1024 } = {}) {
   return out.slice(-lines);
 }
 
+const unq = (w) => w.replace(/^"(.*)"$/s, "$1").replace(/^'(.*)'$/s, "$1");
+const WORD = String.raw`("[^"]*"|'[^']*'|[^\s;&|<>]+)`;
+
+/**
+ * The log file a command writes to, when the shell itself prints nothing (#362: Unity's
+ * `-logFile Logs/all.log` left Shell details on "No output available" for a 5-minute run).
+ * An explicit log flag first, then `tee`, then the last `>`/`>>` redirect — the same order as
+ * the agent's _shell_log_file. → an absolute path that exists, or "".
+ */
+export function commandLogFile(command, workdir = "") {
+  const cmd = String(command ?? "");
+  const last = (re) => {
+    let m, v = "";
+    for (const r = new RegExp(re, "gi"); (m = r.exec(cmd)); ) v = m[1] ?? m[2] ?? v;
+    return v;
+  };
+  const flag = last(String.raw`(?:^|\s)--?(?:log-?file|logfile|log-path|log)(?:=` + WORD + String.raw`|\s+` + WORD + ")");
+  const tee = last(String.raw`\btee\s+(?:-a\s+)?` + WORD);
+  const redir = last(String.raw`(?:^|[^0-9&>])(?:1|&)?>>?\s*(?!&)` + WORD);
+  for (const raw of [flag, tee, redir]) {
+    if (!raw) continue;
+    let p = unq(raw).replace(/\$\{?PWD\}?/g, workdir || "");
+    if (p === "/dev/null" || p === "-") continue;
+    if (p.startsWith("~/")) p = join(homedir(), p.slice(2));
+    if (!isAbsolute(p)) p = join(workdir || process.cwd(), p);
+    try {
+      if (statSync(p).isFile()) return normalize(p);
+    } catch { /* not there (yet) */ }
+  }
+  return "";
+}
+
 /** Word-wrap `text` to `width`; at most `maxRows`, the last ending in "…" when cut. */
 export function wrapClip(text, width, maxRows = 4) {
   const w = Math.max(10, width);
@@ -166,7 +198,7 @@ const plain = (s) => s;
  * The Shell details block, one string per row, no row wider than `width`.
  * `style`: {title, label, running, ok, bad, dim} paint functions (identity in tests).
  */
-export function renderShellDetails({ rec, st, output = [], width = 80, gutter = "  ", style = {} }) {
+export function renderShellDetails({ rec, st, output = [], outputFrom = "", width = 80, gutter = "  ", style = {} }) {
   const p = { title: plain, label: plain, running: plain, ok: plain, bad: plain, dim: plain, ...style };
   const inner = Math.max(20, width - gutter.length);
   const valW = inner - LABEL_W;
@@ -183,7 +215,8 @@ export function renderShellDetails({ rec, st, output = [], width = 80, gutter =
     ...cmd.slice(1).map((c) => gutter + pad + c),
   ];
   if (rec?.workdir) rows.push(row("Folder:", p.dim(wrapClip(rec.workdir, valW, 1)[0])));
-  rows.push("", gutter + p.label("Output:"));
+  // From the log file the command writes, when the shell printed nothing itself — say which.
+  rows.push("", gutter + p.label("Output:") + (outputFrom ? p.dim(`  (from ${wrapClip(outputFrom, Math.max(10, inner - 20), 1)[0]})`) : ""));
   if (!output.length) rows.push(gutter + p.dim("No output available"));
   else for (const l of output) rows.push(gutter + (l.length > inner ? l.slice(0, inner - 1) + "…" : l));
   return rows;