Add RALPH-loop recipe to Copilot SDK cookbook

Add iterative RALPH-loop (Read, Act, Log, Persist, Halt) pattern
implementations for all four supported languages:

- C#/.NET: ralph-loop.cs with documentation
- Node.js/TypeScript: ralph-loop.ts with documentation
- Python: ralph_loop.py with documentation (async API)
- Go: ralph-loop.go with documentation

Each recipe demonstrates:
- Self-referential iteration where AI reviews its own output
- Completion promise detection to halt the loop
- Max iteration safety limits
- File persistence between iterations

Verified against real Copilot SDK APIs:
- Python: fully verified end-to-end with github-copilot-sdk
- Node.js: fully verified end-to-end with @github/copilot-sdk
- C#: compiles and runs successfully with GitHub.Copilot.SDK
- Go: compiles against github.com/github/copilot-sdk/go v0.1.23

cookbook/copilot-sdk/python/recipe/ralph_loop.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+
+import asyncio
+
+from copilot import CopilotClient, MessageOptions, SessionConfig
+
+
+class RalphLoop:
+    """
+    RALPH-loop implementation: Iterative self-referential AI loops.
+
+    The same prompt is sent repeatedly, with AI reading its own previous output.
+    Loop continues until completion promise is detected in the response.
+    """
+
+    def __init__(self, max_iterations=10, completion_promise="COMPLETE"):
+        """Initialize RALPH-loop with iteration limits and completion detection."""
+        self.client = CopilotClient()
+        self.iteration = 0
+        self.max_iterations = max_iterations
+        self.completion_promise = completion_promise
+        self.last_response = None
+
+    async def run(self, initial_prompt):
+        """
+        Run the RALPH-loop until completion promise is detected or max iterations reached.
+        """
+        await self.client.start()
+        session = await self.client.create_session(
+            SessionConfig(model="gpt-5.1-codex-mini")
+        )
+
+        try:
+            while self.iteration < self.max_iterations:
+                self.iteration += 1
+                print(f"\n=== Iteration {self.iteration}/{self.max_iterations} ===")
+
+                current_prompt = self._build_iteration_prompt(initial_prompt)
+                print(f"Sending prompt (length: {len(current_prompt)})...")
+
+                result = await session.send_and_wait(
+                    MessageOptions(prompt=current_prompt),
+                    timeout=300,
+                )
+
+                self.last_response = result.data.content if result else ""
+
+                # Display response summary
+                summary = (
+                    self.last_response[:200] + "..."
+                    if len(self.last_response) > 200
+                    else self.last_response
+                )
+                print(f"Response: {summary}")
+
+                # Check for completion promise
+                if self.completion_promise in self.last_response:
+                    print(
+                        f"\n✓ Success! Completion promise detected: '{self.completion_promise}'"
+                    )
+                    return self.last_response
+
+                print(
+                    f"Iteration {self.iteration} complete. Checking for next iteration..."
+                )
+
+            raise RuntimeError(
+                f"Maximum iterations ({self.max_iterations}) reached without "
+                f"detecting completion promise: '{self.completion_promise}'"
+            )
+
+        except Exception as e:
+            print(f"\nError during RALPH-loop: {e}")
+            raise
+        finally:
+            await session.destroy()
+            await self.client.stop()
+
+    def _build_iteration_prompt(self, initial_prompt):
+        """Build the prompt for the current iteration, including previous output as context."""
+        if self.iteration == 1:
+            return initial_prompt
+
+        return f"""{initial_prompt}
+
+=== CONTEXT FROM PREVIOUS ITERATION ===
+{self.last_response}
+=== END CONTEXT ===
+
+Continue working on this task. Review the previous attempt and improve upon it."""
+
+
+async def main():
+    """Example usage demonstrating RALPH-loop."""
+    prompt = """You are iteratively building a small library. Follow these phases IN ORDER.
+Do NOT skip ahead — only do the current phase, then stop and wait for the next iteration.
+
+Phase 1: Design a DataValidator class that validates records against a schema.
+  - Schema defines field names, types (str, int, float, bool), and whether required.
+  - Return a list of validation errors per record.
+  - Show the class code only. Do NOT output COMPLETE.
+
+Phase 2: Write at least 4 unit tests covering: missing required field, wrong type,
+  valid record, and empty input. Show test code only. Do NOT output COMPLETE.
+
+Phase 3: Review the code from phases 1 and 2. Fix any bugs, add docstrings, and add
+  an extra edge-case test. Show the final consolidated code with all fixes.
+  When this phase is fully done, output the exact text: COMPLETE"""
+
+    loop = RalphLoop(max_iterations=5, completion_promise="COMPLETE")
+
+    try:
+        result = await loop.run(prompt)
+        print("\n=== FINAL RESULT ===")
+        print(result)
+    except RuntimeError as e:
+        print(f"\nTask did not complete: {e}")
+        if loop.last_response:
+            print(f"\nLast attempt:\n{loop.last_response}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())