@tiens.nguyen/gonext-local-worker 1.0.196 → 1.0.198

package/gonext-local-worker.mjs

@@ -288,7 +288,7 @@ if (args[0] === "workspace") {
     //   gonext-local-worker workspace revert          → latest run
     //   gonext-local-worker workspace revert <runId>  → a specific run (see backups dir)
     const { readdirSync, existsSync: ex } = await import("node:fs");
-    const { copyFile, unlink } = await import("node:fs/promises");
+    const { copyFile, unlink, rmdir } = await import("node:fs/promises");
     const backupsRoot = join(homedir(), ".gonext", "workspace-backups");
     let runId = args[2] || "";
     if (!runId) {
@@ -321,6 +321,12 @@ if (args[0] === "workspace") {
           await unlink(c.path);
           deleted += 1;
           console.log(`  deleted  ${c.path}`);
+        } else if (c.action === "create_dir" && ex(c.path)) {
+          // rmdir only removes an EMPTY dir — a revert must never destroy content
+          // the user (or a later run) put inside the created folder afterwards.
+          await rmdir(c.path);
+          deleted += 1;
+          console.log(`  removed  ${c.path}/`);
         }
       } catch (err) {
         failed += 1;

package/gonext-repl.mjs

@@ -15,21 +15,28 @@
  * logs, exactly like a web question. The REPL polls the job and streams the persisted
  * chunks live into the terminal.
  *
+ * Conversation history is saved to ~/.gonext/sessions/<hash-of-folder-path>.json after
+ * every turn and reloaded on the next `gonext` in the SAME folder — so closing the
+ * terminal and coming back later still has context (e.g. "continue" after an
+ * interrupted investigation actually resumes it). /reset clears it.
+ *
  * Requires the worker daemon to be running (it claims the job).
- * Commands: /exit  /revert [runId]  /help      Ctrl-C stops following the current run.
+ * Commands: /exit  /reset  /revert [runId]  /help      Ctrl-C stops following the current run.
  */
-import { readFile, mkdir, writeFile } from "node:fs/promises";
+import { readFile, mkdir, writeFile, unlink } from "node:fs/promises";
 import { existsSync, statSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join, resolve, basename } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline";
+import { createHash } from "node:crypto";
 import dotenv from "dotenv";
 
 const DIR = dirname(fileURLToPath(import.meta.url));
 const ENV_FILE = join(homedir(), ".gonext", "worker.env");
 const WS_FILE = join(homedir(), ".gonext", "workspaces.json");
+const SESSIONS_DIR = join(homedir(), ".gonext", "sessions");
 
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
@@ -39,6 +46,7 @@ const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 // ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
 // code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
 const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
 // The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
@@ -65,6 +73,19 @@ const isRoutingLine = (line) =>
   /^(Routing your request…|Choosing a tool…|Composing a reply…|→ Agent mode.*|→ Chat reply)$/.test(
     line.trim()
   );
+// The edit tools (edit_lines/edit_file/create_file) emit a multi-line "edit card"
+// as one step event — a small stable line protocol rendered here as a colored diff
+// (bold header, red '-' / green '+' lines, dim line numbers). Shapes must stay in
+// sync with _render_edit_card in gonext_agent_chat.py:
+//   ⏺ Update(XeroForwardService.java)
+//     └ Replaced lines 19-19 with 1 line
+//       19 -     ...old...
+//       19 +     ...new...
+//       … (+3 more)
+const isEditCardHeader = (line) => /^⏺ (Update|Create)\(.+\)/.test(line);
+const EDIT_DIFF_RE = /^(\s{4})(\d+) ([-+]) (.*)$/;
+const isEditCardBody = (line) =>
+  /^\s*└ /.test(line) || EDIT_DIFF_RE.test(line) || /^\s{4}… /.test(line);
 
 // Playful words for the local "thinking…" ticker, reused verbatim from the worker's
 // thinking_words.txt sibling (falls back to a tiny built-in list if it's missing).
@@ -90,9 +111,11 @@ if (argv.includes("--help") || argv.includes("-h")) {
       "  -v, --verbose   show the agent's diagnostic logs ([gonext-agent] …) and python stderr\n" +
       "  -h, --help      this help\n\n" +
       "Auth comes from ~/.gonext/worker.env; models/budgets/RAG come from your web Settings.\n" +
-      "Inside the REPL: /exit · /revert [runId] · /help — Ctrl-C stops following a turn.\n" +
+      "Inside the REPL: /exit · /reset · /revert [runId] · /help — Ctrl-C stops following a turn.\n" +
       "Questions are enqueued like web questions and executed by the RUNNING\n" +
-      "gonext-local-worker daemon — its terminal shows the full [gonext-agent] logs."
+      "gonext-local-worker daemon — its terminal shows the full [gonext-agent] logs.\n" +
+      "Conversation history is saved per-folder in ~/.gonext/sessions and resumed next time\n" +
+      "you run `gonext` in the same folder; /reset forgets it and starts fresh."
   );
   process.exit(0);
 }
@@ -218,6 +241,60 @@ async function ensureWorkspace() {
   );
 }
 
+// ---------- conversation persistence, keyed by folder ----------
+// Without this, closing the terminal (or restarting `gonext`) loses ALL context — the
+// next session starts from a blank slate even though the USER remembers the earlier
+// investigation. "continue" (and general follow-ups) only make sense across restarts if
+// there's something real on disk to continue FROM. Same hash-keying scheme the worker's
+// python side already uses for per-URL RAG work dirs (sha256, 32 hex chars), applied
+// here to the workspace path instead so returning to the SAME folder reloads the SAME
+// conversation.
+function sessionFilePath(cwd) {
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 32);
+  return join(SESSIONS_DIR, `${hash}.json`);
+}
+
+// Cap what's kept on disk — the worker already truncates what it actually SENDS to the
+// model by a char budget (see "history: N prior turn(s), M chars (budget 8000)" in its
+// logs), so persisting more than that budget could ever use is just unbounded growth
+// for a long-lived folder with no benefit.
+const MAX_PERSISTED_MESSAGES = 40;
+
+async function loadSession(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return Array.isArray(raw?.history) ? raw.history : [];
+  } catch {
+    return [];
+  }
+}
+
+async function saveSession(cwd, history) {
+  try {
+    await mkdir(SESSIONS_DIR, { recursive: true });
+    const trimmed = history.slice(-MAX_PERSISTED_MESSAGES);
+    await writeFile(
+      sessionFilePath(cwd),
+      JSON.stringify(
+        { cwd, updatedAt: new Date().toISOString(), history: trimmed },
+        null,
+        2
+      ) + "\n"
+    );
+  } catch (err) {
+    // Non-fatal — losing session persistence should never crash or block the REPL.
+    console.error(dim(`(session save failed: ${err.message})`));
+  }
+}
+
+async function clearSession(cwd) {
+  try {
+    await unlink(sessionFilePath(cwd));
+  } catch {
+    // Nothing on disk to clear — fine.
+  }
+}
+
 // ---------- fetch the ready-to-run agent payload from user settings ----------
 async function fetchAgentPayload(messages) {
   const res = await fetch(`${apiBase}/api/worker/agent-payload`, {
@@ -374,6 +451,7 @@ async function runAgentTurn(history) {
   // them prints in a distinct grey (not dim, so it stands out from "Thought:" prose);
   // blank lines keep spacing; everything else commits dim to scrollback.
   let inCode = false;
+  let inEditCard = false; // inside a colored edit-card block (see isEditCardHeader)
   let lastWasBlank = true; // suppresses a leading blank line and collapses repeats
   // Chars of the CURRENT trailing (newline-less) `carry` line already flushed live — lets
   // a long plain-reply answer stream character-by-character instead of waiting for a "\n"
@@ -403,6 +481,35 @@ async function runAgentTurn(history) {
         lastContentAt = Date.now();
         continue;
       }
+      // Edit card (a file change made by the agent's edit tools) — rendered as a
+      // colored diff instead of dim prose. Checked before the <code> handling: the
+      // card is a step event, never part of the model's raw code stream, and the ⏺
+      // header is distinctive enough to never collide with generated Python.
+      if (isEditCardHeader(line)) {
+        onContent();
+        inEditCard = true;
+        process.stdout.write(green("⏺") + bold(line.slice(1)) + "\n");
+        lastWasBlank = false;
+        lastContentAt = Date.now();
+        continue;
+      }
+      if (inEditCard) {
+        if (isEditCardBody(line)) {
+          onContent();
+          const m = EDIT_DIFF_RE.exec(line);
+          if (m) {
+            // "    19 -  old text" → dim line number, red/green signed content.
+            const paintDiff = m[3] === "+" ? green : red;
+            process.stdout.write(`${m[1]}${dim(m[2])} ${paintDiff(`${m[3]} ${m[4]}`)}\n`);
+          } else {
+            process.stdout.write(dim(line) + "\n"); // "└ summary" / "… (+N more)"
+          }
+          lastWasBlank = false;
+          lastContentAt = Date.now();
+          continue;
+        }
+        inEditCard = false; // card ended — fall through to normal handling
+      }
       if (!inCode && isCodeOpenLine(line)) {
         stampIfThinking(); // hold/refresh the stamp; the code body commits it below
         inCode = true;
@@ -522,7 +629,14 @@ async function main() {
   }
   console.log(dim("Ask about this repo, or /help. Ctrl-C aborts a running turn.\n"));
 
-  const history = [];
+  const cwd = resolve(process.cwd());
+  const history = await loadSession(cwd);
+  if (history.length > 0) {
+    const turns = history.filter((m) => m.role === "user").length;
+    console.log(
+      dim(`Resumed session: ${turns} prior turn(s) from last time in this folder — /reset to start fresh.\n`)
+    );
+  }
   // With terminal:false, Ctrl-C is no longer intercepted by readline's raw-mode byte
   // scanning (rl.on("SIGINT", …) would never fire) — it now delivers a real OS SIGINT to
   // the process instead, which we catch directly here. Same behavior as before.
@@ -550,7 +664,18 @@ async function main() {
     const line = lineRaw.trim();
     if (line === "/exit" || line === "/quit") break;
     if (line === "/help") {
-      console.log(dim("  /exit — quit · /revert [runId] — undo the agent's file edits (latest run)"));
+      console.log(
+        dim(
+          "  /exit — quit · /revert [runId] — undo the agent's file edits (latest run) · " +
+            "/reset — forget this folder's saved conversation and start fresh"
+        )
+      );
+      continue;
+    }
+    if (line === "/reset" || line === "/new") {
+      history.length = 0;
+      await clearSession(cwd);
+      console.log(dim("Session cleared — starting fresh.\n"));
       continue;
     }
     if (line.startsWith("/revert")) {
@@ -571,6 +696,10 @@ async function main() {
       const { text: answer, shown } = await runAgentTurn(history);
       if (answer) {
         history.push({ role: "assistant", content: answer });
+        // Persist after every successful turn (not just on clean exit) — an ungraceful
+        // termination (killed terminal, force-quit) would otherwise lose the whole
+        // session even though most of it completed fine.
+        await saveSession(cwd, history);
         // A plain-reply answer already streamed live in the loop above — printing it
         // again here would just duplicate it; a blank line is enough for spacing.
         console.log(shown ? "" : `\n\n${answer}\n`);

package/gonext_agent_chat.py

@@ -599,6 +599,36 @@ _AGENT_KEYWORDS = re.compile(
     re.IGNORECASE,
 )
 
+# File/folder ACTION requests ("create a folder abc", "delete test.txt", "rename X to
+# Y", "list the files") are agent work whenever a workspace is registered. The generic
+# keyword list above cannot carry bare verbs like "create"/"delete" (they'd misroute
+# ordinary chat for non-workspace users), and the weak model classifier reliably
+# misreads these imperatives as how-to questions — answering with INSTRUCTIONS (a
+# mkdir tutorial) instead of DOING the action (the reported bug, task #40). Verb and
+# object noun must appear within one clause (no sentence punctuation between them).
+_WS_ACTION_RE = re.compile(
+    r"\b(?:create|make|add|new|delete|remove|rename|move|copy|list|show)\b"
+    r"[^.?!]{0,60}?"
+    r"\b(?:folders?|director(?:y|ies)|dirs?|files?|subfolders?)\b"
+    # Run/verify actions on the project itself ("start and test the project", "run
+    # the app", "build it and run the tests") — second reported miss (task #40):
+    # none of these words were keywords anywhere, so "help me start and test the
+    # project" got a step-by-step npm tutorial instead of the agent running them.
+    r"|\b(?:run|start|launch|build|test|install|compile|verify|stop|kill|restart)\b"
+    r"[^.?!]{0,60}?"
+    r"\b(?:project|app|application|server|site|website|tests?|build|dependenc(?:y|ies)|packages?)\b"
+    r"|\bmkdir\b",
+    re.IGNORECASE,
+)
+# Genuine how-to QUESTIONS about files/folders ("how do I create a folder in
+# Windows?") must stay plain chat — the user wants an explanation, not the action.
+# Deliberately FIRST-PERSON only ("can I…"): "can/could YOU create a folder" is a
+# polite request for the agent to DO it, not a how-to question.
+_HOWTO_PREFIX_RE = re.compile(
+    r"^(?:how|what|why|when|where|which|explain|can\s+i|could\s+i|should\s+i|is\s+it|does)\b",
+    re.IGNORECASE,
+)
+
 # Pure conversational openers/closers that never need a tool — a greeting, a thank-you, a
 # "who are you". Matching the WHOLE message (anchored) means "hi, fetch https://…" won't
 # match. These skip BOTH the model router call AND the heavy tool preamble → an instant
@@ -802,6 +832,20 @@ def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
         from openai import OpenAI
         client = OpenAI(base_url=base_url, api_key=api_key or "local",
                         max_retries=0, timeout=20)
+        # The classifier's question must reflect the capabilities that ACTUALLY exist
+        # this run — with a workspace registered, acting on files/code/commands is
+        # agent work too, and pronoun phrasings ("test it") that the deterministic
+        # keyword gates can't safely match land here. Without this clause the prompt
+        # was HTTP-only (it predates the workspace tools), so NO was the classifier's
+        # CORRECT answer to the wrong question for every workspace action.
+        ws_clause = (
+            "\nThe user also has a code workspace registered, so answer YES as well "
+            "when the task asks to read, edit, create, delete, or list files or "
+            "folders, run tests/builds/commands, or start, stop, or restart the "
+            "project or its server — even when phrased with pronouns like 'test it' "
+            "or 'run it'."
+        ) if _WS_ROOTS else ""
+        ws_q = ", files, code, or commands" if _WS_ROOTS else ""
         resp = _chat_create(
             client,
             model=model_id,
@@ -810,12 +854,13 @@ def _route(task_text: str, base_url: str, api_key: str, model_id: str) -> bool:
                     "You are a task classifier. Reply YES or NO only, no punctuation.\n"
                     "Answer YES if the task requires fetching data from an external network source "
                     "(URL, API, website, remote server), a web search / factual lookup, or the "
-                    "current date or time.\n"
-                    "Answer NO only if it is pure conversation, opinion, or simple text the "
-                    "assistant can answer directly without looking anything up."
+                    "current date or time."
+                    + ws_clause +
+                    "\nAnswer NO only if it is pure conversation, opinion, or simple text the "
+                    "assistant can answer directly without looking anything up or touching anything."
                 )},
                 {"role": "user", "content": (
-                    f"Does this task require fetching data from an external network source?\n\n"
+                    f"Does this task require using tools (network{ws_q})?\n\n"
                     f"Task: {task_text}\n\nYES or NO:"
                 )},
             ],
@@ -1844,11 +1889,137 @@ def _workspace_overview(roots, max_entries: int = 40) -> str:
     return "\n".join(parts)
 
 
+def _turn_checkpoint_path(workspace: str) -> str:
+    """Path to the interrupted-turn checkpoint for a given workspace. Keyed by a hash
+    of the workspace path (same sha256-slice convention as _rag_source_key) — but a
+    separate file/purpose from the REPL's own ~/.gonext/sessions: this holds one
+    in-PROGRESS turn's step trace, written incrementally as the agent works, not
+    completed Q&A history."""
+    import hashlib
+    import os
+    h = hashlib.sha256(workspace.encode("utf-8")).hexdigest()[:32]
+    base = os.path.join(os.path.expanduser("~"), ".gonext", "agent-turns")
+    os.makedirs(base, exist_ok=True)
+    return os.path.join(base, f"{h}.json")
+
+
+def _write_turn_checkpoint(workspace: str, task: str, steps: list) -> None:
+    """Overwrite the checkpoint for this workspace with the CURRENT turn's step trace so
+    far. Called after every agent step (see step_callback). If the process dies mid-turn
+    (network drop, kill, crash) before any final answer is ever emitted, this file
+    survives on disk and the NEXT turn in this workspace recovers it instead of silently
+    re-investigating from scratch — see _load_and_clear_turn_checkpoint."""
+    import json
+    import os
+    try:
+        path = _turn_checkpoint_path(workspace)
+        tmp = path + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump({"task": task, "steps": steps}, f)
+        os.replace(tmp, path)
+    except Exception as e:  # noqa: BLE001
+        _log(f"turn checkpoint write failed (non-fatal): {e}")
+
+
+def _load_and_clear_turn_checkpoint(workspace: str):
+    """Read a leftover checkpoint (if any) from a prior turn in this workspace that
+    never reached a graceful finish, then delete it — its content is about to be folded
+    into the NEW turn's context, and the new turn starts writing its own fresh
+    checkpoint from here. Returns None if there's nothing to recover."""
+    import json
+    import os
+    path = _turn_checkpoint_path(workspace)
+    data = None
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        return None
+    except Exception as e:  # noqa: BLE001
+        _log(f"turn checkpoint read failed (non-fatal): {e}")
+        return None
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+    return data
+
+
+def _turn_checkpoint_exists(workspace: str) -> bool:
+    """Non-consuming probe: does an interrupted turn survive on disk for this
+    workspace? Routing needs to KNOW there's work to resume (to force agent mode on a
+    bare 'continue') without destroying it — the read-and-delete consume happens later,
+    only on the agent path, where the recovered trace is actually fed to a model."""
+    import os
+    return os.path.exists(_turn_checkpoint_path(workspace))
+
+
+def _clear_turn_checkpoint(workspace: str) -> None:
+    """Delete the checkpoint once a turn reaches ANY graceful finish (full success, the
+    max-steps fallback, or a successful degrade-to-plain-reply) — that turn's findings
+    are already captured in the final answer pushed to conversation history, so the raw
+    step trace is no longer needed for crash recovery."""
+    import os
+    try:
+        os.remove(_turn_checkpoint_path(workspace))
+    except OSError:
+        pass
+
+
+def _render_edit_card(action: str, path: str, summary: str,
+                      removed=None, added=None,
+                      max_removed: int = 8, max_added: int = 12) -> str:
+    """Multi-line terminal-friendly summary of a file edit, emitted as ONE step event.
+
+    The line shapes are a small stable protocol the REPL colorizes (bold header,
+    red '-' lines, green '+' lines, dim line numbers) — keep them in sync with the
+    isEditCardHeader/EDIT_DIFF_RE regexes in gonext-repl.mjs. The web thinking panel
+    shows the same text as-is (the 4-space indent renders as a monospace block in
+    markdown), so no web change is needed.
+
+        ⏺ Update(XeroForwardService.java)
+          └ Replaced lines 19-19 with 1 line
+            19 -     ...old text...
+            19 +     ...new text...
+    """
+    import os
+    lines = [f"⏺ {action}({os.path.basename(path)})", f"  └ {summary}"]
+
+    def _fmt(entries, sign, cap):
+        out = []
+        for i, (no, txt) in enumerate(entries):
+            if i >= cap:
+                out.append(f"    … (+{len(entries) - cap} more)")
+                break
+            # NOT _clip() — that collapses ALL whitespace, destroying the code's
+            # leading indentation, which a diff needs to stay readable.
+            t = txt.rstrip()
+            if len(t) > 160:
+                t = t[:159] + "…"
+            out.append(f"    {no} {sign} {t}")
+        return out
+
+    if removed:
+        lines += _fmt(removed, "-", max_removed)
+    if added:
+        lines += _fmt(added, "+", max_added)
+    return "\n".join(lines)
+
+
 def _ws_write_allowed(path: str) -> str:
     """Resolve `path` for WRITING: must be inside a registered workspace and never
     inside its .git/ internals (agents must not corrupt version control)."""
     import os
-    rp = os.path.realpath(path)
+    p = (path or "").strip()
+    # Anchor RELATIVE paths to the active/first workspace root — the worker daemon's
+    # own cwd is ~, so a bare "abc" would otherwise resolve to ~/abc and be rejected
+    # even though the user plainly means <workspace>/abc. Mirrors _rag_read_allowed.
+    if p and not os.path.isabs(os.path.expanduser(p)):
+        base = _WS_ACTIVE or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "")
+        if base:
+            p = os.path.join(base, p)
+    rp = os.path.realpath(os.path.expanduser(p))
     w = _ws_for_path(rp)
     if w is None:
         raise ValueError(
@@ -1862,7 +2033,7 @@ def _ws_write_allowed(path: str) -> str:
 
 
 _WS_RUN_ID = None  # backup folder for this run, created lazily on first change
-_WS_CHANGES: list = []  # [{"action": "edit"|"create", "path": str, "backup": str|None}]
+_WS_CHANGES: list = []  # [{"action": "edit"|"create"|"create_dir", "path": str, "backup": str|None}]
 
 
 def _ws_backup_root() -> str:
@@ -1915,6 +2086,77 @@ _WS_RUN_ALLOWED = {
     "rspec", "bundle", "php", "composer", "tsc", "jest", "vitest",
 }
 
+# ---- background servers (behavior-detected, command-agnostic) ----
+# run_command classifies a command by OBSERVED BEHAVIOR, never by its text: if the
+# process keeps running AND starts LISTENing on a TCP port, it IS a server — npm start,
+# bun dev, a custom `make serve`, anything. (An earlier version pattern-matched command
+# names like "npm start"; rejected as unwinnable hardcode — same lesson as task #37.)
+# Detected servers are left running in their own process group (start_new_session),
+# recorded in ~/.gonext/servers.json, and stoppable via the stop_server tool.
+
+
+def _ws_pgroup_pids(pgid: int) -> list:
+    """Live pids in a process group (the server + everything it spawned)."""
+    import subprocess
+    try:
+        out = subprocess.run(["pgrep", "-g", str(pgid)],
+                             stdout=subprocess.PIPE, text=True, timeout=5)
+        return [int(x) for x in out.stdout.split()]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def _ws_listening_ports(pgid: int) -> list:
+    """TCP ports the process group is LISTENing on — the behavioral definition of
+    'this command is a server'. Empty when none (or lsof/pgrep unavailable)."""
+    import subprocess
+    pids = _ws_pgroup_pids(pgid)
+    if not pids:
+        return []
+    try:
+        out = subprocess.run(
+            ["lsof", "-a", "-p", ",".join(map(str, pids)),
+             "-iTCP", "-sTCP:LISTEN", "-P", "-n"],
+            stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, timeout=5)
+        ports = set()
+        for line in out.stdout.splitlines()[1:]:
+            m = re.search(r":(\d+)\s+\(LISTEN\)", line)
+            if m:
+                ports.add(int(m.group(1)))
+        return sorted(ports)
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def _ws_servers_path() -> str:
+    import os
+    base = os.path.join(os.path.expanduser("~"), ".gonext")
+    os.makedirs(base, exist_ok=True)
+    return os.path.join(base, "servers.json")
+
+
+def _ws_load_servers(prune: bool = True) -> list:
+    """Registry of background servers we started. `prune` drops entries whose
+    process group is gone (crashed or stopped outside of us)."""
+    import json as _json
+    try:
+        with open(_ws_servers_path(), encoding="utf-8") as fh:
+            servers = _json.load(fh).get("servers", [])
+    except Exception:  # noqa: BLE001
+        return []
+    if prune:
+        servers = [s for s in servers if _ws_pgroup_pids(int(s.get("pgid", 0)))]
+    return servers
+
+
+def _ws_save_servers(servers: list) -> None:
+    import json as _json
+    try:
+        with open(_ws_servers_path(), "w", encoding="utf-8") as fh:
+            _json.dump({"servers": servers}, fh, indent=2)
+    except OSError as e:
+        _log(f"servers.json write failed: {e}")
+
 
 def _ws_scrubbed_env() -> dict:
     """Minimal child env for run_command. The worker process env holds secrets
@@ -1923,7 +2165,11 @@ def _ws_scrubbed_env() -> dict:
     import os
     keep = ("PATH", "HOME", "LANG", "LC_ALL", "TMPDIR", "SHELL", "USER", "TERM",
             "JAVA_HOME", "GOPATH", "CARGO_HOME", "NVM_DIR")
-    return {k: os.environ[k] for k in keep if k in os.environ}
+    env = {k: os.environ[k] for k in keep if k in os.environ}
+    # CI=1 makes watch-mode test runners (CRA's `npm test`, jest --watch) run ONCE and
+    # exit instead of sitting in interactive watch mode until the timeout kills them.
+    env["CI"] = "1"
+    return env
 
 
 def _ws_distill_output(out: str, cap_head: int = 1200, cap_tail: int = 4000) -> str:
@@ -2246,11 +2492,27 @@ def run_agent_chat(cfg):
         the AGENT, not plain chat — plain chat has zero tool access and can never
         actually continue a stalled grep_repo/read_file_lines investigation, which is
         exactly the reported bug: 'continue' silently degraded to a tool-less reply that
-        could only apologize, never resume. Gated tightly (short continuation phrase +
-        genuinely-interrupted prior turn) so it doesn't misfire on an unrelated 'continue'
-        after a normal, already-complete answer."""
+        could only apologize, never resume. Two independent interruption signals:
+        (a) our own interrupted-investigation marker in the prior assistant turn (the
+        max-steps note or the degrade-fallback note); (b) an on-disk turn checkpoint for
+        this workspace — a CRASHED turn leaves NO history marker at all (the REPL
+        discards failed turns entirely, by design — task #35), so the checkpoint file is
+        the only surviving evidence there is work to resume. Gated tightly (short
+        continuation phrase + a genuine interruption signal) so it doesn't misfire on an
+        unrelated 'continue' after a normal, already-complete answer."""
         return bool(_CONTINUE_CUE.match((latest_user_text or "").strip())
-                    and _prior_turn_was_interrupted())
+                    and (_prior_turn_was_interrupted()
+                         or (_WS_ACTIVE and _turn_checkpoint_exists(_WS_ACTIVE))))
+
+    def _ws_action_pending() -> bool:
+        """An imperative file/folder action ("create a folder abc") with a registered
+        workspace must reach the AGENT — plain chat can only answer with mkdir
+        instructions (the reported task-#40 bug). How-to QUESTIONS are excluded: the
+        user asking "how do I create a folder in Windows?" wants an explanation."""
+        t = (latest_user_text or "").strip()
+        return bool(_WS_AVAILABLE
+                    and not _HOWTO_PREFIX_RE.match(t)
+                    and _WS_ACTION_RE.search(t))
 
     # Route: does this task need HTTP tool use? A trivial greeting/thank-you/"who are you"
     # is caught LOCALLY (no model classifier call, no tool preamble) → straight to a fast
@@ -2275,6 +2537,13 @@ def run_agent_chat(cfg):
         _log("router → YES (continuation of an interrupted investigation)")
         _emit({"type": "step", "text": "→ Agent mode (continuing)"})
         needs_agent = True
+    # An imperative file/folder action with a workspace registered must be DONE with
+    # tools, not answered with terminal instructions — the classifier misreads these
+    # as how-to questions (task #40: "create a folder abc" got a mkdir tutorial).
+    if not needs_agent and _ws_action_pending():
+        _log("router → YES (workspace file/folder action)")
+        _emit({"type": "step", "text": "→ Agent mode (workspace action)"})
+        needs_agent = True
 
     if not needs_agent:
         _log("router: plain chat (no HTTP needed)")
@@ -2518,6 +2787,42 @@ def run_agent_chat(cfg):
         "create_pdf / final_answer.\n"
         "- Do NOT put final_answer outside the code block.\n\n"
     )
+    # Recover an interrupted prior turn's step trace, if one survives on disk (crash/
+    # connection drop mid-investigation — see _write_turn_checkpoint). Consumed HERE,
+    # inside the agent path only, and not up front before routing: task_text feeds only
+    # the agent prompt (plain chat sends the raw `messages` list to _plain_reply), so an
+    # earlier consume would let any plain-chat-routed message delete the checkpoint
+    # without any model ever seeing it — silently destroying the recovery data.
+    if _WS_ACTIVE:
+        _ck = _load_and_clear_turn_checkpoint(_WS_ACTIVE)
+        if _ck and _ck.get("steps"):
+            _ck_steps = _ck["steps"]
+            # Newest-first budget walk (same pattern as the history condenser above):
+            # the latest steps matter most for resuming, and an uncapped 12-step trace
+            # (~25K chars at the per-step clip limits) would dominate prompt-eval on a
+            # slow coding server — the user's box already takes 3+ min at half that.
+            _kept, _used = [], 0
+            for _i, _s in enumerate(reversed(_ck_steps)):
+                if not isinstance(_s, dict):
+                    _s = {"did": str(_s), "found": ""}
+                _seg = (f"Step {_s.get('step', len(_ck_steps) - _i)}:\n"
+                        f"  Did: {_s.get('did', '')}\n  Found: {_s.get('found', '')}")
+                if _used + len(_seg) > 5000 and _kept:
+                    _kept.append(f"(…{len(_ck_steps) - len(_kept)} earlier step(s) omitted)")
+                    break
+                _kept.append(_seg)
+                _used += len(_seg)
+            _kept.reverse()
+            _log(f"recovered {len(_ck_steps)} step(s) from an interrupted prior turn "
+                 f"in this workspace ({_used} chars folded into the task)")
+            task_text += (
+                "\n\nNOTE: your previous attempt at a task in this workspace was "
+                "interrupted before finishing (crash or connection drop) — here is "
+                "exactly what was already done and found. Do NOT repeat these steps; "
+                "continue the investigation/edit from here:\n"
+                f"Previous task: {_ck.get('task', '')}\n" + "\n".join(_kept)
+            )
+
     # Lead with the TASK so the weak model anchors on what's actually being asked —
     # not on the tool reference below. (Previously the hint led with the date, and the
     # 3B model treated every message as a date question.)
@@ -2535,6 +2840,13 @@ def run_agent_chat(cfg):
     # tool returned (no extra model call) if the loop ends without final_answer.
     _last_obs: dict = {"text": ""}
 
+    # Set by provide_final_answer when it had to synthesize a PARTIAL answer at the
+    # step budget. Read by the graceful-finish checkpoint clear: a max-steps ending
+    # surfaces only the LAST observation into history, so the full step trace must
+    # survive on disk for a follow-up "continue" to genuinely resume — clearing it
+    # there would leave the next turn a ~500-char condensed history line instead.
+    _maxsteps_partial: dict = {"hit": False}
+
     # Deterministic loop-breaker. Weak models often repeat the SAME search/fetch over and
     # over (hoping for a "more complete" result) and never converge, burning the whole step
     # budget. We remember each (tool, arg) signature; on a repeat we DON'T re-run it —
@@ -2908,6 +3220,11 @@ def run_agent_chat(cfg):
         _last_obs["text"] = out
         return out
 
+    # Growing record of this turn's steps, persisted to disk after each one via
+    # _write_turn_checkpoint (inside step_callback below) — see _load_and_clear_turn_
+    # checkpoint above for how a crashed/interrupted turn gets recovered on the next run.
+    _turn_steps: list = []
+
     def step_callback(step_log):
         step_num = getattr(step_log, "step_number", "?")
 
@@ -2929,6 +3246,22 @@ def run_agent_chat(cfg):
             text = _summarise_step(step_log)
         except Exception as e:  # noqa: BLE001
             text = f"Step: {e}"
+        # Checkpoint every real step to disk so an interrupted turn (crash/connection
+        # drop) can be recovered on the next run in this workspace. Deliberately uses
+        # the FULL model_output + FULL _last_obs here, NOT the one-line `text` summary
+        # above — `text` is clipped to a single first line for the live terminal display
+        # and would lose most of what the step actually found (e.g. a grep_repo hit list
+        # is up to 100 lines; `_summarise_step` keeps only the "N hits" header line).
+        # `_last_obs["text"]` already holds the CURRENT step's full tool output — every
+        # workspace/RAG tool sets it on every return path (see task #38) specifically so
+        # the max-steps fallback can surface it; reusing it here for the same reason.
+        if _WS_ACTIVE and (model_output or _last_obs.get("text")):
+            _turn_steps.append({
+                "step": step_num,
+                "did": _clip(str(model_output or "").strip(), 600),
+                "found": _clip(str(_last_obs.get("text") or "").strip(), 1500),
+            })
+            _write_turn_checkpoint(_WS_ACTIVE, latest_user_text, _turn_steps)
         # Skip emitting if there's nothing beyond the tool name — the tool already
         # emitted its own step event with the actual response above.
         if not text or text.rstrip().endswith("| →"):
@@ -3366,6 +3699,7 @@ def run_agent_chat(cfg):
                     _log(f"deterministic create_pdf did not succeed: {str(out)[:120]}")
                 except Exception as e:  # noqa: BLE001
                     _log(f"deterministic create_pdf error: {type(e).__name__}: {e}")
+            _maxsteps_partial["hit"] = True
             text = (_last_obs.get("text") or "").strip()
             if text:
                 _log(f"max-steps fallback (last tool obs) → {text[:80]}")
@@ -3778,11 +4112,17 @@ def run_agent_chat(cfg):
                 new_lines = new_content.splitlines(keepends=True)
                 if new_lines and not new_lines[-1].endswith("\n"):
                     new_lines[-1] += "\n"
+                old_lines = lines[s - 1:e]
                 lines[s - 1:e] = new_lines
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.writelines(lines)
                 _ws_record_change("edit", rp, backup)
-                _emit({"type": "step", "text": f"Edited {os.path.basename(rp)} lines {s}-{e}"})
+                _emit({"type": "step", "text": _render_edit_card(
+                    "Update", rp,
+                    f"Replaced lines {s}-{e} with {len(new_lines)} line(s)",
+                    removed=[(s + i, t) for i, t in enumerate(old_lines)],
+                    added=[(s + i, t) for i, t in enumerate(new_lines)],
+                )})
                 shown = "".join(f"{i}: {lines[i - 1]}" for i in
                                 range(max(1, s - 2), min(len(lines), s + len(new_lines) + 1) + 1))
                 out = (f"Replaced lines {s}-{e} of {rp} with {len(new_lines)} line(s). "
@@ -3826,7 +4166,15 @@ def run_agent_chat(cfg):
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(text.replace(old_string, new_string, 1))
                 _ws_record_change("edit", rp, backup)
-                _emit({"type": "step", "text": f"Edited {os.path.basename(rp)}"})
+                start_no = text[:text.index(old_string)].count("\n") + 1
+                old_ls = old_string.splitlines() or [""]
+                new_ls = new_string.splitlines() or [""]
+                _emit({"type": "step", "text": _render_edit_card(
+                    "Update", rp,
+                    f"Replaced {len(old_ls)} line(s) at line {start_no}",
+                    removed=[(start_no + i, t) for i, t in enumerate(old_ls)],
+                    added=[(start_no + i, t) for i, t in enumerate(new_ls)],
+                )})
                 out = f"Replaced 1 occurrence in {rp}. Backup saved."
                 _last_obs["text"] = out
                 return out
@@ -3854,7 +4202,12 @@ def run_agent_chat(cfg):
                 with open(rp, "w", encoding="utf-8") as fh:
                     fh.write(content)
                 _ws_record_change("create", rp, None)
-                _emit({"type": "step", "text": f"Created {os.path.basename(rp)}"})
+                content_ls = content.splitlines() or [""]
+                _emit({"type": "step", "text": _render_edit_card(
+                    "Create", rp,
+                    f"Added {len(content_ls)} line(s)",
+                    added=[(i + 1, t) for i, t in enumerate(content_ls)],
+                )})
                 out = f"Created {rp} ({len(content)} chars)."
                 _last_obs["text"] = out
                 return out
@@ -3863,19 +4216,54 @@ def run_agent_chat(cfg):
                 _last_obs["text"] = msg
                 return msg
 
+        @tool
+        def create_folder(path: str) -> str:
+            """Create a folder (and any missing parent folders) inside a registered workspace. Use this to ACTUALLY create a folder/directory the user asked for — never answer with mkdir instructions.
+
+            Args:
+                path: new folder path inside a workspace (a relative path resolves against the workspace root).
+            """
+            try:
+                rp = _ws_write_allowed((path or "").strip())
+                import os
+                if os.path.isdir(rp):
+                    msg = f"Folder already exists: {rp}"
+                    _last_obs["text"] = msg
+                    return msg
+                if os.path.exists(rp):
+                    msg = f"Error: {path} already exists and is a file, not a folder."
+                    _last_obs["text"] = msg
+                    return msg
+                os.makedirs(rp)
+                # "create_dir" (not "create") — revert removes it with rmdir, which only
+                # deletes EMPTY dirs, so a revert can never destroy content the user
+                # added inside it afterwards. unlink (the "create" revert) fails on dirs.
+                _ws_record_change("create_dir", rp, None)
+                _emit({"type": "step", "text": _render_edit_card(
+                    "Create", rp, "New folder")})
+                out = f"Created folder {rp}."
+                _last_obs["text"] = out
+                return out
+            except Exception as ex:  # noqa: BLE001
+                msg = f"Error: create_folder failed: {type(ex).__name__}: {ex}"
+                _last_obs["text"] = msg
+                return msg
+
         @tool
         def run_command(command: str, workdir: str = "", timeout_seconds: int = 180) -> str:
-            """Run a build/test command inside a workspace that has run permission (e.g. 'npm test', 'mvn test', 'pytest'). Use to VERIFY code changes; read the output and fix failures.
+            """Run a command inside a workspace that has run permission (e.g. 'npm test', 'npm run build', 'npm start', 'mvn test'). 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 in the background and its URL is reported — tell the user the URL, and use stop_server to stop it when asked.
 
             Args:
-                command: the command line (build/test runners only; no shells or sudo).
+                command: the command line (allowlisted runners only; no shells or sudo).
                 workdir: directory to run in. Empty = first registered workspace.
-                timeout_seconds: kill the command after this many seconds (max 600).
+                timeout_seconds: give up after this many seconds if the command neither exits nor starts a server (max 600).
             """
             try:
                 import os
                 import shlex
+                import signal
                 import subprocess
+                import time as _t
                 wd = _rag_read_allowed((workdir or "").strip() or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "."))
                 w = _ws_for_path(wd)
                 if w is None or not w.get("allowRun"):
@@ -3895,23 +4283,128 @@ def run_agent_chat(cfg):
                     return msg
                 _emit({"type": "step", "text": f"Running → {command[:70]}"})
                 t = max(5, min(int(timeout_seconds or 180), 600))
-                # Scrubbed env: repo test scripts must never see worker secrets.
-                proc = subprocess.run(
-                    argv, cwd=wd, env=_ws_scrubbed_env(), timeout=t,
-                    stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+                # Own process group (start_new_session) + output to a log file. This is
+                # what lets a server OUTLIVE this job process, and what lets a timeout
+                # kill take the runner's whole child tree (npm's node child etc. — the
+                # old subprocess.run timeout killed only the direct child, leaking it).
+                logs_dir = os.path.join(os.path.expanduser("~"), ".gonext", "run-logs")
+                os.makedirs(logs_dir, exist_ok=True)
+                log_path = os.path.join(logs_dir, f"{_t.strftime('%Y%m%d-%H%M%S')}-{os.getpid()}.log")
+                log_fh = open(log_path, "wb")
+                # Scrubbed env: repo scripts must never see worker secrets.
+                proc = subprocess.Popen(
+                    argv, cwd=wd, env=_ws_scrubbed_env(),
+                    stdout=log_fh, stderr=subprocess.STDOUT,
+                    start_new_session=True,
                 )
-                out = _ws_distill_output(proc.stdout or "")
-                status = "PASSED (exit 0)" if proc.returncode == 0 else f"FAILED (exit {proc.returncode})"
-                _emit({"type": "step", "text": f"Command {status.split()[0].lower()} → {command[:50]}"})
-                result = f"{status}\n{out}" if out.strip() else status
-                _last_obs["text"] = result
-                return result
-            except subprocess.TimeoutExpired:
-                msg = f"Error: command timed out after {timeout_seconds}s."
+                start = _t.time()
+
+                def _read_log() -> str:
+                    log_fh.flush()
+                    try:
+                        with open(log_path, "r", encoding="utf-8", errors="replace") as fh:
+                            return fh.read()
+                    except OSError:
+                        return ""
+
+                # Behavior classification loop — no command-name matching anywhere:
+                # exited → one-shot result; still running AND listening on a TCP port →
+                # it's a server, leave it running; neither by the deadline → kill group.
+                while True:
+                    rc = proc.poll()
+                    if rc is not None:
+                        out = _ws_distill_output(_read_log())
+                        status = "PASSED (exit 0)" if rc == 0 else f"FAILED (exit {rc})"
+                        _emit({"type": "step", "text": f"Command {status.split()[0].lower()} → {command[:50]}"})
+                        result = f"{status}\n{out}" if out.strip() else status
+                        _last_obs["text"] = result
+                        return result
+                    if _t.time() - start >= 3:
+                        ports = _ws_listening_ports(proc.pid)
+                        if ports:
+                            servers = _ws_load_servers()
+                            servers.append({
+                                "pgid": proc.pid, "pid": proc.pid, "command": command,
+                                "workdir": wd, "ports": ports, "log": log_path,
+                                "started_at": _t.strftime("%Y-%m-%d %H:%M:%S"),
+                            })
+                            _ws_save_servers(servers)
+                            urls = ", ".join(f"http://localhost:{p}" for p in ports)
+                            _emit({"type": "step", "text": f"Server up → {urls} (left running)"})
+                            tail = _ws_distill_output(_read_log())
+                            result = (f"RUNNING: '{command}' is up and listening — {urls} "
+                                      f"(pid {proc.pid}, log {log_path}). It stays running in "
+                                      "the background; use stop_server to stop it. "
+                                      f"Startup output:\n{tail}")
+                            _last_obs["text"] = result
+                            return result
+                    if _t.time() - start >= t:
+                        try:
+                            os.killpg(proc.pid, signal.SIGKILL)
+                        except OSError:
+                            pass
+                        tail = _ws_distill_output(_read_log())
+                        msg = (f"Error: command neither exited nor started a server within "
+                               f"{t}s — killed. Output so far:\n{tail}")
+                        _last_obs["text"] = msg
+                        return msg
+                    _t.sleep(2)
+            except Exception as ex:  # noqa: BLE001
+                msg = f"Error: run_command failed: {type(ex).__name__}: {ex}"
                 _last_obs["text"] = msg
                 return msg
+            finally:
+                try:
+                    log_fh.close()
+                except Exception:  # noqa: BLE001
+                    pass
+
+        @tool
+        def stop_server(port_or_pid: str = "") -> str:
+            """Stop a background server previously started by run_command. Use when the user asks to stop/kill the server.
+
+            Args:
+                port_or_pid: the server's port or pid (empty = the most recently started one).
+            """
+            try:
+                import os
+                import signal
+                import time as _t
+                servers = _ws_load_servers()
+                if not servers:
+                    msg = "No background servers are running."
+                    _last_obs["text"] = msg
+                    return msg
+                key = (port_or_pid or "").strip()
+                target = None
+                if key:
+                    for s in servers:
+                        if key == str(s.get("pid")) or any(key == str(p) for p in s.get("ports", [])):
+                            target = s
+                            break
+                    if target is None:
+                        listing = "; ".join(
+                            f"pid {s['pid']} ports {s.get('ports')} ({s['command']})" for s in servers)
+                        msg = f"No running server matches '{key}'. Running: {listing}"
+                        _last_obs["text"] = msg
+                        return msg
+                else:
+                    target = servers[-1]
+                pgid = int(target["pgid"])
+                try:
+                    os.killpg(pgid, signal.SIGTERM)
+                    _t.sleep(1.5)
+                    if _ws_pgroup_pids(pgid):
+                        os.killpg(pgid, signal.SIGKILL)
+                except OSError:
+                    pass
+                _ws_save_servers([s for s in servers if s is not target])
+                _emit({"type": "step", "text": f"Server stopped → {target['command'][:50]}"})
+                out = f"Stopped '{target['command']}' (pid {target['pid']}, ports {target.get('ports')})."
+                _last_obs["text"] = out
+                return out
             except Exception as ex:  # noqa: BLE001
-                msg = f"Error: run_command failed: {type(ex).__name__}: {ex}"
+                msg = f"Error: stop_server failed: {type(ex).__name__}: {ex}"
                 _last_obs["text"] = msg
                 return msg
 
@@ -3929,7 +4422,7 @@ def run_agent_chat(cfg):
                             rag_index, rag_add, rag_search]
         if _WS_AVAILABLE:
             agent_tools += [grep_repo, read_file_lines, edit_lines, edit_file,
-                            create_file, run_command]
+                            create_file, create_folder, run_command, stop_server]
             # list_dir/read_text_file are needed for workspace browsing even when RAG
             # (S3 indexing) isn't configured.
             if not _RAG_AVAILABLE:
@@ -3978,6 +4471,16 @@ def run_agent_chat(cfg):
         final_text = _strip_tool_tags(str(result).strip()) or "[No result]"
         _log(f"done (deterministic, no summarizer call): {len(final_text)} chars")
         _emit({"type": "final", "text": final_text})
+        # Clear the step checkpoint ONLY on a genuinely complete finish (the model's own
+        # final_answer, or a deterministic PDF delivery) — that content is now in the
+        # answer pushed to conversation history, so the raw trace is no longer needed.
+        # Kept when the turn ended PARTIALLY, in either way this can happen:
+        # - max-steps fallback (_maxsteps_partial): its answer surfaces only the LAST
+        #   observation, so a follow-up "continue" needs the full trace on disk;
+        # - degrade-to-plain-reply (except block below): its note carries only a
+        #   top-level file listing, not the step trace — same reasoning, never cleared.
+        if _WS_ACTIVE and not _maxsteps_partial["hit"]:
+            _clear_turn_checkpoint(_WS_ACTIVE)
     except Exception as e:  # noqa: BLE001
         # Config errors (wrong coding-model name/URL) must reach the user VERBATIM —
         # they contain the fix (the server's real model list). smolagents wraps model

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.196",
+  "version": "1.0.198",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",