@tiens.nguyen/gonext-local-worker 1.0.235 → 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/package.json

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