@tiens.nguyen/gonext-local-worker 1.0.199 → 1.0.201

package/gonext-repl.mjs

@@ -206,6 +206,19 @@ const ask = async (q) => {
   rl.setPrompt(PROMPT);
   return (a ?? "").trim();
 };
+// Yes/no prompt with an explicit default. Empty input (just Enter) → the default;
+// otherwise the FIRST non-space character decides (y*→yes, n*→no), and anything else
+// re-uses the default. This replaces a fragile `(await ask()) || "y"` idiom where any
+// leftover character (a stray escape byte, a stray space) silently defeated the
+// default — the reported "[Y/n] + Enter registered as No" bug.
+const askYesNo = async (question, defaultYes) => {
+  const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+  const raw = (await ask(question + suffix)).trim().toLowerCase();
+  if (!raw) return defaultYes; // just Enter → the default
+  if (raw[0] === "y") return true;
+  if (raw[0] === "n") return false;
+  return defaultYes; // unrecognized → default (never silently flip it)
+};
 
 // ---------- workspace registration for the current folder ----------
 async function readWorkspaces() {
@@ -229,16 +242,18 @@ async function ensureWorkspace() {
   }
   if (!existsSync(cwd) || !statSync(cwd).isDirectory()) return;
   console.log(`This folder is not a registered workspace:\n  ${cwd}`);
-  const reg = (await ask("Register it so the agent can read/edit code here? [Y/n] ")) || "y";
-  if (!/^y(es)?$/i.test(reg)) {
+  const register = await askYesNo(
+    "Register it so the agent can read/edit code here?", true /* default Yes */
+  );
+  if (!register) {
     console.log(dim("Skipped — the agent will not be able to touch files here."));
     return;
   }
-  const trust = (await ask(
+  const allowRun = await askYesNo(
     "Do you trust this folder — allow the agent to RUN build/test commands\n" +
-      "(npm test, mvn, pytest…)? [y/N] "
-  )) || "n";
-  const allowRun = /^y(es)?$/i.test(trust);
+      "(npm test, mvn, pytest…)?",
+    false /* default No — running commands is the riskier grant */
+  );
   const next = list.filter((w) => w.path !== cwd);
   next.push({
     name: basename(cwd),

package/gonext_agent_chat.py

@@ -659,6 +659,36 @@ def _is_trivial_chat(text: str) -> bool:
     return bool(_TRIVIAL_CHAT.match(t))
 
 
+# The greeting/smalltalk set MINUS the coding-ambiguous words: in a registered
+# workspace (the `gonext` terminal), a bare "test"/"testing"/"ping" leans toward a
+# command ("run the tests"), so it should reach the agent, not be answered as chat.
+# This is the ONLY escape from workspace-mode's default-to-agent routing, so it must
+# stay tight — anything not obviously conversational is better handled as a task.
+_GREETING_SMALLTALK = re.compile(
+    r"^\s*(?:"
+    r"h(?:i+|ello+|ey+|iya|owdy)|yo|sup|wass?up|"
+    r"good\s*(?:morning|afternoon|evening|night|day)|greetings|"
+    r"thanks?(?:\s*you)?|thank\s*you|thx|ty|cheers|much\s*appreciated|"
+    r"bye+|goodbye|see\s*(?:ya|you)|cya|later|good\s*night|"
+    r"ok(?:ay)?|k|cool|nice|great|awesome|perfect|sounds\s*good|got\s*it|"
+    r"how\s*(?:are|r)\s*(?:you|u|ya)(?:\s*doing)?|how'?s\s*it\s*going|what'?s\s*up|"
+    r"who\s*(?:are|r)\s*(?:you|u)|what\s*(?:can|do)\s*you\s*do|what\s*are\s*you"
+    r")"
+    r"(?:\s+(?:there|everyone|all|bot|assistant|gonext|man|dude|buddy))?"
+    r"[\s!.?,'\"]*$",
+    re.IGNORECASE,
+)
+
+
+def _is_greeting_smalltalk(text: str) -> bool:
+    """Tighter than _is_trivial_chat (no test/ping) — the single chat escape from
+    workspace-mode default-to-agent routing."""
+    t = (text or "").strip()
+    if not t or len(t) > 60:
+        return False
+    return bool(_GREETING_SMALLTALK.match(t))
+
+
 # A weak/confused coding model sometimes "thinks out loud" in plain prose instead of
 # emitting the next tool call — e.g. a rambling, self-correcting scratchpad ("Wait,
 # actually... Let's try... Actually, let's just...") that can run thousands of chars.
@@ -2514,14 +2544,31 @@ def run_agent_chat(cfg):
                     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.
-    if _is_trivial_chat(latest_user_text) and not _AGENT_KEYWORDS.search(latest_user_text or ""):
-        _log("router → NO (trivial greeting/smalltalk — local fast-path, no tool preamble)")
-        _emit({"type": "step", "text": "Routing your request…"})
+    # Routing. Two fundamentally different contexts:
+    #
+    # (A) WORKSPACE MODE (a folder is registered — i.e. the `gonext` terminal, or web
+    #     with a workspace): DEFAULT TO THE AGENT. The user opened a code folder and
+    #     registered it for the agent to read/edit/run — everything they type is
+    #     presumptively a task to DO, not a question to classify. We do NOT ask a model
+    #     classifier "does this need tools?" here: on a weak local model that guess is
+    #     unreliable, and every wrong guess sends an action request ("create a reactjs
+    #     project and start it", "do it for me") to plain chat, which can only hand back
+    #     instructions — the exact instability the user rejected. The ONLY escape is the
+    #     deterministic greeting/thanks fast-path, so "hi"/"thanks" stay instant instead
+    #     of spinning up the coding model. Anything else → agent, which still just
+    #     answers via final_answer when no tool is needed.
+    #
+    # (B) NO WORKSPACE (plain web chat): keep the keyword + model classifier — there are
+    #     no file/run tools to act with, so chat-vs-tool routing still earns its keep.
+    _emit({"type": "step", "text": "Routing your request…"})
+    if _is_greeting_smalltalk(latest_user_text) and not _AGENT_KEYWORDS.search(latest_user_text or ""):
+        _log("router → NO (greeting/smalltalk — local fast-path)")
         _emit({"type": "step", "text": "→ Chat reply"})
         needs_agent = False
+    elif _WS_AVAILABLE:
+        _log("router → YES (workspace registered → act by default, no classifier)")
+        _emit({"type": "step", "text": "→ Agent mode (workspace)"})
+        needs_agent = True
     else:
         needs_agent = _route(latest_user_text, agent_base_url, agent_api_key, agent_model_id)
     # A pending email awaiting 'confirm' must reach the agent even though a bare

package/package.json

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