@tiens.nguyen/gu-cli 1.0.796 → 1.0.798

package/gonext_agent_chat.py

@@ -1072,6 +1072,75 @@ class _AgentConfigError(RuntimeError):
     worth a plain-reply degrade — the user needs the message itself to fix Settings."""
 
 
+class _OutputBudgetExhausted(_AgentConfigError):
+    """The coding model used its WHOLE output budget and wrote nothing — twice (issue #104).
+
+    Found in a real turn: Claude returned 0 characters for exactly max_tokens (32,000) output
+    tokens, six calls in a row, ~6.5 minutes each. Every one was retried unchanged, and the turn
+    finally stopped with "the coding model kept replying with explanations instead of a runnable
+    code block" — which is not what happened. A subclass of the config error so the turn ends as
+    FAILED with this message verbatim: no degrade to a plain reply, no three more steps of the
+    same."""
+
+
+# The retry of a budget-exhausted reply gets this much room (the first attempt had 32,000).
+_BUDGET_RETRY_MAX_TOKENS = 64000
+
+
+def _output_budget_exhausted(content, finish_reason) -> bool:
+    """Did this reply end at the output limit with nothing written? Pure.
+
+    Only the pair counts: an empty reply that stopped normally is the "thought but didn't act"
+    case the code-now retry exists for, and a reply cut at the limit WITH text is a truncated
+    block, handled where blocks are closed."""
+    return not (content or "").strip() and (finish_reason or "") == "length"
+
+
+def _budget_retry_kwargs(completion_kwargs, native_claude: bool, with_effort: bool = True) -> dict:
+    """The ONE retry of a budget-exhausted reply: more room, and (native Claude) lower effort.
+
+    Never the same request again — that is what cost 192,000 output tokens. Pure."""
+    kw = dict(completion_kwargs)
+    current = int(kw.get("max_tokens") or kw.get("max_completion_tokens") or 0)
+    if native_claude:
+        kw["max_tokens"] = max(_BUDGET_RETRY_MAX_TOKENS, current)
+        if with_effort:
+            kw["gu_effort"] = "low"
+        else:
+            kw.pop("gu_effort", None)
+    elif current:
+        # An OpenAI-compatible server: only a limit WE set can be raised; with none, it is the
+        # server's own and the request is left as it is.
+        key = "max_tokens" if kw.get("max_tokens") else "max_completion_tokens"
+        kw[key] = max(_BUDGET_RETRY_MAX_TOKENS, current * 2)
+    return kw
+
+
+def _no_code_message(model) -> str:
+    """Three steps in a row with no runnable code block. Pure.
+
+    It used to end "…or switch the coding backend back to Ollama in Settings" — said to someone
+    whose coder was a hosted Claude model (issue #104). It now names the model and the two
+    things that are always available."""
+    return (
+        f"I had to stop: {model or 'the coding model'} replied three times in a row without a "
+        "runnable code block, so none of those steps could execute. Some models put their answer "
+        "in their thinking and leave the reply empty. Type continue to try again, or pick another "
+        "coding model with /model."
+    )
+
+
+def _budget_exhausted_message(model, out_tokens) -> str:
+    """What the user is told when the retry came back empty at the limit too. Pure."""
+    spent = f"{int(out_tokens):,} output tokens" if out_tokens else "its whole output allowance"
+    return (
+        f"I had to stop: {model or 'the coding model'} used {spent} on this step — twice — and "
+        "wrote nothing. It ran out of output while thinking, before it got to the answer; this is "
+        "not a problem with your request. Nothing was changed by this step. Type continue to try "
+        "again, ask for the work in smaller pieces, or pick another coding model with /model."
+    )
+
+
 class _AgentOffline(_AgentConfigError):
     """The network was gone for longer than the wait budget (task #302, part 3). Ends the turn
     as FAILED — never as a stop — with the work so far kept and "continue" as the way on. A
@@ -1223,6 +1292,13 @@ def _anthropic_request(kw: dict) -> dict:
     # NO temperature / top_p: current Claude models reject sampling parameters with a 400, and
     # the thinking / effort settings are left at the model's defaults so they never vary per
     # request (a change there invalidates the cache).
+    #
+    # ONE EXCEPTION (issue #104): the retry of a reply that used its WHOLE output budget and wrote
+    # nothing asks for lower effort, so the second attempt cannot spend the budget the same way.
+    # A one-off request — its cache miss is the price of not repeating a 32,000-token blank.
+    effort = str(kw.get("gu_effort") or "").strip().lower()
+    if effort in ("low", "medium", "high"):
+        req["output_config"] = {"effort": effort}
     return req
 
 
@@ -1319,6 +1395,10 @@ class _AnthropicChatAdapter:
                         usage["output_tokens"] = int(out)
         if stop_reason == "refusal":
             _log("claude: the model declined this request (stop_reason=refusal)")
+        elif stop_reason == "max_tokens":
+            # Issue #104: six calls ended this way with no text and nothing in the log said so.
+            _log(f"warning: claude stopped at the output limit (stop_reason=max_tokens, "
+                 f"max_tokens={req.get('max_tokens')}, output {usage.get('output_tokens', 0)} tokens)")
         _log_anthropic_usage(usage)
         yield chunk(content="", finish=_ANTHROPIC_FINISH.get(stop_reason, "stop"))
         yield chunk(usage=_anthropic_usage(usage))
@@ -7485,21 +7565,42 @@ def _ws_distill_output(out: str, cap_head: int = 1200, cap_tail: int = 4000) ->
 # d6ad7211 walked a 6,665-line file in slices for ~40 steps. With cache reads at 0.1x a bigger
 # read costs about what the extra step did, and steps are what we save. Claude Code's own Read
 # allows 25k tokens. Small or unknown windows keep 3,000 — a 16k local Ollama is unchanged.
+#
+# VERY LARGE WINDOWS GET MORE (GitHub #105 / task #355) — for ANY model the user picks, by its
+# window, never by its name. The 24,000-char ceiling was reached at a 200k window and then stood
+# still: a 1,000,000-token coder was allowed the same read as a 200k one — 0.6% of its window —
+# and read_file_lines stopped at 400 lines whatever the model. A 6,665-line file is 17 reads at
+# 400 lines, 4 at 2,000. So above 200k the same 3% share keeps applying, up to 80,000 chars
+# (~20k tokens — about what Claude Code's own Read allows), and the line limit follows the cap.
+# Nothing changes at or below 200k: those rows of the table are exactly what they were.
+#
+# The ceiling is about COST, not fit: every read stays in the step memory and is sent again on
+# each later step (cached at ~0.1x on hosted coders, re-evaluated in full on a self-hosted one),
+# so "it fits" is not a reason to hand over a whole 500k-char file.
 _OBS_CAP_FLOOR = 3000
-_OBS_CAP_READ_MAX = 24_000    # ≈ read_file_lines' own 400-line limit
-_OBS_CAP_SEARCH_MAX = 12_000  # ≈ grep_repo's 100 hits / list_dir's 300 entries
-_OBS_CAP_WINDOW_SHARE = 0.03  # one read may take ~3% of the window
-_OBS_CAPS = {"read": _OBS_CAP_FLOOR, "search": _OBS_CAP_FLOOR}
+_OBS_CAP_READ_MAX = 24_000         # the ceiling up to a 200k window ≈ a 400-line read
+_OBS_CAP_READ_MAX_LARGE = 80_000   # …and above it (reached at ~667k tokens)
+_OBS_CAP_SEARCH_MAX = 12_000       # ≈ grep_repo's 100 hits / list_dir's 300 entries
+_OBS_CAP_SEARCH_MAX_LARGE = 24_000
+_OBS_CAP_LARGE_WINDOW = 200_000    # tokens; above this the large ceilings apply
+_OBS_CAP_WINDOW_SHARE = 0.03       # one read may take ~3% of the window
+_OBS_LINES_FLOOR = 400             # read_file_lines' limit, as it always was
+_OBS_LINES_MAX = 2000
+_OBS_CHARS_PER_LINE = 60           # 24,000 chars ≈ 400 lines — the ratio the old pair already had
+_OBS_CAPS = {"read": _OBS_CAP_FLOOR, "search": _OBS_CAP_FLOOR, "lines": _OBS_LINES_FLOOR}
 
 
 def _obs_caps_for_window(window_tokens: int) -> dict:
-    """{read, search} character caps for a model with this context window (0 = unknown)."""
+    """{read, search} character caps and the `lines` limit of one read, for a model with this
+    context window (0 = unknown). Pure — the whole rule is this function."""
     if not window_tokens or window_tokens <= 0:
-        return {"read": _OBS_CAP_FLOOR, "search": _OBS_CAP_FLOOR}
+        return {"read": _OBS_CAP_FLOOR, "search": _OBS_CAP_FLOOR, "lines": _OBS_LINES_FLOOR}
+    large = window_tokens > _OBS_CAP_LARGE_WINDOW
     read = int(window_tokens * 4 * _OBS_CAP_WINDOW_SHARE)  # ~4 chars per token
-    read = max(_OBS_CAP_FLOOR, min(_OBS_CAP_READ_MAX, read))
-    search = max(_OBS_CAP_FLOOR, min(_OBS_CAP_SEARCH_MAX, read // 2))
-    return {"read": read, "search": search}
+    read = max(_OBS_CAP_FLOOR, min(_OBS_CAP_READ_MAX_LARGE if large else _OBS_CAP_READ_MAX, read))
+    search = max(_OBS_CAP_FLOOR, min(_OBS_CAP_SEARCH_MAX_LARGE if large else _OBS_CAP_SEARCH_MAX, read // 2))
+    lines = max(_OBS_LINES_FLOOR, min(_OBS_LINES_MAX, read // _OBS_CHARS_PER_LINE))
+    return {"read": read, "search": search, "lines": lines}
 
 
 def _set_obs_caps(window_tokens: int) -> dict:
@@ -7664,8 +7765,12 @@ def run_agent_chat(cfg):
     # current task are logged early, and a real turn caught them leaking when this came later).
     # "production" (the account has no Enable Full Log): content becomes <content, N chars> and the
     # model-request dump is only what is new per step. "full" (or absent — an older worker): as before.
-    global _LOG_PRODUCTION
-    _LOG_PRODUCTION = str(cfg.get("logProfile") or "full").strip().lower() == "production"
+    global _LOG_PRODUCTION, _LOG_MINIMAL
+    _profile = str(cfg.get("logProfile") or "full").strip().lower()
+    # "minimal" (task #352) is production's rules — no conversation content — plus: only trouble
+    # is logged at all (see _log).
+    _LOG_MINIMAL = _profile == "minimal"
+    _LOG_PRODUCTION = _profile in ("production", "minimal")
     # One turn, one ledger (task #142): the process is per-turn today, but a stale entry would
     # credit RAG for tokens it never cost, and a wrong number is worse than none.
     _rag_ledger_reset()
@@ -9703,7 +9808,8 @@ def run_agent_chat(cfg):
     _ctx_window = _model_context_window(coding_base_url, coding_model_id, coding_api_key)
     _compact_at = _compact_threshold(_ctx_window)
     _caps = _set_obs_caps(_ctx_window)
-    _log(f"read caps: {_caps['read']} chars per read, {_caps['search']} per search (issue #49)")
+    _log(f"read caps: {_caps['read']} chars / {_caps['lines']} lines per read, {_caps['search']} chars "
+         f"per search — for a {_ctx_window or 'unknown'}-token window (issues #49, #105)")
     if _ctx_window:
         # SAY WHICH SOURCE ANSWERED. A measured window and a remembered one are not the same
         # claim, and a table entry presented as fact is how a stale number survives unquestioned.
@@ -10178,6 +10284,11 @@ def run_agent_chat(cfg):
                 return super().generate(*args, **kwargs)
             try:
                 return self._streamed_generate(*args, **kwargs)
+            except _AgentConfigError:
+                # A final reason to stop (issue #104), not a streaming problem: the unstreamed
+                # re-send below would be the same blank a third time — and it marked streaming
+                # as "refused by the server" for the rest of the process.
+                raise
             except Exception as e:  # noqa: BLE001
                 _started = getattr(self, "_first_token_seen", False)
                 if _stream_fallback_decision(e, _started) == "raise":
@@ -10523,6 +10634,47 @@ def run_agent_chat(cfg):
             # OpenAI-compatible backend, not a failure. _close_dangling_code_block runs in
             # _run_stream (and again inside _code_nudge_reason) so it is already excluded.
             _pair_re = _CODE_PAIR_RE
+            # THE WHOLE OUTPUT BUDGET, AND NOTHING WRITTEN (issue #104). Checked BEFORE the
+            # code-now retry, which would resend the same request and get the same blank: this
+            # reply is retried ONCE with room to answer (and lower effort on the native Claude
+            # path); a second blank at the limit ends the turn with what really happened.
+            if _output_budget_exhausted(content, getattr(self, "_last_finish_reason", "")):
+                _native = isinstance(self.client, _AnthropicChatAdapter)
+                _log(f"warning: the model used its whole output budget ({out_tok} tokens) and wrote "
+                     "nothing (finish_reason=length) → retrying ONCE with a larger budget"
+                     + (" and lower effort" if _native else ""))
+                _emit({"type": "step", "text": (
+                    f"{_VERBOSE_PREFIX}The model ran out of output before writing anything — "
+                    "asking once more with room to answer…")})
+                _first_out = out_tok
+                _retry = _budget_retry_kwargs(completion_kwargs, _native)
+                _retry["messages"] = list(completion_kwargs.get("messages") or []) + [
+                    {"role": "user", "content": self._CODE_NOW_DIRECTIVE}
+                ]
+                try:
+                    r_content, r_role, r_in, r_out, _ = self._run_stream(_retry)
+                except Exception as _e:  # noqa: BLE001
+                    # A server that does not know the effort setting answers 400 — the larger
+                    # budget alone is still a different request, so try that before giving up.
+                    if _native and _http_status_of(_e) == 400:
+                        _log(f"warning: the lower-effort retry was refused (HTTP 400) — retrying "
+                             "with the larger budget only")
+                        _retry = _budget_retry_kwargs(completion_kwargs, _native, with_effort=False)
+                        _retry["messages"] = list(completion_kwargs.get("messages") or []) + [
+                            {"role": "user", "content": self._CODE_NOW_DIRECTIVE}
+                        ]
+                        r_content, r_role, r_in, r_out, _ = self._run_stream(_retry)
+                    else:
+                        raise
+                out_tok += r_out  # generated and billed, whatever came back (#112)
+                if _output_budget_exhausted(r_content, getattr(self, "_last_finish_reason", "")) \
+                        or not (r_content or "").strip():
+                    _log("error: the retry used its output budget and wrote nothing too → ending "
+                         "the turn instead of repeating it")
+                    raise _OutputBudgetExhausted(
+                        _budget_exhausted_message(self.model_id, r_out or _first_out))
+                content, role = r_content, r_role
+                in_tok = r_in or in_tok
             why = _code_nudge_reason(content, self._openai_backend)
             if why:
                 _log(f"{why} turn (reasoning={reasoning_len} chars) → retrying once with a "
@@ -10747,6 +10899,11 @@ def run_agent_chat(cfg):
                             _emit({"type": "step", "text": "Connection back — continuing"})
                             _log(f"connection back after {time.monotonic() - offline['since']:.0f}s")
                         break
+                    except _AgentConfigError:
+                        # Already a final, user-ready reason to stop (issue #104: a reply that
+                        # used its whole output budget twice). Retrying it here would repeat
+                        # exactly the calls it exists to prevent.
+                        raise
                     except Exception as e:  # noqa: BLE001
                         emsg = str(e)
                         # A 404 "model not found" is a config error (wrong model NAME
@@ -11234,14 +11391,7 @@ def run_agent_chat(cfg):
                         if self._no_code_streak >= 3:
                             _log("no-code streak hit limit → ending the turn honestly "
                                  "instead of looping on a coder that won't emit code")
-                            _nocode_msg = (
-                                "I had to stop: the coding model kept replying with "
-                                "explanations instead of a runnable code block, so none of "
-                                "my steps could actually execute. This is usually a "
-                                "reasoning model putting its answer in the thinking channel. "
-                                "Try a non-reasoning coding model, or switch the coding "
-                                "backend back to Ollama in Settings, then run this again."
-                            )
+                            _nocode_msg = _no_code_message(self.model_id)
                             msg.content = ("<code>\nfinal_answer("
                                            + repr(_nocode_msg) + ")\n</code>")
                             self._no_code_streak = 0
@@ -12379,7 +12529,9 @@ def run_agent_chat(cfg):
             Args:
                 path: local file path.
                 start_line: first line to show (1-based).
-                end_line: last line to show inclusive; 0 = rest of file (max 400 lines shown).
+                end_line: last line to show inclusive; 0 = rest of file. One read shows at most 400
+                    lines (more with a large-context model) — the first line of the result says the
+                    range shown and the file's total, so read the next range if there is more.
             """
             try:
                 _emit_running("Reading lines",
@@ -12391,7 +12543,9 @@ def run_agent_chat(cfg):
                     lines = fh.readlines()
                 s = max(1, int(start_line or 1))
                 e = int(end_line or 0) or len(lines)
-                e = min(e, len(lines), s + 399)
+                # The line limit follows the coder's window (#105): 400, up to 2,000 on a very
+                # large one — see _obs_caps_for_window.
+                e = min(e, len(lines), s + int(_OBS_CAPS.get("lines") or _OBS_LINES_FLOOR) - 1)
                 # AFTER normalising, never before: end_line=0 means "to the end, capped at
                 # 400", so the range the model asked for and the range it actually gets are
                 # different numbers. Comparing the raw arguments would miss every whole-file
@@ -13590,13 +13744,40 @@ def run_agent_chat(cfg):
         _emit({"type": "final", "text": note})
 
 
+# What still gets logged at the MINIMAL level (task #352): a line that says something went wrong.
+# The same list as log-level.mjs TROUBLE — the worker filters again, but dropping the narration
+# HERE means it is never built into an event, sent down the pipe and parsed just to be discarded
+# (about 150 lines a turn, measured).
+_LOG_TROUBLE = re.compile(
+    r"\b(error|errors|errored|fail|failed|failure|fatal|exception|traceback|panic|refused|unreachable|"
+    r"unavailable|overloaded|denied|forbidden|unauthori[sz]ed|invalid|rejected|aborted|killed|crash(ed)?|"
+    r"timed out|timeout|not found|cannot|can't|could ?n[o']t|couldn't|unable|warning|warn|degrad\w*|"
+    r"fall(ing|s)? back|fell back|fallback|skipped|lost)\b|✗|⚠|HTTP [45]\d\d|status[= ][45]\d\d",
+    re.IGNORECASE,
+)
+# System error codes (ENOENT, ECONNRESET…) — case-sensitive, or it matches every word in "e…".
+_LOG_ERRNO = re.compile(r"\bE[A-Z]{4,}\b")
+
+
+def _log_kept_at_minimal(text) -> bool:
+    """Is this line trouble? Pure."""
+    t = str(text or "")
+    return bool(_LOG_TROUBLE.search(t) or _LOG_ERRNO.search(t))
+
+
 def _log(text: str):
-    """Emit a log event — worker prints it to console, not forwarded to chat."""
+    """Emit a log event — worker prints it to console, not forwarded to chat.
+
+    At the minimal level (the default, task #352) only trouble is emitted; the rest is what
+    `gu --log` is for."""
+    if _LOG_MINIMAL and not _log_kept_at_minimal(text):
+        return
     _emit({"type": "log", "text": text})
 
 
 _CLIENT_MODE = False  # task #134: agent runs here, models live on another machine
 _LOG_PRODUCTION = False  # task #249: set from cfg.logProfile; False = log as always
+_LOG_MINIMAL = False  # task #352: only trouble is logged
 # How many messages of THIS run's model requests are already in the log (task #249, production
 # only). One python process runs one job, so module state is per turn.
 _DUMP_SEEN = {"n": 0}

package/gu-cli.mjs

@@ -36,6 +36,7 @@ import { createRequire } from "node:module";
 import dotenv from "dotenv";
 import OpenAI from "openai";
 import { resolvePython } from "./platform-tools.mjs";
+import { MINIMAL_RUN_LOGS, agentLogProfile, currentLevel, installLevelFilter, levelLine } from "./log-level.mjs";
 import { skillsForTurn } from "./skills.mjs";
 import { mcpForTurn } from "./mcp-config.mjs";
 import { hooksForTurn, sessionForTurn } from "./hooks-config.mjs";
@@ -398,6 +399,7 @@ if (["start", "stop", "status", "logs", "restart"].includes(args[0])) {
     if (s.running) {
       const who = s.pidFilePid ? `pid ${s.pidFilePid}` : `pid ${s.pids.join(", ")}`;
       console.log(`[gu-worker] daemon RUNNING (${who}). Logs: ${ctl.LOG_FILE}`);
+      console.log(`[gu-worker] ${levelLine(currentLevel())}`); // #352: which level it is writing at
     } else {
       console.log("[gu-worker] daemon is NOT running. Start it with: gu-cli start");
     }
@@ -4081,7 +4083,9 @@ async function runAgentChatJob(job) {
       alwaysExtendOnMaxStep: payload?.alwaysExtendOnMaxStep === true,
       // What the agent may log (task #249): "production" = no conversation content, and the
       // model-request dump only what is new per step. "full" = as it always has.
-      logProfile: logPolicy?.profile() ?? "full",
+      // #352: "minimal" (starts, stops, errors) unless a `gu --log` terminal is open right now —
+      // then the account's own profile, i.e. what was logged before the minimal level existed.
+      logProfile: agentLogProfile(logLevelNow(), logPolicy?.profile() ?? "full"),
       // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
       autoTest: payload?.autoTest === true,
       // Deploy target chosen via the terminal /server picker (task #69). Host/user only.
@@ -5222,6 +5226,7 @@ let shuttingDown = false;
 async function failInFlightJobsAndExit(signal, onExit = () => {}) {
   if (shuttingDown) return;
   shuttingDown = true;
+  console.log(`[gu-worker] stopping (${signal})`); // #352: the STOP line
   const ids = [...inFlightJobs.keys()];
   if (ids.length) {
     console.log(
@@ -5338,6 +5343,9 @@ async function pollOnce() {
       return;
     }
     if (job.jobType === "agent_chat") {
+      // #352: the START line of a turn — with "completed"/"failed" it is all a turn leaves in the
+      // minimal log.
+      console.log(`[gu-worker] started agent_chat ${String(job.jobId ?? job._id ?? job.id ?? "")}`);
       // Fire-and-forget into the pool — the same shape local_health has used all along. The
       // `await … return` this replaces is the entire bug: it held the poll loop for the whole
       // turn, so no other folder could be served (task #152).
@@ -5385,6 +5393,14 @@ async function pollOnce() {
  * Log, or the setting not readable yet) is exactly today's logging. See log-policy.mjs.
  */
 let logPolicy = null;
+// #352: the level is read from the `gu --log` lease, at most twice a second — it sits on the path
+// of every line printed.
+let _levelCache = { at: 0, level: "minimal" };
+function logLevelNow() {
+  const now = Date.now();
+  if (now - _levelCache.at > 500) _levelCache = { at: now, level: currentLevel() };
+  return _levelCache.level;
+}
 async function startLogPolicy() {
   try {
     const lp = await import("./log-policy.mjs");
@@ -5399,15 +5415,34 @@ async function startLogPolicy() {
             : "[gu-worker] log profile: full — Enable Full Log is on for this account"
         ),
     });
-    lp.installTimestamps(() => logPolicy.profile() === "production");
+    // #352: at the minimal level every line is stamped too — a log of starts, stops and errors is
+    // only useful if each says WHEN.
+    lp.installTimestamps(() => logPolicy.profile() === "production" || logLevelNow() === "minimal");
+    // THE LEVEL FILTER, last so it is the first thing a line meets (see log-level.mjs).
+    installLevelFilter(logLevelNow);
     await logPolicy.refresh();
     const runLogs = join(homedir(), ".gonext", "run-logs");
     const housekeep = async () => {
+      if (logLevelNow() === "minimal") {
+        await lp.rotateIfLarge(LOG_FILE);
+        await lp.pruneRunLogs(runLogs, MINIMAL_RUN_LOGS);
+        return;
+      }
       if (logPolicy.profile() !== "production") return;
       await lp.rotateIfLarge(LOG_FILE);
       await lp.pruneRunLogs(runLogs);
     };
     await housekeep();
+    // Say which level this log is written at — and say it again whenever it changes, so a stretch
+    // of detail in the file is explained by the line above it.
+    let saidLevel = logLevelNow();
+    console.log(`[gu-worker] ${levelLine(saidLevel)}`);
+    setInterval(() => {
+      const now = logLevelNow();
+      if (now === saidLevel) return;
+      saidLevel = now;
+      console.log(`[gu-worker] ${levelLine(now)}`);
+    }, 2_000).unref();
     let ticks = 0;
     const { REFRESH_FLAG } = await import("./full-log-command.mjs");
     setInterval(() => {