use task.steered event xml shape for steer injection

Replace the ad-hoc <priority>...</priority> wrap from the previous
commit with the same <event name="..."> shape the TaskAgent already
reads for task.progress, task.cancelled, etc. Body starts with
"User has steered your task:" so the LLM has a clear directive to
treat this as overriding its current plan.

Before:
  <priority>Override your current plan with the instruction below.</priority>
  {text}

After:
  <event name="task.steered">
  User has steered your task: {text}
  </event>

Test + CHANGELOG updated to match.

Author: jptaylor

CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- `TaskAgent._inject_steering` now wraps incoming steer text with a short `<priority>` directive before injecting it into LLM context, so the steer outranks the original task instruction (which is itself a user message). Orchestrator side drops its now-redundant `"Steering instruction: "` text prefix.
+- `TaskAgent._inject_steering` now wraps incoming steer text in a `<event name="task.steered">User has steered your task: ...</event>` block before injecting into LLM context — same shape as task.progress / task.cancelled events the agent already reads — so the steer outranks the original task instruction (which is itself a plain user message). Orchestrator side drops its now-redundant `"Steering instruction: "` text prefix.
 - `start_task` and `steer_task` now pre-flight the target's finishing state. If the in-process TaskAgent has already called `finished` (or been cancelled), the steer would race the terminal turn and silently drop. `start_task` handles this transparently: the public entrypoint waits up to `TASK_STEER_CLOSING_WAIT_SECONDS` (default 5s) for the slot to free, then retries the start cleanly — the LLM never sees the intermediate state. Explicit `steer_task` returns `error: "task_closing"` for the LLM to chain `start_task` itself. Personal and corp in-process ships symmetric; BYOA skips the check.
 - Voice agent prompt: removed the contradictory "do NOT call start_task if all slots are occupied" line; added a short note that for steered instructions the agent should read the `task.completed` message and mention any unfulfilled intent to the commander.
 

src/gradientbang/runtime/subagents/task_agent.py

@@ -1715,15 +1715,14 @@ async def _inject_steering(self, text: str) -> None:
         cleaned = text.strip()
         if not cleaned:
             return
-        # Wrap with a brief priority directive so the LLM treats this user
-        # message as outranking the original task instruction. The task
-        # description was itself a user message, so without this wrap the
-        # steer is just another peer instruction with no priority signal.
-        prioritized = (
-            "<priority>Override your current plan with the instruction below.</priority>\n"
-            f"{cleaned}"
+        # Wrap as a task.steered event so the LLM treats it as a system
+        # directive overriding the original task instruction. The task
+        # description was itself a plain user message, so without this
+        # framing the steer is just another peer instruction.
+        steered_xml = (
+            f'<event name="task.steered">\nUser has steered your task: {cleaned}\n</event>'
         )
-        message = {"role": "user", "content": prioritized}
+        message = {"role": "user", "content": steered_xml}
         if self._llm_context is not None:
             self._llm_context.add_message(message)
         self._output(cleaned, TaskOutputType.INPUT)

tests/unit/test_task_agent.py

@@ -967,13 +967,15 @@ async def test_steering_emits_replanning_message(self):
         ]
         agent.queue_frame.assert_awaited_once()
 
-        # The steer is injected as a user message wrapped with a brief
-        # <priority> directive so the LLM treats it as outranking the
-        # original task instruction (which was itself a user message).
+        # The steer is injected as a user message wrapped in a
+        # task.steered event so the LLM treats it as a system directive
+        # overriding the original task instruction (which was itself a
+        # plain user message).
         agent._llm_context.add_message.assert_called_once()
         injected = agent._llm_context.add_message.call_args.args[0]
         assert injected["role"] == "user"
-        assert injected["content"].startswith("<priority>")
+        assert injected["content"].startswith('<event name="task.steered">')
+        assert "User has steered your task" in injected["content"]
         assert "Change direction" in injected["content"]
 
     async def test_duplicate_progress_message_is_suppressed_without_new_action_or_event(self):