@tiens.nguyen/gonext-local-worker 1.0.234 → 1.0.236

package/gonext-local-worker.mjs

@@ -2043,7 +2043,13 @@ async function runAgentChatJob(job) {
       method: "PATCH",
       body: JSON.stringify({
         jobStatus: "completed",
-        resultText: finalText || fullText,
+        // When the answer streamed live (answer_stream), completed resultText must stay
+        // an EXACT EXTENSION of the chunk accumulation: the REPL renders the final poll
+        // by flushing resultText.slice(<chars already shown>), so replacing the stream
+        // with the shorter bare answer here made short plain replies render cut
+        // mid-word ("Hello! How"). Only when nothing streamed is the deduped finalText
+        // the whole story.
+        resultText: answerStreamed ? fullText : finalText || fullText,
         tokenCount: Math.max(1, Math.ceil((finalText || fullText).length / 4)),
         totalTimeSeconds,
       }),

package/gonext-repl.mjs

@@ -994,6 +994,14 @@ async function runAgentTurn(history) {
   // (see carryFlushedLen below); the agent path's code/tool-call lines must stay buffered
   // until a full line is known, or we'd risk showing part of something we meant to hide.
   let plainReplyFlow = false;
+  // Exact answer characters printed live in the plain-reply flow — lets the completed
+  // poll figure out how much of the FINAL answer is still unshown even when resultText
+  // was replaced (not extended) on completion. See the completed-branch recovery below.
+  let liveAnswer = "";
+  // First few KB of the raw stream as consumed — a cheap fingerprint to verify the
+  // completed resultText really EXTENDS what we streamed (an old worker replaces it
+  // with the shorter bare answer, which must not be sliced by shownChars).
+  let seenRaw = "";
 
   // --- Live in-progress ("blinking") bullet -------------------------------------------
   // The agent's raw Thought/code stream is SUPPRESSED (see the ~~~-fence handling in
@@ -1235,6 +1243,7 @@ async function runAgentTurn(history) {
         // Plain-reply content IS the answer — print it in the default color and remember
         // it's visible so the caller doesn't reprint it once the turn completes.
         process.stdout.write(line.slice(alreadyFlushed) + "\n");
+        liveAnswer += line.slice(alreadyFlushed) + "\n";
         answerShownLive = true;
       } else {
         // The remaining out-of-fence ACTION events ("Command passed → …", "Searching code
@@ -1251,6 +1260,7 @@ async function runAgentTurn(history) {
     if (plainReplyFlow && !inCode && carry.length > carryFlushedLen) {
       if (carryFlushedLen === 0) onContent();
       process.stdout.write(carry.slice(carryFlushedLen)); // default color — this IS the answer
+      liveAnswer += carry.slice(carryFlushedLen);
       carryFlushedLen = carry.length;
       answerShownLive = true;
       lastWasBlank = false;
@@ -1323,14 +1333,38 @@ async function runAgentTurn(history) {
         // caller (shown=false), so a live flush there is unnecessary (and would compound
         // the separate agent double-print). This runs for the completed poll only; the
         // running-branch consume below handles every earlier poll.
-        if (plainReplyFlow && text.length > shownChars) {
+        //
+        // The suffix math is only valid when the completed resultText EXTENDS the
+        // streamed accumulation. An older worker REPLACES it with the bare deduped
+        // answer — a shorter, different string — so slicing by shownChars either shows
+        // nothing (the reported "Hello! How" cut) or a garbage tail. Verify with the
+        // seenRaw fingerprint; on a mismatch, recover by answer-prefix instead: print
+        // whatever of the final answer wasn't already shown live.
+        const extendsStream = text.length >= shownChars && text.startsWith(seenRaw);
+        if (plainReplyFlow && extendsStream && text.length > shownChars) {
           consume(text.slice(shownChars));
           shownChars = text.length;
+        } else if (plainReplyFlow && !extendsStream && answerShownLive) {
+          const ans = answerFrom(text);
+          let rest = ans.startsWith(liveAnswer) ? ans.slice(liveAnswer.length) : null;
+          if (rest === null) {
+            // The live text may carry a trailing newline the trimmed answer lacks.
+            const printed = liveAnswer.replace(/\s+$/, "");
+            rest = ans.startsWith(printed) ? ans.slice(printed.length) : null;
+          }
+          if (rest) {
+            onContent();
+            process.stdout.write(rest);
+            lastWasBlank = false;
+          }
         }
         clearStatus();
         return { text: answerFrom(text), shown: answerShownLive };
       }
       if (text.length > shownChars) {
+        if (seenRaw.length < 4096) {
+          seenRaw = (seenRaw + text.slice(shownChars)).slice(0, 4096);
+        }
         consume(text.slice(shownChars));
         shownChars = text.length;
       }
@@ -1470,6 +1504,11 @@ async function main() {
   process.on("SIGINT", onInterrupt);
   rl.on("SIGINT", onInterrupt);
 
+  // The task from the most recent Ctrl+C-cancelled turn — so a bare "continue" right after
+  // resumes it. A cancelled turn is popped from history (nothing to continue otherwise), so
+  // without this "continue" reaches the agent with no task and it replies as generic chat.
+  let lastCancelledTask = "";
+
   for (;;) {
     rl.prompt();
     // Absorb blank Enter-presses SILENTLY under the same prompt — without this, lines
@@ -1536,7 +1575,22 @@ async function main() {
       console.log(dim(`unknown command: ${cmd} — type /help (or / then Tab) to list commands\n`));
       continue;
     }
-    history.push({ role: "user", content: line });
+    // Resume a cancelled task: a BARE "continue" right after a Ctrl+C re-runs the ORIGINAL
+    // request. Only the immediately-next input may resume (consumed here) and only a bare
+    // continue-word — a message with real instructions is a new task. Slash commands above
+    // used `continue` and never reach here, so `/model` then "continue" still resumes.
+    const pendingResume = lastCancelledTask;
+    lastCancelledTask = "";
+    let taskLine = line;
+    if (
+      pendingResume &&
+      /^(continue|resume|go on|keep going|carry on|proceed)\.?$/i.test(line)
+    ) {
+      taskLine = pendingResume;
+      const shown = pendingResume.length > 80 ? pendingResume.slice(0, 80) + "…" : pendingResume;
+      console.log(dim(`↻ resuming the cancelled task: ${shown}\n`));
+    }
+    history.push({ role: "user", content: taskLine });
     try {
       const { text: answer, shown, cancelled } = await runAgentTurn(history);
       if (answer) {
@@ -1552,7 +1606,12 @@ async function main() {
         history.pop(); // aborted/failed/cancelled turn — don't poison the next request
         // Ctrl+C cancel already printed its own "(cancelled)" note in runAgentTurn — a
         // second "(no answer)" line here would be redundant/misleading.
-        if (!cancelled) {
+        if (cancelled) {
+          // Remember the ACTUAL task that ran (taskLine, not a bare "continue") so the
+          // next bare "continue" resumes it — even if it was cancelled during step 1,
+          // before any worker-side checkpoint step was written.
+          lastCancelledTask = taskLine;
+        } else {
           console.log(red("\n(no answer — run aborted or failed)\n"));
         }
       }

package/gonext_agent_chat.py

@@ -1926,20 +1926,31 @@ _WS_ACTIVE: str = ""
 
 
 def _rag_read_allowed(path: str) -> str:
-    """Resolve `path` and ensure it stays within a safe root (worker cwd, temp dir,
-    ~/.gonext, or a registered workspace) — so the agent's file tools can't read
-    arbitrary files like ~/.ssh. Relative paths anchor to the terminal workspace (where
-    downloads/unzips land), NOT the worker's process cwd (the home dir), because the
-    model routinely passes bare names like "tools-hook" or "tools-hook/README.md"."""
+    """Resolve `path` and ensure it stays within a safe root (temp dir, ~/.gonext, the
+    active terminal folder, or a registered workspace) — so the agent's file tools can't
+    read arbitrary files like ~/.ssh. Relative paths anchor to the terminal workspace
+    (where downloads/unzips land), because the model routinely passes bare names like
+    "tools-hook" or "tools-hook/README.md".
+
+    NOTE: the worker's PROCESS CWD is deliberately NOT an allowed root (bug #70). The
+    daemon is often launched from ~/Projects (the PARENT of every workspace), so trusting
+    os.getcwd() let `grep_repo(path="/Users/joseph/Projects")` read EVERY project on disk
+    — including other repos' secrets. Reads are confined to the registered/active
+    workspaces + ~/.gonext + the temp dir. Fail-closed: no workspace ⇒ no repo reads."""
     import os
     import tempfile
     expanded = os.path.expanduser((path or "").strip())
     if not os.path.isabs(expanded):
-        base = _WS_ACTIVE or (_WS_ROOTS[0]["path"] if _WS_ROOTS else os.getcwd())
+        # Anchor a relative path to the active workspace (NOT the worker cwd — see above).
+        base = _WS_ACTIVE or (_WS_ROOTS[0]["path"] if _WS_ROOTS else None)
+        if base is None:
+            raise ValueError(
+                "No workspace is active — register a folder with `gonext-local-worker "
+                "workspace add <path>` before reading files."
+            )
         expanded = os.path.join(base, expanded)
     rp = os.path.realpath(expanded)
     roots = [
-        os.path.realpath(os.getcwd()),
         os.path.realpath(tempfile.gettempdir()),
         os.path.realpath(os.path.join(os.path.expanduser("~"), ".gonext")),
     ] + [w["path"] for w in _WS_ROOTS]
@@ -1950,8 +1961,8 @@ def _rag_read_allowed(path: str) -> str:
     if any(rp == r or rp.startswith(r + os.sep) for r in roots):
         return rp
     raise ValueError(
-        "Path is outside the allowed working directories (download/unzip outputs "
-        "or a registered workspace)."
+        f"Path '{path}' is outside your registered workspace(s). The agent can only read "
+        "inside a folder you registered (or download/unzip outputs), not the whole disk."
     )
 
 
@@ -3040,6 +3051,9 @@ def run_agent_chat(cfg):
         f"  CURRENT folder — the terminal is open HERE; default ALL create/edit/run/"
         f"download operations to THIS folder unless the user EXPLICITLY names another "
         f"workspace: {_active_label}\n"
+        "  Ignore any OTHER folder paths that appear only in EARLIER messages (a previous "
+        "task, a cancelled turn) — they are stale. Do NOT grep/list/read across parent "
+        "directories or unrelated projects; work in the CURRENT folder above.\n"
         if _active_label else ""
     )
     # Upfront, ZERO-COST (no tool call, no model round-trip) top-level listing — so the
@@ -5196,8 +5210,17 @@ def run_agent_chat(cfg):
         # even during a total coding-model outage, instead of trusting a plain-chat
         # model's guess that "there's no code or project" (seen live — false: the
         # workspace had real content the whole time, the model just never reached it).
+        # ONLY the current/active folder — never dump the full list of every registered
+        # workspace here. That list (t1..t23) used to get persisted into the answer/history
+        # and then confused the next turn into free-roaming other projects (bug #70).
         if _WS_AVAILABLE:
-            note += f"\n\n(Your registered workspace:\n{_workspace_overview(_WS_ROOTS)})"
+            import os as _os
+            _ov_path = _WS_ACTIVE or (_WS_ROOTS[0]["path"] if _WS_ROOTS else "")
+            _ov = next((w for w in _WS_ROOTS if w["path"] == _ov_path), None)
+            if _ov is None and _ov_path:
+                _ov = {"name": _os.path.basename(_ov_path), "path": _ov_path}
+            if _ov:
+                note += f"\n\n(Current folder {_ov['name']}:\n{_workspace_overview([_ov])})"
         _emit({"type": "final", "text": note})
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.234",
+  "version": "1.0.236",
   "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",