@tiens.nguyen/gu-cli 1.0.745 → 1.0.746

package/conversation-archive.mjs

@@ -0,0 +1,100 @@
+/**
+ * EVERY MESSAGE OF A FOLDER'S CONVERSATION, KEPT (task #278).
+ *
+ *   ~/.gonext/sessions/archive/<folder hash>.jsonl   — append-only, one JSON object per line
+ *
+ * The session file keeps only the last 40 messages (what the model is sent), and /reset used to
+ * delete even those — with the folder's settings — and delete the database copy too: no archive,
+ * no undo. The user avoided /reset because of it ("i still need to keep the history").
+ *
+ * So the archive is a LOG: each message is appended once, the first time it is saved; a /reset
+ * appends a marker and the conversation starts over. Nothing is ever rewritten, so a crash
+ * mid-write can cost at most the line being written. The model's context is unchanged — this is
+ * for the user.
+ *
+ *   {"type":"message","at":"…","role":"user","content":"…"}
+ *   {"type":"reset","at":"…","messages":12}
+ */
+import { createHash } from "node:crypto";
+import { appendFile, mkdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const archiveDir = (home = homedir()) => join(home, ".gonext", "sessions", "archive");
+
+/** The same folder hash the session file uses (gu-repl.mjs sessionFilePath). */
+export function archivePathFor(cwd, home = homedir()) {
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 32);
+  return join(archiveDir(home), `${hash}.jsonl`);
+}
+
+async function exists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function appendLines(path, objs) {
+  if (!objs.length) return;
+  await mkdir(join(path, ".."), { recursive: true });
+  await appendFile(path, objs.map((o) => JSON.stringify(o)).join("\n") + "\n", { encoding: "utf8", mode: 0o600 });
+}
+
+const asLine = (m, at) => ({ type: "message", at, role: String(m?.role ?? ""), content: String(m?.content ?? "") });
+
+/**
+ * A folder opened for the first time since the archive existed: copy in the history it already
+ * has, so nothing from before this feature is lost either. → how many messages are now archived
+ * (the caller's starting point for `appendNew`). An archive that already exists is left alone.
+ */
+export async function seedArchive(cwd, history, { home = homedir(), now = () => new Date().toISOString() } = {}) {
+  const path = archivePathFor(cwd, home);
+  const list = Array.isArray(history) ? history : [];
+  if (!(await exists(path))) await appendLines(path, list.map((m) => asLine(m, now())));
+  return list.length;
+}
+
+/**
+ * Append the messages after `archivedUpTo` (an index into `history`). → the new index. A history
+ * that SHRANK (a question dropped by #247's rules, a trim) just moves the index back — what is
+ * archived stays archived.
+ */
+export async function appendNew(cwd, history, archivedUpTo, { home = homedir(), now = () => new Date().toISOString() } = {}) {
+  const list = Array.isArray(history) ? history : [];
+  if (list.length <= archivedUpTo) return list.length;
+  await appendLines(archivePathFor(cwd, home), list.slice(archivedUpTo).map((m) => asLine(m, now())));
+  return list.length;
+}
+
+/** Mark where a /reset started a new conversation. */
+export async function markReset(cwd, messages, { home = homedir(), now = () => new Date().toISOString() } = {}) {
+  await appendLines(archivePathFor(cwd, home), [{ type: "reset", at: now(), messages }]);
+}
+
+/** The whole log, parsed; a damaged line is skipped, never fatal. */
+export async function readArchive(cwd, { home = homedir() } = {}) {
+  let text = "";
+  try {
+    text = await readFile(archivePathFor(cwd, home), "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      /* a half-written last line after a crash — skip it */
+    }
+  }
+  return out;
+}
+
+/** The database copy of an archived conversation: its own record, beside the live one. */
+export function archivedWorkspaceKey(liveKey, at) {
+  return `${liveKey}:archived:${at}`;
+}

package/gonext_agent_chat.py

@@ -6115,6 +6115,59 @@ def _shell_op_tokens(command):
     return [t for t in toks if t in _SHELL_OP_TOKENS or _REDIRECT_TOKEN_RE.match(t)]
 
 
+# How far explore() (task #276) may search before it must answer. Its own steps are cheap —
+# a fresh, small context — but it is still a model call each.
+_EXPLORE_MAX_STEPS = 12
+
+
+def _and_chain_parts(command):
+    """`A && B && C` → ["A", "B", "C"]; anything else → None. (task #274)
+
+    SAVING STEPS WITHOUT A SHELL. A build → install → launch sequence was one run_command call
+    per command, and every call is a full model step that resends the whole prompt — a 29-step
+    Android turn cost ~600k input tokens. Claude Code runs such a line in one Bash call; gu
+    keeps its no-shell rule (an injected `; curl … | sh` stays impossible by construction) and
+    instead runs an `&&` chain ITSELF: each part through the normal policy, in order, stopping
+    at the first failure — which is exactly what `&&` means.
+
+    Only unquoted `&&` separates; quotes and backslashes are respected, so `git commit -m 'a &&
+    b'` is one command. ANY other shell syntax (|, ;, ||, &, <, >, `, $( ) → None, so the caller's
+    existing refusal explains it. An empty part (`a && && b`, `a &&`) → None too.
+    """
+    s = command or ""
+    parts, cur, q, saw, i = [], [], None, False, 0
+    while i < len(s):
+        c = s[i]
+        if q:
+            cur.append(c)
+            if c == q:
+                q = None
+            elif c == "\\" and q == '"' and i + 1 < len(s):
+                cur.append(s[i + 1])
+                i += 1
+        elif c in "'\"":
+            q = c
+            cur.append(c)
+        elif c == "\\" and i + 1 < len(s):
+            cur.append(c)
+            cur.append(s[i + 1])
+            i += 1
+        elif s.startswith("&&", i):
+            parts.append("".join(cur).strip())
+            cur, saw = [], True
+            i += 2
+            continue
+        elif c in "|;&<>`" or s.startswith("$(", i):
+            return None
+        else:
+            cur.append(c)
+        i += 1
+    parts.append("".join(cur).strip())
+    if q or not saw or any(not p for p in parts):
+        return None
+    return parts
+
+
 def _shell_syntax_error(command, argv):
     """Why this command cannot do what it says, or None. (task #204)
 
@@ -6166,10 +6219,13 @@ def _shell_syntax_error(command, argv):
 
     found = _shell_op_tokens(command)
     ops = [t for t in found if t in _SHELL_OP_TOKENS]
+    # Name what is actually unsupported: in `a && b | c` the && is fine, the | is not (#274).
+    ops = [o for o in ops if o != "&&"] or ops
     if ops:
         return ("Error: that command did NOT fully run. " + _no_shell + "'" + ops[0]
                 + "' was passed as a literal argument and everything after it never executed. "
-                "Run ONE command per call, and use the cwd argument to choose the directory.")
+                "Only && chains work (they run in order and stop at the first failure); for anything "
+                "else run one command per call, and use the cwd argument to choose the directory.")
 
     redirects = [t for t in found if _REDIRECT_TOKEN_RE.match(t)]
     if redirects:
@@ -7920,7 +7976,7 @@ def run_agent_chat(cfg):
         # change", the agent saved the task and then went on to do it (scaffold rule 8).
         + "WORK LIKE A SENIOR DEVELOPER — you OWN the task you were GIVEN until it DEMONSTRABLY works:\n"
         "    * OUTCOME over exit code: a command exiting 0 is NOT the goal. After any "
-        "state-changing step (start/build/install/edit), VERIFY the intended EFFECT "
+        "state-changing step (start/build/install/edit), VERIFY the intended EFFECT — in the same call when you can (`build && test`) — "
         "(server responds, artifact exists, test green, file contains the change) before "
         "moving on or finishing.\n"
         "    * On failure: read the error, fix the ROOT CAUSE (edit the code/config, "
@@ -7943,10 +7999,18 @@ def run_agent_chat(cfg):
         "truncated and slow every later step) → edit_lines to change it → run_command to "
         "VERIFY. edit_file only for a byte-exact unique string; create_file(overwrite=True) "
         "replaces a whole file in ONE call (no read+edit just to rewrite it).\n"
-        "    run_command LIMITS: there is NO shell — pipes `|`, redirects `>`, `&&` and "
-        "backticks do NOT work (one command per call, or python3 for anything that composes); "
-        "`sudo`/`su` are blocked; an interactive input() CLI fails with EOFError. A server or "
-        "GUI app is left RUNNING — stop_server closes it.\n"
+        "    EXPLORE FIRST for a broad question about the code (where is X handled, how does Y "
+        "work, what would a change to Z touch): explore(question) searches in a SEPARATE "
+        "context and returns a short summary with path:line references — its greps and reads "
+        "do not pile up here. Use grep_repo/read_file_lines directly when you already know "
+        "the file or the exact string.\n"
+        "    run_command CHAINS: put dependent commands in ONE call with && — e.g. "
+        "run_command(\"cd app && ./gradlew assembleDebug && adb install -r app/build/outputs/apk/debug/app-debug.apk\") "
+        "— they run in order, `cd` sets the folder for the rest, and the first failure stops the "
+        "chain. There is NO shell otherwise: pipes `|`, redirects `>`, `;`, `||` and backticks do "
+        "NOT work (use python3 for anything that composes). `sudo`/`su` are blocked; an "
+        "interactive input() CLI fails with EOFError. A server or GUI app is left RUNNING — "
+        "stop_server closes it.\n"
         "    DEPLOY: prefer deploy_web(local_dir, host, user, remote_path, domain) over "
         "hand-written scp/ssh/rsync (it rsyncs over your SSH key and finishes nginx when it "
         "can, else writes deploy.sh and returns the exact commands). KEY auth ONLY "
@@ -8049,8 +8113,10 @@ def run_agent_chat(cfg):
         f"Solve the TASK step by step (up to {max_steps} steps). At EACH step write a "
         "brief Thought, then ONE code block. BATCH INDEPENDENT LOOKUPS into that block — "
         "several reads, greps or listings whose arguments you already know, printing each "
-        "result under a header (up to about 8). Make ONE CHANGE per block (an edit, a file "
-        "write or a command): if a line fails, the lines after it never run. Take a separate "
+        "result under a header (up to about 8). A CHANGE AND ITS CHECK MAY SHARE A BLOCK "
+        "(task #275): e.g. edit_lines(...) then run_command(\"cd app && npm run build && npm test\") "
+        "— print every result and read them all, because a tool that fails RETURNS an error "
+        "instead of stopping the block. Keep UNRELATED changes in separate blocks. Take a separate "
         "step only when a call depends on a result you have not seen yet (e.g. web_search to "
         "find a URL, THEN fetch_url to read it). You SEE the Observation before the next step. "
         "When you have enough to answer, call final_answer(<your answer>) in a code block. "
@@ -11705,7 +11771,7 @@ def run_agent_chat(cfg):
             """Run a command inside a workspace that has run permission (e.g. 'npm test', 'npm run build', 'npm start', 'mvn test', 'python3 app.py'). One-shot commands return their output when they exit. If the command turns out to be a SERVER (keeps running and listens on a port), it is left RUNNING and its URL is reported. If it is a DESKTOP/GUI app (opens a window — tkinter, pygame, PyQt…), it is LAUNCHED and left running: its window appears on the user's Mac; tell them it's open. Both are stoppable via stop_server. Also allows DEPLOY commands (ssh/scp/rsync) — use non-interactive KEY auth (-o BatchMode=yes); never put a password in the command (there is no stdin). Note: an interactive CLI that reads stdin (input()) cannot be driven here — it will fail with EOFError; make it non-interactive or give the user the command to run themselves.
 
             Args:
-                command: the command line. Most commands run; no shell (so no pipes/redirects/&&), and sudo/su are blocked.
+                command: the command line. Chain dependent steps with && in ONE call ("cd app && npm ci && npm test"): they run in order, cd sets the folder, the first failure stops the rest. No other shell syntax (no pipes/redirects/;). sudo/su are blocked.
                 workdir: directory to run in. Empty = first registered workspace.
                 timeout_seconds: give up after this many seconds if the command neither exits nor starts a server (max 600).
             """
@@ -11754,6 +11820,55 @@ def run_agent_chat(cfg):
                     msg = "Error: empty command."
                     _last_obs["text"] = msg
                     return msg
+                # 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)
+                if _chain:
+                    _chain_start = _t.time()
+                    _cur_wd = wd
+                    _outs = []
+                    _stopped = ""
+                    for _k, _part in enumerate(_chain, 1):
+                        _hdr = f"── [{_k}/{len(_chain)}] {_part}"
+                        try:
+                            _pargv = shlex.split(_part)
+                        except ValueError as _e:
+                            _outs.append(f"{_hdr}\nError: {_e}")
+                            _stopped = _part
+                            break
+                        if _pargv and _pargv[0] == "cd":
+                            _target = _pargv[1] if len(_pargv) == 2 else ""
+                            _new = os.path.normpath(os.path.join(_cur_wd, os.path.expanduser(_target))) if _target else ""
+                            try:
+                                _new = _rag_read_allowed(_new) if _new else ""
+                            except Exception:  # noqa: BLE001
+                                _new = ""
+                            if not _new or not os.path.isdir(_new):
+                                _outs.append(f"{_hdr}\nError: no such folder: {_target or '(none given)'}")
+                                _stopped = _part
+                                break
+                            _cur_wd = _new
+                            _outs.append(f"{_hdr}\nnow in {_cur_wd}")
+                            continue
+                        # The executor gives a whole code block ~660s; keep the chain inside it.
+                        _left = 640 - (_t.time() - _chain_start)
+                        if _left < 5:
+                            _outs.append(f"{_hdr}\nError: out of time for this chain (~10 min) — run the rest in another call")
+                            _stopped = _part
+                            break
+                        _res = str(run_command(_part, _cur_wd, int(min(timeout_seconds or 180, 600, _left))))
+                        _outs.append(f"{_hdr}\n{_res}")
+                        if _res.startswith(("FAILED", "Error")):
+                            _stopped = _part
+                            break
+                    _rest = _chain[len(_outs):]
+                    _summary = (f"CHAIN STOPPED at [{len(_outs)}/{len(_chain)}] — the parts after it did NOT run"
+                                + (": " + " && ".join(_rest) if _rest else "")
+                                if _stopped else f"CHAIN DONE — all {len(_chain)} parts ran")
+                    result = _summary + "\n" + "\n".join(_outs)
+                    _last_obs["text"] = result
+                    return result
                 # REFUSE SHELL SYNTAX BEFORE SPAWNING (task #204). Without this, `cd X && Y`
                 # executes the `cd` PROGRAM — which exits 0 with no output — and the step is
                 # reported as a success that did nothing. Refusing costs one step; the observed
@@ -12180,6 +12295,60 @@ def run_agent_chat(cfg):
             # (S3 indexing) isn't configured.
             if not _RAG_AVAILABLE:
                 agent_tools += [list_dir, read_text_file]
+
+            # EXPLORE (task #276) — Claude Code's Explore subagent, for gu. Every grep and read
+            # used to land in THIS loop and be re-sent on every later step. explore() searches
+            # in a SEPARATE agent with a fresh context and hands back only a summary.
+            # READ-ONLY BY CONSTRUCTION: its tool list has no edit, write, command or network
+            # tool, so it cannot change anything whatever the text says.
+            _explore_tools = [symbol_context, grep_repo, read_file_lines, list_dir, read_text_file]
+            if _RAG_AVAILABLE:
+                _explore_tools.append(rag_search_workspace)
+
+            @tool
+            def explore(question: str) -> str:
+                """Answer a question about the code in a SEPARATE, read-only search — use it for broad questions ("where is X handled?", "how does Y work?", "which files would a change to Z touch?") that would otherwise take several greps and reads here. It returns a short summary with path:line references; its searching does not fill this conversation. It cannot edit or run anything.
+
+                Args:
+                    question: what to find out, e.g. "where is the splash screen logo set, and which files would changing it touch?"
+                """
+                q = (question or "").strip()
+                if not q:
+                    return "Error: explore needs a question."
+                _emit({"type": "step", "text": f"Exploring → {_clip(q, 70)}"})
+                sub_kwargs = dict(tools=list(_explore_tools), model=model, max_steps=_EXPLORE_MAX_STEPS)
+                if agent_kwargs.get("prompt_templates"):
+                    sub_kwargs["prompt_templates"] = agent_kwargs["prompt_templates"]
+                sub_kwargs["executor_kwargs"] = {"timeout_seconds": 300}
+                sub_kwargs["additional_authorized_imports"] = ["json", "re"]
+                # A PLAIN CodeAgent, not _ToolAgent: the turn's max-steps fallback and completion
+                # gate belong to the main loop and must not fire (or mutate its state) in here.
+                sub = CodeAgent(**sub_kwargs)
+                where = _WS_ACTIVE or _default_ws_root()
+                sub_task = (
+                    f"EXPLORE (read-only) the code in {where} and answer:\n{q}\n\n"
+                    "Use only the tools you have and BATCH independent lookups into one block. "
+                    "Finish with final_answer(<summary>): the answer in a few sentences, then the "
+                    "relevant files as `path:start-end — what is there`, one per line. At most "
+                    "about 250 words; never paste whole files.")
+                try:
+                    with contextlib.redirect_stdout(sys.stderr):
+                        out = sub.run(sub_task)
+                except Exception as e:  # noqa: BLE001
+                    msg = f"Error: explore failed: {type(e).__name__}: {_clip(str(e), 200)}"
+                    _last_obs["text"] = msg
+                    return msg
+                n = sum(1 for s in getattr(sub.memory, "steps", []) if type(s).__name__ == "ActionStep")
+                _emit({"type": "step", "text": f"Explored → {n} step(s), in its own context"})
+                _log(f"explore: {n} sub-step(s), {len(str(out))} chars back")
+                text = str(out).strip()
+                if len(text) > 4000:
+                    text = text[:4000] + "\n… [summary cut]"
+                result = f"[explore: {n} step(s) in a separate context]\n{text}"
+                _last_obs["text"] = result
+                return result
+
+            agent_tools.append(explore)
         # SKILLS (task #269): only offered when at least one exists, like every tool above.
         if _skills:
             @tool

package/gu-repl.mjs

@@ -122,6 +122,7 @@ import {
 } from "./terminal-layout.mjs";
 import { completedFlush } from "./completed-flush.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";
 import { unapprovedProjectServers } from "./mcp-command.mjs";
 import { readHooks } from "./hooks-config.mjs";
@@ -4372,15 +4373,16 @@ async function resetGlobalOutputTokens() {
   }
 }
 
-async function pushWorkspaceSync(cwd, history, { del = false } = {}) {
+async function pushWorkspaceSync(cwd, history, { del = false, key = "", name = "" } = {}) {
   if (!wsSync.enabled) return;
+  // `key` = a record of its own (an archived conversation, #278): sent whole, not cut to 40.
   const body = del
     ? { workspaceKey: workspaceKeyFor(cwd), delete: true }
     : {
-        workspaceKey: workspaceKeyFor(cwd),
-        name: wsSync.name || basename(cwd),
+        workspaceKey: key || workspaceKeyFor(cwd),
+        name: name || wsSync.name || basename(cwd),
         path: cwd,
-        history: history.slice(-MAX_PERSISTED_MESSAGES),
+        history: key ? history : history.slice(-MAX_PERSISTED_MESSAGES),
       };
   try {
     await fetch(`${apiBase}/api/worker/workspace-sync`, {
@@ -4923,17 +4925,55 @@ async function saveSession(cwd, history, { unfinishedTask = sessionUnfinishedTas
     // Non-fatal — losing session persistence should never crash or block the REPL.
     console.error(dim(`(session save failed: ${err.message})`));
   }
+  // EVERY message is kept in the folder's archive log (#278) — the session file keeps only
+  // the last MAX_PERSISTED_MESSAGES, and those used to be the only copy.
+  try {
+    archivedUpTo = await appendNew(cwd, history, archivedUpTo);
+  } catch (err) {
+    console.error(dim(`(conversation archive write failed: ${err.message})`));
+  }
   // Mirror to the cloud AFTER the local write (fire-and-forget; opt-in via wsSync).
   void pushWorkspaceSync(cwd, history);
 }
 
-async function clearSession(cwd) {
+/** How many of the in-memory history's messages are already in the archive log (#278). */
+let archivedUpTo = 0;
+
+/**
+ * /reset — a NEW conversation, the old one KEPT (#278). It used to unlink the whole session file
+ * (the conversation AND this folder's model/key/RAG/test-auto choices) and delete the database
+ * copy. Now: every message is in the archive log (a reset marker is added), the database gets an
+ * "archived" record of its own, and only the conversation in the session file is emptied.
+ * → where the archive is.
+ */
+async function startNewConversation(cwd, history) {
+  const n = history.length;
+  const at = new Date().toISOString();
   try {
-    await unlink(sessionFilePath(cwd));
-  } catch {
-    // Nothing on disk to clear — fine.
+    archivedUpTo = await appendNew(cwd, history, archivedUpTo);
+    await markReset(cwd, n);
+  } catch (err) {
+    console.error(dim(`(conversation archive write failed: ${err.message})`));
   }
-  void pushWorkspaceSync(cwd, [], { del: true }); // /reset removes the cloud copy too
+  if (n) {
+    void pushWorkspaceSync(cwd, history, {
+      key: archivedWorkspaceKey(workspaceKeyFor(cwd), at),
+      name: `${wsSync.name || basename(cwd)} — archived ${at.slice(0, 16).replace("T", " ")}`,
+    });
+  }
+  try {
+    await updateSessionFile(cwd, (raw) => {
+      raw.history = [];
+      raw.unfinishedTask = "";
+      raw.updatedAt = at;
+    });
+  } catch (err) {
+    console.error(dim(`(session save failed: ${err.message})`));
+  }
+  sessionUnfinishedTask = "";
+  void pushWorkspaceSync(cwd, []); // the live record: empty, not deleted
+  archivedUpTo = 0;
+  return archivePathFor(cwd);
 }
 
 /**
@@ -11115,6 +11155,8 @@ async function main() {
 
   const cwd = resolve(process.cwd());
   const history = await loadSession(cwd);
+  // The folder's archive log (#278): seeded with what it already has, the first time.
+  archivedUpTo = await seedArchive(cwd, history).catch(() => history.length);
   // A new gu session (task #270): the agent runs onStart hooks on the first turn it sees this id.
   await startHookSession(cwd);
   if (history.length > 0) {
@@ -11475,10 +11517,17 @@ async function main() {
       continue;
     }
     if (line === "/reset" || line === "/new") {
+      const kept = history.length;
+      const where = await startNewConversation(cwd, history);
       history.length = 0;
-      await clearSession(cwd);
       await startHookSession(cwd); // a fresh session: onStart hooks run again (#270)
-      console.log(GUTTER + dim("Session cleared — starting fresh.\n"));
+      console.log(
+        GUTTER + dim("New conversation started — this folder's settings are unchanged.") + "\n" +
+          GUTTER + dim(kept
+            ? `The previous one (${kept} message${kept === 1 ? "" : "s"}) is kept: ${where.replace(homedir(), "~")}` +
+              (wsSync.enabled ? ", and as an archived copy in the database." : ".")
+            : `Every earlier message of this folder is kept: ${where.replace(homedir(), "~")}.`) + "\n"
+      );
       continue;
     }
     if (line === "/tokens") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.745",
+  "version": "1.0.746",
   "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",
@@ -94,6 +94,7 @@
     "mcp-command.mjs",
     "hooks-config.mjs",
     "hooks-command.mjs",
+    "conversation-archive.mjs",
     "gonext_probe_agent.py",
     "gonext_agent_chat.py",
     "gu_mcp.py",