fix(orchestrator): always use delta mode when statefulMarker exists

**Problem:**
Claude models were looping - repeating the same actions over and over.
Root cause: SAM sent FULL conversation history even when statefulMarker existed,
causing Claude to see its own previous responses and repeat them.

**Investigation:**
1. Studied VS Code Copilot Chat reference implementation
2. Found they ALWAYS slice messages when previous_response_id exists
3. SAM only sliced when hasToolResults=true (workflow mode)
4. Regular conversations sent full history + statefulMarker = loops!

**Solution:**
Changed stateful marker slicing from:
  `if let marker = statefulMarker, hasToolResults {`
To:
  `if let marker = statefulMarker {`

Now SAM ALWAYS uses delta-only mode when statefulMarker exists, matching
VS Code behavior. Server already knows history up to marker, only send new messages.

**Why This Prevents Loops:**
- Before: Claude sees "I listed directory" → repeats same action → loop
- After: Claude only sees NEW context since last response → continues forward

**Also Fixed:**
1. Trailing whitespace bug (trim content before sending to API)
2. Tool result preview filtering (don't send UI-only messages)
3. Added message ID field to OpenAIChatMessage for future enhancements

**Testing:**
✅ Build: PASS
Next: Test with Claude to verify loop prevention

**References:**
- VS Code: reference/vscode-copilot-chat/src/platform/endpoint/node/responsesApi.ts
- Archive fix: ai-assisted/archive/similar-bug-20241218/handoff/fix-details.md

Author: fewtarius

.gitignore

@@ -65,3 +65,5 @@ scratch/
 
 # Generated release notes
 release-notes/
+
+reference/

Sources/APIFramework/AgentOrchestrator.swift

@@ -4274,22 +4274,27 @@ public class AgentOrchestrator: ObservableObject, IterationController {
         let messagesToAppend = internalMessages[...]
         logger.debug("INTERNAL_MESSAGES: Sending all \(internalMessages.count) internal messages (tool calls + results)")
 
-        /// Delta-only slicing ONLY when statefulMarker exists AND we have tool results
-        /// Previously, slicing happened whenever statefulMarker existed, even for subsequent user messages
-        /// This caused messagesToSend to be empty when user sent a follow-up message, removing all context!
-        /// /// CORRECT BEHAVIOR:
-        /// 1. statefulMarker + hasToolResults = delta-only mode (workflow iteration) - skip conversation history
-        /// 2. statefulMarker + NO tool results = subsequent user message - send FULL conversation history
-        /// 3. NO statefulMarker = first message or fresh start - send FULL conversation history
-        if let marker = statefulMarker, hasToolResults {
-            /// Delta-only mode: This is a workflow iteration with tool results
-            /// Server has full history up to marker, only need to send tool execution delta
+        /// Delta-only slicing when statefulMarker exists (GitHub Copilot session continuity)
+        /// CRITICAL FIX: Always slice when statefulMarker exists, not just for tool results!
+        /// Previous bug: Only sliced when hasToolResults=true, causing Claude to loop by seeing its own responses
+        ///
+        /// CORRECT BEHAVIOR:
+        /// 1. statefulMarker exists = delta-only mode - send ONLY messages after the marker
+        /// 2. NO statefulMarker = first message or fresh start - send FULL conversation history
+        ///
+        /// WHY THIS PREVENTS LOOPS:
+        /// - statefulMarker represents server's knowledge up to that point
+        /// - Sending full history + statefulMarker = model sees its own previous responses
+        /// - Claude sees "I listed directory before" → repeats same action → infinite loop!
+        /// - Slicing = model only sees NEW context since last response → continues forward
+        if let marker = statefulMarker {
+            /// Delta-only mode: Server has full history up to marker, only need to send new messages
             /// PREFERRED: Use message count from when marker was captured (no timing dependencies)
             if let markerMessageCount = statefulMarkerMessageCount {
                 /// Slice to only include messages AFTER the marker count
                 let sliceIndex = markerMessageCount
                 messagesToSend = Array(messagesToSend.suffix(from: min(sliceIndex, messagesToSend.count)))
-                logger.debug("STATEFUL_MARKER_SLICING: Using message count \(markerMessageCount), sending \(messagesToSend.count) messages after marker (delta-only mode with tool results)")
+                logger.debug("STATEFUL_MARKER_SLICING: Using message count \(markerMessageCount), sending \(messagesToSend.count) messages after marker (delta-only mode)")
             }
             /// FALLBACK: Search for marker in messages (timing-dependent)
             else if let markerIndex = messagesToSend.lastIndex(where: { $0.githubCopilotResponseId == marker }) {
@@ -4299,10 +4304,6 @@ public class AgentOrchestrator: ObservableObject, IterationController {
             } else {
                 logger.warning("STATEFUL_MARKER_WARNING: Marker \(marker.prefix(20))... not found in conversation AND no message count available, sending full history (\(messagesToSend.count) messages)")
             }
-        } else if statefulMarker != nil && !hasToolResults {
-            /// Subsequent user message scenario: statefulMarker exists but no tool results yet
-            /// Do NOT slice conversation history - user needs full context for their new message!
-            logger.debug("SUBSEQUENT_USER_MESSAGE: StatefulMarker exists but no tool results - sending FULL conversation history (\(messagesToSend.count) messages) for user context")
         } else {
             logger.debug("INFO: No statefulMarker, sending all \(messagesToSend.count) conversation messages")
         }

Sources/APIFramework/OpenAIModels.swift

@@ -230,13 +230,15 @@ public enum ServerOpenAIRole: String, Codable {
 
 /// OpenAI chat message DESIGN NOTE: Content is optional to support OpenAI tool calling where assistant messages may contain only tool_calls without text content.
 public struct OpenAIChatMessage: Content, Sendable {
+    public let id: String?  // Message ID for stateful marker tracking
     public let role: String
     public let content: String?
     public let toolCalls: [OpenAIToolCall]?
     public let toolCallId: String?
 
     /// Standard message constructor (backward compatible).
     public init(role: String, content: String) {
+        self.id = nil  // Legacy messages don't have IDs
         self.role = role
         self.content = content
         self.toolCalls = nil
@@ -245,6 +247,7 @@ public struct OpenAIChatMessage: Content, Sendable {
 
     /// Tool calling constructor (future use).
     public init(role: String, content: String?, toolCalls: [OpenAIToolCall]?) {
+        self.id = nil
         self.role = role
         self.content = content
         self.toolCalls = toolCalls
@@ -253,14 +256,24 @@ public struct OpenAIChatMessage: Content, Sendable {
 
     /// Tool result constructor (future use).
     public init(role: String, content: String, toolCallId: String) {
+        self.id = nil
         self.role = role
         self.content = content
         self.toolCalls = nil
         self.toolCallId = toolCallId
     }
+    
+    /// Message constructor with ID for stateful marker tracking.
+    public init(id: String?, role: String, content: String?, toolCalls: [OpenAIToolCall]? = nil, toolCallId: String? = nil) {
+        self.id = id
+        self.role = role
+        self.content = content
+        self.toolCalls = toolCalls
+        self.toolCallId = toolCallId
+    }
 
     enum CodingKeys: String, CodingKey {
-        case role, content
+        case id, role, content
         case toolCalls = "tool_calls"
         case toolCallId = "tool_call_id"
     }