test: add 3 targeted coverage tests for 80% Codecov threshold

Cover remaining uncovered branches in presentAssistantMessage.ts:
- didRejectTool cleanup path with pending protocol guide merge
- missing nativeArgs fallback with guided PARAM_MISSING payload
- structural fingerprint change circuit reset

Author: k1yt

ci-fix-commit.ps1

@@ -1,15 +1,10 @@
 cd Zoo-Code
 git add -A
-git commit --no-verify -m "fix: update e2e fixture and add coverage tests for Codecov
+git commit --no-verify -m "test: add 3 targeted coverage tests for 80% Codecov threshold
 
-Fix e2e apply_diff fixture to expect guided JSON payload format instead
-of raw error text strings. The interceptor now transforms apply_diff
-errors into structured DIFF_MATCH_FAILED guidance.
-
-Add 16 new tests:
-- 8 integration tests for presentAssistantMessage error-interception
-  paths (XML detection, structural preflight, guide consumption)
-- 8 edge case tests for ToolErrorInterceptor (array results with images,
-  isErrorResult/inferStatus branches)"
+Cover remaining uncovered branches in presentAssistantMessage.ts:
+- didRejectTool cleanup path with pending protocol guide merge
+- missing nativeArgs fallback with guided PARAM_MISSING payload
+- structural fingerprint change circuit reset"
 $env:HUSKY = "0"
 git push -u fork feat/error-interception-middleware

src/core/assistant-message/__tests__/presentAssistantMessage-error-interception.spec.ts

@@ -304,6 +304,127 @@ describe("presentAssistantMessage - Error Interception Integration", () => {
 		})
 	})
 
+	describe("didRejectTool cleanup path", () => {
+		it("merges a pending native protocol guide into the rejection tool_result", async () => {
+			const state = getTaskErrorState(mockTask)
+			state.setPendingNativeProtocolGuide("[XML_NATIVE_DUAL_PROTOCOL occurrence=1] guide-to-merge")
+
+			mockTask.didRejectTool = true
+			const toolCallId = "call_rejected_with_guide"
+			mockTask.assistantMessageContent = [
+				{
+					type: "tool_use",
+					id: toolCallId,
+					name: "read_file",
+					params: { path: "x.txt" },
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask)
+
+			const toolResult = mockTask.userMessageContent.find(
+				(item: any) => item.type === "tool_result" && item.tool_use_id === toolCallId,
+			)
+			expect(toolResult).toBeDefined()
+			expect(toolResult.is_error).toBe(true)
+			expect(String(toolResult.content)).toContain("Skipping tool")
+			expect(String(toolResult.content)).toContain("guide-to-merge")
+			// Guide must be consumed so it cannot leak into later turns.
+			expect(state.consumePendingNativeProtocolGuide()).toBeUndefined()
+		})
+	})
+
+	describe("missing nativeArgs (malformed native call)", () => {
+		it("pushes a structured tool_result and does not set didAlreadyUseTool", async () => {
+			const toolCallId = "call_missing_native_args"
+			mockTask.assistantMessageContent = [
+				{
+					type: "tool_use",
+					id: toolCallId,
+					name: "read_file",
+					params: { path: "x.txt" },
+					// nativeArgs intentionally omitted: parser could not finalize arguments.
+					partial: false,
+				},
+			]
+
+			await presentAssistantMessage(mockTask)
+
+			const toolResult = mockTask.userMessageContent.find(
+				(item: any) => item.type === "tool_result" && item.tool_use_id === toolCallId,
+			)
+			expect(toolResult).toBeDefined()
+			expect(toolResult.is_error).toBe(true)
+			// The interceptor transforms the missing-nativeArgs signal into a
+			// structured guided payload (PARAM_MISSING category).
+			expect(String(toolResult.content)).toContain("guided_tool_error")
+			expect(String(toolResult.content)).toContain("PARAM_MISSING")
+			expect(mockTask.consecutiveMistakeCount).toBe(1)
+			expect(mockTask.recordToolError).toHaveBeenCalledWith(
+				"read_file",
+				expect.stringContaining("missing nativeArgs"),
+			)
+			expect(mockTask.didAlreadyUseTool).toBe(false)
+		})
+	})
+
+	describe("structural fingerprint change", () => {
+		it("resets the PARAM_TYPE_MISMATCH circuit when the failure shape changes", async () => {
+			const state = getTaskErrorState(mockTask)
+
+			// First failure: CWD_OBJECT_MISUSE on execute_command.
+			mockTask.assistantMessageContent = [
+				{
+					type: "tool_use",
+					id: "call_shape_a",
+					name: "execute_command",
+					params: { command: "ls" },
+					nativeArgs: { command: "ls", cwd: { nested: "object" } },
+					partial: false,
+				},
+			]
+			await presentAssistantMessage(mockTask)
+			const fingerprintA = state.getFingerprint("PARAM_TYPE_MISMATCH")
+			expect(fingerprintA).toContain("CWD_OBJECT_MISUSE")
+
+			// Second failure on the SAME task with a different structural shape
+			// (NESTED_PARAM_OVERFLOW on read_file) must reset the circuit and
+			// report the new variant instead of inheriting the previous one.
+			mockTask.assistantMessageContent = [
+				{
+					type: "tool_use",
+					id: "call_shape_b",
+					name: "read_file",
+					params: {},
+					nativeArgs: {
+						path: "a.txt",
+						extra: { name: "read_file", arguments: { path: "b.txt" } },
+					},
+					partial: false,
+				},
+			]
+			mockTask.currentStreamingContentIndex = 0
+			mockTask.didAlreadyUseTool = false
+			mockTask.userMessageContent = []
+			mockTask.consecutiveMistakeCount = 0
+
+			await presentAssistantMessage(mockTask)
+
+			const fingerprintB = state.getFingerprint("PARAM_TYPE_MISMATCH")
+			expect(fingerprintB).toContain("NESTED_PARAM_OVERFLOW")
+			expect(fingerprintB).not.toBe(fingerprintA)
+			// After a shape change the circuit restarts, so occurrence is 1
+			// and the message is the first-occurrence NESTED_PARAM_OVERFLOW
+			// guidance rather than a repeat/stuck-loop escalation.
+			expect(mockTask.recordToolError).toHaveBeenLastCalledWith(
+				"read_file",
+				expect.stringContaining("NESTED_PARAM_OVERFLOW"),
+			)
+			expect(state.isOpen("PARAM_TYPE_MISMATCH")).toBe(false)
+		})
+	})
+
 	describe("missing tool_use.id (legacy XML call)", () => {
 		it("transforms the error through interceptor and pushes guided text", async () => {
 			mockTask.assistantMessageContent = [