From d3fdcef13232d01a42e63a90873e783d285e6266 Mon Sep 17 00:00:00 2001 From: Teknium <127238744+teknium1@users.noreply.github.com> Date: Sat, 5 Sep 2026 06:36:52 -0700 Subject: [PATCH] fix(goal): the re-paste pointer applies only to a near-whole re-paste, and on every surface Independent review: substring matching lost the selected objective (after a message offering API or UI work, '/goal ship the API' and '/goal ship the UI' kicked identically), and the gateway and TUI /goal paths still re-sent the full goal. The rule now lives once in hermes_cli.goals.goal_kick_prompt: the pointer replaces the goal only when the goal is >= 400 chars, contained in the last user message, and >= 80% of it. The CLI reads the last user message from its history; the gateway and TUI read it from the SessionDB (fail-safe: goal sent verbatim). Tests: a fragment that selects one option is kicked verbatim; a long goal that is a minority of a longer message is kicked verbatim; all three surfaces call the shared function. --- gateway/slash_commands_goals.py | 7 ++-- hermes_cli/cli_commands_mixin.py | 23 +++--------- hermes_cli/goals.py | 49 ++++++++++++++++++++++++++ tests/cli/test_cli_goal_kick_prompt.py | 36 ++++++++++++++++--- tui_gateway/methods_tools.py | 4 ++- 5 files changed, 93 insertions(+), 26 deletions(-) diff --git a/gateway/slash_commands_goals.py b/gateway/slash_commands_goals.py index a36cfff565..607c9c6d3b 100644 --- a/gateway/slash_commands_goals.py +++ b/gateway/slash_commands_goals.py @@ -196,9 +196,12 @@ class GatewayGoalCommandsMixin: except ValueError as exc: return t("gateway.goal.invalid", error=str(exc)) - # Queue the goal text as an immediate first turn; the post-turn hook takes over after. + # Queue the goal text as an immediate first turn (a short pointer when the user just pasted that + # very text: hermes_cli.goals.goal_kick_prompt); the post-turn hook takes over after. + from hermes_cli.goals import goal_kick_prompt, last_user_message_from_db + kick = goal_kick_prompt(state.goal, last_user_message_from_db(getattr(mgr, "session_id", None))) self._enqueue_goal_turn( - event, state.goal, label="kickoff enqueue", kickoff=True, route=self._adapter_and_key_for(event) + event, kick, label="kickoff enqueue", kickoff=True, route=self._adapter_and_key_for(event) ) base = t("gateway.goal.set", budget=state.max_turns, goal=state.goal) diff --git a/hermes_cli/cli_commands_mixin.py b/hermes_cli/cli_commands_mixin.py index 7f58ad33cd..146f6d85fd 100644 --- a/hermes_cli/cli_commands_mixin.py +++ b/hermes_cli/cli_commands_mixin.py @@ -2223,26 +2223,11 @@ class CLICommandsMixin: else: self._goal_set(mgr, arg) - # `/goal ` kicks the loop by queueing the goal text as the next user turn. When that text - # is what the user JUST said (a pasted handoff note, a plan the agent already has), re-sending - # it makes the agent spend a turn deciding it is a replay (11 API calls, 6 min, in one run) and - # duplicates ~2k tokens of context. A short pointer starts the loop just as well. - _GOAL_ALREADY_SEEN_KICK = "[Goal set] Continue with the goal you were just given; there is no need to re-read it." - def _goal_kick_prompt(self, goal: str) -> str: - """The goal text, or a short pointer when the last user message already carries it.""" - last_user = "" - for msg in reversed(getattr(self, "conversation_history", None) or []): - if msg.get("role") == "user": - content = msg.get("content") - if isinstance(content, list): - content = " ".join(str(b.get("text", "")) for b in content if isinstance(b, dict)) - last_user = str(content or "") - break - goal_norm = " ".join(goal.split()) - if goal_norm and goal_norm in " ".join(last_user.split()): - return self._GOAL_ALREADY_SEEN_KICK - return goal + """The goal text, or a short pointer when the last user message is essentially that text + (shared rule: ``hermes_cli.goals.goal_kick_prompt``).""" + from hermes_cli.goals import goal_kick_prompt, last_user_message_content + return goal_kick_prompt(goal, last_user_message_content(getattr(self, "conversation_history", None))) def _kick_goal(self, prompt: str) -> bool: """Queue ``prompt`` as the next turn so the loop starts without a separate message.""" diff --git a/hermes_cli/goals.py b/hermes_cli/goals.py index 8d0b24f679..27a0fae759 100644 --- a/hermes_cli/goals.py +++ b/hermes_cli/goals.py @@ -909,6 +909,55 @@ def judge_goal( return verdict, reason, parse_failed, wait_directive, False +# `/goal ` kicks the loop by sending the goal as the next user turn. When that text IS what +# the user just said (a pasted handoff note, a plan the agent already has), re-sending it makes the +# agent spend a turn deciding it is a replay (11 API calls, 6 min, in one run) and duplicates ~2k +# tokens of context. The pointer is used only when the goal is substantially the WHOLE last +# message: a short goal that merely appears inside a longer one ("ship the API" after a message +# offering API or UI work) selects one option, and two different goals must not kick identically. +GOAL_ALREADY_SEEN_KICK = "[Goal set] Continue with the goal you were just given; there is no need to re-read it." +_GOAL_REPASTE_MIN_CHARS = 400 +_GOAL_REPASTE_MIN_SHARE = 0.8 + + +def goal_kick_prompt(goal: str, last_user_message: Any) -> str: + """The goal text, or ``GOAL_ALREADY_SEEN_KICK`` when ``last_user_message`` is essentially that text.""" + content = last_user_message + if isinstance(content, list): + content = " ".join(str(b.get("text", "")) for b in content if isinstance(b, dict)) + goal_norm, last_norm = " ".join(str(goal or "").split()), " ".join(str(content or "").split()) + if ( + len(goal_norm) >= _GOAL_REPASTE_MIN_CHARS + and goal_norm in last_norm + and len(goal_norm) >= _GOAL_REPASTE_MIN_SHARE * len(last_norm) + ): + return GOAL_ALREADY_SEEN_KICK + return goal + + +def last_user_message_content(history: Any) -> Any: + """Content of the newest ``role == "user"`` message in an OpenAI-shaped history, else ``""``.""" + for msg in reversed(history or []): + if isinstance(msg, dict) and msg.get("role") == "user": + return msg.get("content") + return "" + + +def last_user_message_from_db(session_id: Optional[str]) -> Any: + """Newest user message of ``session_id`` from the SessionDB (gateway/TUI surfaces have no live + history object at slash-command time); ``""`` on any error.""" + if not session_id: + return "" + try: + db = _get_session_db() + if db is None: + return "" + rows = db.get_messages(str(session_id), limit=20, latest=True) + return last_user_message_content(rows) + except Exception: + return "" + + def gather_background_processes(task_id: Optional[str] = None) -> List[Dict[str, Any]]: """Fail-safe snapshot of RUNNING ``process_registry`` sessions for the judge; ``[]`` on any error so the loop degrades to its pre-wait-barrier behavior.""" diff --git a/tests/cli/test_cli_goal_kick_prompt.py b/tests/cli/test_cli_goal_kick_prompt.py index ae57abc900..2e15ba44ab 100644 --- a/tests/cli/test_cli_goal_kick_prompt.py +++ b/tests/cli/test_cli_goal_kick_prompt.py @@ -6,6 +6,7 @@ a user message; the kickoff re-sent it and the agent spent 11 API calls / 6 min import queue from hermes_cli.cli_commands_mixin import CLICommandsMixin +from hermes_cli.goals import GOAL_ALREADY_SEEN_KICK def _cli(history): @@ -15,16 +16,16 @@ def _cli(history): return cli -HANDOFF = "HANDOFF: resume round 3 integration.\n - merge r3-16 first\n - then run the full suite" +HANDOFF = "HANDOFF: resume round 3 integration.\n" + "\n".join(f" - step {i}: merge r3-{i} and run its targeted suite, then the full suite" for i in range(8)) def test_goal_that_the_user_just_pasted_kicks_with_a_pointer_not_the_text(): - cli = _cli([{"role": "user", "content": "Here is the plan.\n\n" + HANDOFF + "\n\nGo."}, + cli = _cli([{"role": "user", "content": HANDOFF + "\n\nGo."}, {"role": "assistant", "content": "ok"}]) - assert cli._goal_kick_prompt(HANDOFF) == CLICommandsMixin._GOAL_ALREADY_SEEN_KICK + assert cli._goal_kick_prompt(HANDOFF) == GOAL_ALREADY_SEEN_KICK # block-style content is handled too cli = _cli([{"role": "user", "content": [{"type": "text", "text": HANDOFF}]}]) - assert cli._goal_kick_prompt(HANDOFF) == CLICommandsMixin._GOAL_ALREADY_SEEN_KICK + assert cli._goal_kick_prompt(HANDOFF) == GOAL_ALREADY_SEEN_KICK def test_a_new_goal_or_a_goal_from_an_older_turn_is_kicked_verbatim(): @@ -35,3 +36,30 @@ def test_a_new_goal_or_a_goal_from_an_older_turn_is_kicked_verbatim(): cli = _cli([{"role": "user", "content": HANDOFF}, {"role": "assistant", "content": "done"}, {"role": "user", "content": "now something else"}]) assert cli._goal_kick_prompt(HANDOFF) == HANDOFF + + +def test_a_short_goal_that_selects_one_option_from_the_last_message_is_kicked_verbatim(): + """Independent-review witness: after a message offering API or UI work, `/goal ship the API` and + `/goal ship the UI` produced identical kickoffs. A goal that is a fragment of the last message + carries the selection; only a near-whole re-paste is replaced by the pointer.""" + offer = "I can either ship the API or ship the UI next; which do you want? " * 8 + cli = _cli([{"role": "user", "content": offer}]) + assert cli._goal_kick_prompt("ship the API") == "ship the API" + assert cli._goal_kick_prompt("ship the UI") == "ship the UI" + # a long goal that is only a minority of a much longer message is also kept verbatim + long_goal = "x" * 500 + cli = _cli([{"role": "user", "content": long_goal + " " + "y" * 2000}]) + assert cli._goal_kick_prompt(long_goal) == long_goal + + +def test_gateway_and_tui_surfaces_use_the_same_rule(tmp_path, monkeypatch): + """Independent review: other surfaces still duplicated the full goal. One shared function now.""" + from hermes_cli import goals + long_goal = "HANDOFF " + "step; " * 120 + assert goals.goal_kick_prompt(long_goal, long_goal) == goals.GOAL_ALREADY_SEEN_KICK + assert goals.goal_kick_prompt("ship the API", "ship the API or ship the UI? " * 8) == "ship the API" + # DB-backed lookup fails safe to "" (goal kicked verbatim) when no session/db + assert goals.last_user_message_from_db(None) == "" + import gateway.slash_commands_goals as g, tui_gateway.methods_tools as m # noqa: E401 + import inspect + assert "goal_kick_prompt" in inspect.getsource(g) and "goal_kick_prompt" in inspect.getsource(m) diff --git a/tui_gateway/methods_tools.py b/tui_gateway/methods_tools.py index 9d9e457f75..839c200b44 100644 --- a/tui_gateway/methods_tools.py +++ b/tui_gateway/methods_tools.py @@ -709,7 +709,9 @@ def _cmd_goal(rid, params, session, name, arg): f"⊙ Goal set ({state.max_turns}-turn budget): {state.goal}\n" "I'll keep working until the goal is done, you pause/clear it, or the budget is exhausted.\n" "Controls: /goal status · /goal pause · /goal resume · /goal clear") - return _ok(rid, {"type": "send", "notice": notice, "message": state.goal}) + from hermes_cli.goals import goal_kick_prompt, last_user_message_from_db + kick = goal_kick_prompt(state.goal, last_user_message_from_db(getattr(mgr, "session_id", None))) + return _ok(rid, {"type": "send", "notice": notice, "message": kick}) def _cmd_loop(rid, params, session, name, arg):