fix(kiro): stop proxy filler from preceding a mid-turn steer

Reported as issue #543: mid-turn steering messages typed in Claude Code
while the agent works were ignored on kiro/claude-opus-5, though the
reporter's own control showed them working on kiro/claude-opus-4.8 with
the same proxy build.

Claude Code delivers such a steer as text riding the same user turn as
the pending tool_result. The Kiro adapter merges adjacent user content,
and the tool-result branch pushed KIRO_TOOL_RESULT_CARRIER_MESSAGE first,
so the assembled current message read:

  "The requested tool result is attached.

   <the human's actual instruction>"

The carrier sentence exists to keep an otherwise EMPTY tool-result turn
from having blank content. It was never meant as a prefix, and putting it
ahead of the newest human intent buries that intent behind boilerplate.

Tool results now push empty content, and the carrier is backfilled only
for turns that still have no text. The backfill runs before the current
turn is popped: doing it after would ship an empty current content, which
validateKiroConversationState accepts because tool results count as
payload, so the mistake would fail silently.

This is a targeted mitigation, not a proven fix for #543. Request
construction is otherwise the same for both models — verified by invoking
buildKiroPayload directly for each — differing only in model identity and
opus-5's native output_config.effort, so any remaining divergence is
upstream. The new parity test pins that so a future model-conditional
regression on this path surfaces here instead of in a user's session.

Author: lidge-jun

src/adapters/kiro.ts

@@ -498,7 +498,11 @@ export function buildKiroPayload(
       if (!priorCalls.has(toolUseId)) {
         throw new Error(`Kiro history contains an orphaned tool result for call ${JSON.stringify(tr.toolCallId)}`);
       }
-      pushUser(KIRO_TOOL_RESULT_CARRIER_MESSAGE, images, [{
+      // Carrier text is a placeholder for an OTHERWISE EMPTY tool-result turn, not a prefix.
+      // Passing it here would push proxy filler AHEAD of a human instruction that Claude Code
+      // sends in the same turn (mid-turn steering / queued_command, issue #543), burying the
+      // newest user intent behind boilerplate. Backfill below only when nothing else speaks.
+      pushUser("", images, [{
         content: [{ text: resultText }],
         status: tr.isError ? "error" : "success",
         toolUseId,
@@ -518,6 +522,16 @@ export function buildKiroPayload(
     });
   }
 
+  // Give tool-result turns a carrier sentence ONLY when they carry no other text. This runs
+  // before the pop below so the current turn is covered too: skipping it there would ship an
+  // empty current content, which validateKiroConversationState accepts (tool results count as
+  // payload) and would therefore fail silently.
+  for (const turn of turns) {
+    if (turn.kind === "user" && !turn.content.trim() && turn.toolResults.length > 0) {
+      turn.content = KIRO_TOOL_RESULT_CARRIER_MESSAGE;
+    }
+  }
+
   const currentTurn = turns.pop();
   if (!currentTurn || currentTurn.kind !== "user") throw new Error("Kiro request must end with a user turn");
   const toEntry = (turn: KiroTurn): KiroHistoryEntry => turn.kind === "assistant"

tests/kiro-adapter.test.ts

@@ -840,6 +840,65 @@ describe("kiro adapter — native and emulated reasoning effort", () => {
     expect(content).not.toContain("<thinking_mode>");
   });
 
+  // issue #543: Claude Code sends a mid-turn steer (queued_command) as text riding the same
+  // user turn as the pending tool_result. Proxy filler must never precede that instruction.
+  test("a mid-turn steering message is the current turn without proxy carrier filler", async () => {
+    const steer = "STOP editing module A. Use kiro/gpt-5.6-sol instead.";
+    const messages = [
+      { role: "user", content: "Refactor module A." },
+      { role: "assistant", content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: { command: "ls" } }] },
+      { role: "toolResult", toolCallId: "call-1", toolName: "bash", content: "file list", isError: false },
+      { role: "user", content: steer },
+    ];
+    const { body } = await createKiroAdapter(provider).buildRequest(parsedWith(messages, [bashTool]));
+    const current = JSON.parse(body).conversationState.currentMessage.userInputMessage;
+
+    // The human instruction is the whole content: the carrier sentence must be ABSENT, not
+    // merely moved after it (a startsWith assertion would pass with filler appended).
+    expect(current.content).toBe(steer);
+    expect(current.content).not.toContain(KIRO_TOOL_RESULT_CARRIER_MESSAGE);
+    // The tool result still rides along structurally, so no information is lost.
+    expect(current.userInputMessageContext.toolResults).toEqual([
+      { content: [{ text: "file list" }], status: "success", toolUseId: "call-1" },
+    ]);
+  });
+
+  test("mid-turn steering reaches Kiro identically for opus-5 and opus-4.8", async () => {
+    // The #543 reporter observed opus-4.8 honoring mid-turn steers while opus-5 ignored them on
+    // the same proxy build. Pin that our request construction does not differ between the two
+    // beyond model identity and opus-5's native effort field, so a future model-conditional
+    // regression on this path is caught here rather than in a user's session.
+    const steer = "Stop and switch approach now.";
+    const messages = [
+      { role: "user", content: "Start the task." },
+      { role: "assistant", content: [{ type: "toolCall", id: "call-1", name: "bash", arguments: { command: "ls" } }] },
+      { role: "toolResult", toolCallId: "call-1", toolName: "bash", content: "out", isError: false },
+      { role: "user", content: steer },
+    ];
+    const build = async (modelId: string) => {
+      const { body } = await createKiroAdapter(provider).buildRequest({
+        ...parsedWith(messages, [bashTool], modelId),
+        options: { reasoning: "high" },
+      });
+      return JSON.parse(body);
+    };
+    const opus5 = await build("claude-opus-5");
+    const opus48 = await build("claude-opus-4.8");
+
+    for (const payload of [opus5, opus48]) {
+      const current = payload.conversationState.currentMessage.userInputMessage;
+      expect(current.content).toBe(steer);
+      expect(current.userInputMessageContext.toolResults).toEqual([
+        { content: [{ text: "out" }], status: "success", toolUseId: "call-1" },
+      ]);
+    }
+    // Only the native-effort field may differ; opus-4.8 also gets no emulated thinking tags
+    // here because tool-result turns skip that injection.
+    expect(opus5.additionalModelRequestFields).toEqual({ output_config: { effort: "high" } });
+    expect(opus48.additionalModelRequestFields).toBeUndefined();
+    expect(opus48.conversationState.currentMessage.userInputMessage.content).not.toContain("<thinking_mode>");
+  });
+
   test("gpt-5.6-sol sends native reasoning while legacy models keep labeled emulation", async () => {
     const nativeBody = JSON.parse((await createKiroAdapter(provider).buildRequest({
       ...parsedWith([{ role: "user", content: "solve" }], undefined, "gpt-5.6-sol"),