@tiens.nguyen/gonext-local-worker 1.0.195 → 1.0.197

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,28 +15,38 @@
  * 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`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const blue = (s) => `\x1b[34m${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
@@ -45,7 +55,7 @@ const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
 const isFenceLine = (line) => line.trim() === "~~~";
 // The model's raw Python code blob is delimited by <code>/</code> lines. We don't print
-// the tag lines themselves, but the code IN BETWEEN prints in a distinct color (blue)
+// the tag lines themselves, but the code IN BETWEEN prints in a distinct grey (codeColor)
 // instead of dim prose, so it visually separates from the "Thought:" reasoning.
 const isCodeOpenLine = (line) => line.trim() === "<code>";
 const isCodeCloseLine = (line) => line.trim() === "</code>";
@@ -63,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).
@@ -88,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);
 }
@@ -127,16 +152,26 @@ if (!workerKey || !apiBase) {
 // readline stops managing the line/cursor itself; the OS's own canonical-mode terminal
 // still echoes keystrokes normally, and 'line' events fire exactly the same.
 const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+// Side effect of terminal:false above: readline no longer intercepts arrow keys for
+// command-history recall, so pressing ↑/↓/→/← (or Home/End/Delete) sends the RAW escape
+// bytes straight through as literal input — the OS's own canonical line discipline
+// doesn't understand them either, so they get echoed and end up IN the submitted line
+// once Enter is pressed (seen live: a task sent to the model started with a literal
+// "\x1b[A" from an accidental up-arrow press). Strip CSI escape sequences (ESC '[' …
+// final-byte) from every submitted line so stray arrow-key presses can't corrupt task
+// text sent to the model.
+const stripAnsiEscapes = (s) => String(s ?? "").replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "");
 const _lineQueue = [];
 let _lineWaiter = null;
 let _stdinClosed = false;
 rl.on("line", (l) => {
+  const clean = stripAnsiEscapes(l);
   if (_lineWaiter) {
     const w = _lineWaiter;
     _lineWaiter = null;
-    w(l);
+    w(clean);
   } else {
-    _lineQueue.push(l);
+    _lineQueue.push(clean);
   }
 });
 rl.on("close", () => {
@@ -206,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`, {
@@ -359,9 +448,10 @@ async function runAgentTurn(history) {
   // Split newly-arrived text into lines: heartbeats + ~~~ fences + the post-tool-call step
   // summary ("tool(...) | → result", redundant with the daemon's own terminal) are
   // swallowed; the model's <code>/</code> TAG lines are hidden but the code body between
-  // them prints in blue (not dim, so it stands out from "Thought:" prose); blank lines
-  // keep spacing; everything else commits dim to scrollback.
+  // 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"
@@ -391,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;
@@ -400,7 +519,7 @@ async function runAgentTurn(history) {
         if (isCodeCloseLine(line)) { inCode = false; lastContentAt = Date.now(); continue; }
         if (line.trim() === "") { lastContentAt = Date.now(); continue; } // skip blank lines in code
         onContent();
-        process.stdout.write(blue(line) + "\n");
+        process.stdout.write(codeColor(line) + "\n");
         lastWasBlank = false;
         continue;
       }
@@ -510,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.
@@ -538,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")) {
@@ -559,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

@@ -297,6 +297,15 @@ _EMAIL_CONFIRM = re.compile(
     re.IGNORECASE,
 )
 
+# A bare "continue"-style nudge — matched WHOLE-MESSAGE (anchored) so it only fires on a
+# short, unambiguous continuation cue, never a longer sentence that happens to contain
+# one of these words. See _continuation_pending().
+_CONTINUE_CUE = re.compile(
+    r"^(please\s+)?(continue|keep\s+going|go\s+on|resume|carry\s+on|try\s+again)"
+    r"[\s.!?]*$",
+    re.IGNORECASE,
+)
+
 
 def _email_allowed(addr, allow):
     """True if addr matches an allow-list entry — an exact address or a bare domain."""
@@ -590,6 +599,29 @@ _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"
+    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
@@ -1835,11 +1867,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(
@@ -1853,7 +2011,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:
@@ -2220,6 +2378,45 @@ def run_agent_chat(cfg):
         return bool(_EMAIL_AVAILABLE and _EMAIL_CONFIRM.search(latest_user_text or "")
                     and _prior_email_preview())
 
+    def _prior_turn_was_interrupted() -> bool:
+        """True if the immediately preceding assistant turn is one of OUR OWN
+        interrupted-investigation markers (the honest degrade-fallback note, or the
+        max-steps 'ran out of steps' note) — i.e. a genuine tool-use attempt started but
+        didn't finish, as opposed to a normal completed answer."""
+        for m in reversed(messages[:last_user_idx]):
+            if m.get("role") == "assistant":
+                c = m.get("content") or ""
+                return ("ran out of steps before finishing" in c
+                        or "couldn't finish the full investigation" in c)
+        return False
+
+    def _continuation_pending() -> bool:
+        """A bare 'continue'/'keep going' after an interrupted investigation must reach
+        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. 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()
+                         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
     # small-prompt reply. Otherwise ask the model classifier.
@@ -2236,6 +2433,20 @@ def run_agent_chat(cfg):
         _log("router → YES (email confirm pending)")
         _emit({"type": "step", "text": "→ Agent mode (email confirm)"})
         needs_agent = True
+    # A bare "continue" after WE reported an interrupted investigation must reach the
+    # agent too — plain chat has zero tool access, so it can only apologize again, never
+    # actually resume the grep_repo/read_file_lines work (the reported bug).
+    if not needs_agent and _continuation_pending():
+        _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)")
@@ -2479,6 +2690,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.)
@@ -2496,6 +2743,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 —
@@ -2869,6 +3123,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", "?")
 
@@ -2890,6 +3149,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("| →"):
@@ -3327,6 +3602,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]}")
@@ -3739,11 +4015,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). "
@@ -3787,7 +4069,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
@@ -3815,7 +4105,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
@@ -3824,6 +4119,39 @@ 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.
@@ -3890,7 +4218,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]
             # list_dir/read_text_file are needed for workspace browsing even when RAG
             # (S3 indexing) isn't configured.
             if not _RAG_AVAILABLE:
@@ -3939,6 +4267,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.195",
+  "version": "1.0.197",
   "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",