@inceptionstack/roundhouse 0.5.22 → 0.5.26

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to `@inceptionstack/roundhouse` are documented here.
 
+## [0.5.25] — 2026-05-12
+
+### Fixed
+- **Emergency-compact loop** — when a pi session exceeded the model's context limit (e.g. Bedrock 200k), the memory-flush step sent a prompt through the already-overloaded session, which the provider rejected, leaving `pendingCompact = "emergency"` re-armed on every turn (infinite loop). Fix: on emergency pressure, skip flush entirely and go straight to `session.compact()`, which builds its own summarization payload from older history and does not require the live session to fit under the limit. (#122)
+- **Telemetry:** `timing.model` no longer mis-reports the flush model when the adapter lacks `compactWithModel`. Documented remaining BaseAdapter-shim ambiguity inline. (#122)
+- **Soft flush no longer blocks thread lock** — Haiku flush (30–120s) runs outside the lock; hard/emergency compact still inside for memory invariants. Removes 2-minute silent dead zones after user messages. (#110)
+- **Session auto-repair** — corrupted session history (orphan tool-call/result pairs from crashed tools) is now detected and the session file repaired on the fly, preventing permanent thread wedging. (#118)
+- **Sub-agent orphan recovery** — watcher checks stdout before marking a run failed on non-zero exit, so runs that produced output survive process crashes. (#109)
+- **Sub-agent completion on non-zero exit** — runs with stdout output treated as complete regardless of exit code. (#105)
+- **Sub-agents run with `--no-extensions --no-skills`** — prevents stale-context crashes on teardown. (#107)
+- **Boot turn** — synthetic thread now fully transport-agnostic via `transport.createThread()`. Fixes Telegram coupling and missing `handleStream`. (#100, #102, #103)
+
+### Added
+- **`/topic` inline keyboard** — tap-to-switch topic menu in private chats with `🏠 main` escape button; falls back to text list when no topics exist. Sentinel design: button value is `-main` so user input can never collide (leading `-` stripped by normalizer). (#120)
+- **Cron management notifications via IPC** — `roundhouse cron add/pause/resume/trigger/delete` now posts to the active transport without spawning an agent turn. (#114)
+- **Sub-agent completion injects result into parent agent** — synthetic agent turn fires with stdout, so the parent "hears" what the sub-agent did. (#108)
+- **Sub-agent launch notification** (🔬) via `onSpawn()` observer on the orchestrator interface. (#111, #112)
+
+### Changed
+- **Gateway notifications use markdown** — transport adapters convert to their native format (Telegram HTML, future Slack mrkdwn). Removed `parseMode` from the transport interface. (#113)
+- **Command dispatch: descriptor pattern** — each command declares `{triggers, stage, acceptsArgs, invoke, actions}` and the gateway iterates a single list. Replaces three branching dispatch loops. Adding a command is now one object literal. (#121)
+- **Clean code pass** on `cron-commands` + gateway (SRP/DRY extraction). (#115)
+- **Slack adapter design doc** added (Socket Mode, `pairedChannels`, DM-based pairing, progressive streaming). (#116, #117)
+
 ## [0.5.19] — 2026-05-10
 - Sub-agent orchestrator: spawn background Pi agents for review/research/scout/implementation
 - CLI: `roundhouse subagent spawn/status/list/abort`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inceptionstack/roundhouse",
-  "version": "0.5.22",
+  "version": "0.5.26",
   "type": "module",
   "description": "Multi-platform chat gateway that routes messages through a configured AI agent",
   "license": "MIT",

package/src/agents/pi/pi-adapter.ts

@@ -28,6 +28,7 @@ import {
 
 import type { AgentAdapter, AgentAdapterFactory, AgentMessage, AgentResponse, AgentStreamEvent, MessageContext } from "../../types";
 import { formatMessage, extractCustomMessage, customContentToText } from "./message-format";
+import { isToolPairingError, repairSessionFile } from "../shared/session-repair";
 import { SESSIONS_DIR } from "../../config";
 import { DEBUG_STREAM, threadIdToDir } from "../../util";
 
@@ -35,6 +36,8 @@ interface SessionEntry {
   session: AgentSession;
   lastUsed: number;
   inFlight: number;
+  /** Captured config used to recreate the session after disk-level repair. */
+  threadId?: string;
 }
 
 const DEFAULT_SESSIONS_DIR = SESSIONS_DIR;
@@ -80,10 +83,94 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
   }
 
 
-  async function runPromptAndFollowUps(entry: SessionEntry, text: string, onDraining?: () => void, onDrainComplete?: () => void): Promise<void> {
+  /**
+   * Callback shape for re-subscribing after a mid-turn session swap (auto-repair).
+   * Caller provides:
+   *   - `subscribe(session)` — re-attach the caller's event handler to the new session
+   *   - `unsubscribeOld()` — detach from the old session before it's disposed
+   *
+   * Ordering inside runPromptAndFollowUps on repair:
+   *   1. unsubscribeOld() on the pre-repair session
+   *   2. dispose old session
+   *   3. repair + reload
+   *   4. subscribe(newSession) so the retry's events reach the caller
+   */
+  interface Resubscribe {
+    unsubscribeOld: () => void;
+    subscribe: (session: AgentSession) => void;
+  }
+
+  async function runPromptAndFollowUps(
+    entry: SessionEntry,
+    text: string,
+    onDraining?: () => void,
+    onDrainComplete?: () => void,
+    resubscribe?: Resubscribe,
+  ): Promise<void> {
     entry.inFlight++;
+    // Track whether *this specific prompt call* has already retried after a
+    // repair. Prevents retry loops within one turn, but doesn't latch the
+    // SessionEntry for its whole lifetime — a future prompt on the same
+    // long-lived entry can still auto-repair if new corruption appears (F3).
+    let repairedThisCall = false;
     try {
-      await entry.session.prompt(text);
+      try {
+        await entry.session.prompt(text);
+      } catch (err) {
+        // Auto-recover from session-history corruption (orphaned toolCall/toolResult
+        // pairs caused by crashed/aborted tools mid-session). Repair the .jsonl on
+        // disk, reload the session, retry once. Do NOT loop — if the repaired file
+        // still fails, something else is wrong; surface the original error.
+        if (!isToolPairingError(err) || repairedThisCall) {
+          throw err;
+        }
+        repairedThisCall = true;
+        const sessionFile = entry.session.sessionFile;
+        if (!sessionFile) {
+          throw err; // in-memory session — nothing to repair on disk
+        }
+        console.warn(`[pi-agent] tool-pairing error detected on session ${sessionFile} — attempting repair`);
+        const report = repairSessionFile(sessionFile);
+        if (!report.repaired) {
+          // File had no orphans but model still rejected — not our problem to fix.
+          console.warn(`[pi-agent] repair found no orphans; re-throwing original error`);
+          throw err;
+        }
+        console.warn(
+          `[pi-agent] repaired session: dropped ${report.droppedEntryIds.length} entries ` +
+          `(${report.droppedToolCallIds.length} toolCalls, ${report.droppedToolResultIds.length} toolResults). ` +
+          `Backup: ${report.backupPath}`
+        );
+        // Detach caller's subscriber from the dying session before we swap, so
+        // it doesn't receive events from (or prevent GC of) the old session.
+        resubscribe?.unsubscribeOld();
+        // Reload session FIRST (before disposing old) so that if
+        // SessionManager.open / createAgentSession throws, we don't leave the
+        // SessionEntry with a disposed-but-still-referenced session that
+        // subsequent prompts would reuse. Old session stays alive as fallback
+        // until the new one is fully constructed.
+        let reloaded: { session: AgentSession };
+        try {
+          reloaded = await reloadSession(entry, sessionFile);
+        } catch (reloadErr) {
+          console.warn(`[pi-agent] reloadSession failed after repair — keeping old session, re-subscribing`, reloadErr);
+          // Re-attach to the old session so the caller isn't silently orphaned.
+          resubscribe?.subscribe(entry.session);
+          throw err; // surface original tool-pairing error — repair didn't help
+        }
+        // Now it's safe to dispose the old session: we have a working replacement.
+        const oldSession = entry.session;
+        entry.session = reloaded.session;
+        try {
+          oldSession.dispose();
+        } catch (disposeErr) {
+          console.warn(`[pi-agent] old session dispose failed (non-fatal):`, disposeErr);
+        }
+        // Re-attach caller's subscriber to the new session so the retry's
+        // text_delta/tool events flow through (F1).
+        resubscribe?.subscribe(entry.session);
+        await entry.session.prompt(text);
+      }
       await drainSessionEvents(entry.session);
 
       // Check for pending follow-up work AFTER drainSessionEvents — that's
@@ -138,6 +225,38 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
     }
   }
 
+  /**
+   * Rebuild just the AgentSession for an existing SessionEntry. Used after
+   * on-disk session repair — we need pi-ai to re-read the fixed .jsonl, which
+   * means a fresh SessionManager + createAgentSession call.
+   *
+   * Intentionally does NOT re-run one-time setup (memory-capability detection,
+   * tool registration) — those belong to createSession(). This is a narrow
+   * "replace the pi session object" operation.
+   *
+   * Opens the *exact* repaired file by path (not continueRecent) to avoid
+   * picking up a different recent session file.
+   */
+  async function reloadSession(entry: SessionEntry, repairedSessionFile: string): Promise<{ session: AgentSession }> {
+    const threadId = entry.threadId;
+    if (!threadId) {
+      throw new Error("reloadSession: entry has no threadId; cannot reload");
+    }
+    const dirName = threadIdToDir(threadId);
+    const threadDir = join(sessionsDir, dirName);
+    // Open the specific repaired file by path so we don't race with other
+    // session files in the directory (F4).
+    const sessionManager = SessionManager.open(repairedSessionFile, threadDir, cwd);
+    console.log(`[pi-agent] reloaded session for ${threadId}: ${sessionManager.getSessionFile()}`);
+    const result = await createAgentSession({
+      cwd,
+      sessionManager,
+      authStorage,
+      modelRegistry,
+    });
+    return { session: result.session };
+  }
+
   async function createSession(threadId: string): Promise<SessionEntry> {
     const dirName = threadIdToDir(threadId);
     const threadDir = join(sessionsDir, dirName);
@@ -181,7 +300,7 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
       console.log(`[pi-agent] model fallback: ${result.modelFallbackMessage}`);
     }
 
-    const entry: SessionEntry = { session: result.session, lastUsed: Date.now(), inFlight: 0 };
+    const entry: SessionEntry = { session: result.session, lastUsed: Date.now(), inFlight: 0, threadId };
     sessions.set(threadId, entry);
 
     // Detect memory capabilities from loaded extensions (first session only)
@@ -346,7 +465,10 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
             const entry = await getOrCreate(threadId);
             entry.lastUsed = Date.now();
 
-            const unsub = entry.session.subscribe((event: AgentSessionEvent) => {
+            // Extracted subscriber handler so it can be re-attached after an
+            // auto-repair session swap (captures only the enqueue closure,
+            // not `entry.session`, so it's safe to re-use).
+            const handleEvent = (event: AgentSessionEvent) => {
               if (DEBUG_STREAM) {
                 const extra =
                   event.type === "message_end" || event.type === "message_start"
@@ -384,21 +506,34 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
                 eventQueue.push(streamEvent);
                 resolve?.();
               }
-            });
+            };
+
+            // Subscription is mutable so auto-repair can swap it when the
+            // session is reloaded mid-prompt.
+            let unsub = entry.session.subscribe(handleEvent);
 
             try {
-              await runPromptAndFollowUps(entry, text, () => {
-                eventQueue.push({ type: "draining" });
-                resolve?.();
-              }, () => {
-                eventQueue.push({ type: "drain_complete" });
-                resolve?.();
-              });
+              await runPromptAndFollowUps(
+                entry,
+                text,
+                () => {
+                  eventQueue.push({ type: "draining" });
+                  resolve?.();
+                },
+                () => {
+                  eventQueue.push({ type: "drain_complete" });
+                  resolve?.();
+                },
+                {
+                  unsubscribeOld: () => { try { unsub(); } catch { /* ignore */ } },
+                  subscribe: (newSession) => { unsub = newSession.subscribe(handleEvent); },
+                },
+              );
               // Final drain — guarantees all subscriber events have been delivered
               // before we unsubscribe below.
               await drainSessionEvents(entry.session);
             } finally {
-              unsub();
+              try { unsub(); } catch { /* ignore */ }
               eventQueue.push({ type: "agent_end" });
               done = true;
               resolve?.();
@@ -591,7 +726,7 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
     entry.lastUsed = Date.now();
 
     let fullText = "";
-    const unsub = entry.session.subscribe((event: AgentSessionEvent) => {
+    const handleEvent = (event: AgentSessionEvent) => {
       if (
         event.type === "message_update" &&
         event.assistantMessageEvent.type === "text_delta"
@@ -603,13 +738,17 @@ export const createPiAgentAdapter: AgentAdapterFactory = (config) => {
           fullText += "\n\n" + custom.content;
         }
       }
-    });
+    };
+    let unsub = entry.session.subscribe(handleEvent);
 
     try {
-      await runPromptAndFollowUps(entry, text);
+      await runPromptAndFollowUps(entry, text, undefined, undefined, {
+        unsubscribeOld: () => { try { unsub(); } catch { /* ignore */ } },
+        subscribe: (newSession) => { unsub = newSession.subscribe(handleEvent); },
+      });
       await drainSessionEvents(entry.session);
     } finally {
-      unsub();
+      try { unsub(); } catch { /* ignore */ }
     }
 
     return { text: fullText };

package/src/agents/shared/message-validator.test.ts

@@ -0,0 +1,351 @@
+/**
+ * message-validator.test.ts — Tests for message history validation
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateToolPairing,
+  stripOrphanedResults,
+  validateAndRepair,
+  type Message,
+} from './message-validator';
+
+describe('message-validator', () => {
+  describe('validateToolPairing', () => {
+    it('passes when all toolCalls and toolResults match', () => {
+      const messages: Message[] = [
+        {
+          role: 'user',
+          content: 'help me',
+          timestamp: 1,
+        },
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 2,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 3,
+        },
+      ];
+
+      const result = validateToolPairing(messages);
+      expect(result.isValid).toBe(true);
+      expect(result.orphanedCount).toBe(0);
+      expect(result.orphanedToolCallIds).toEqual([]);
+      expect(result.orphanedToolResultIds).toEqual([]);
+    });
+
+    it('detects orphaned toolResults (no matching toolCall)', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 2,
+        },
+        {
+          role: 'toolResult', // No matching toolCall!
+          toolCallId: 'orphan-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'orphan' }],
+          isError: false,
+          timestamp: 3,
+        },
+      ];
+
+      const result = validateToolPairing(messages);
+      expect(result.isValid).toBe(false);
+      expect(result.orphanedToolResultIds).toContain('orphan-1');
+      expect(result.orphanedCount).toBe(1);
+    });
+
+    it('detects orphaned toolCalls (no matching toolResult)', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+            { type: 'toolCall', id: 'call-2', name: 'read', arguments: {} }, // No result!
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 2,
+        },
+      ];
+
+      const result = validateToolPairing(messages);
+      expect(result.isValid).toBe(false);
+      expect(result.orphanedToolCallIds).toContain('call-2');
+    });
+
+    it('detects out-of-order: toolResult before toolCall', () => {
+      const messages: Message[] = [
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'result' }],
+          isError: false,
+          timestamp: 1,
+        },
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 2,
+        },
+      ];
+
+      const result = validateToolPairing(messages);
+      expect(result.isValid).toBe(false);
+      expect(result.orphanedToolResultIds).toContain('call-1');
+    });
+
+    it('handles empty history', () => {
+      const result = validateToolPairing([]);
+      expect(result.isValid).toBe(true);
+      expect(result.orphanedCount).toBe(0);
+    });
+  });
+
+  describe('stripOrphanedResults', () => {
+    it('removes orphaned toolResult messages', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 2,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'orphan-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'orphan' }],
+          isError: false,
+          timestamp: 3,
+        },
+      ];
+
+      const cleaned = stripOrphanedResults(messages);
+      expect(cleaned).toHaveLength(2);
+      expect(cleaned).not.toContainEqual(
+        expect.objectContaining({ toolCallId: 'orphan-1' })
+      );
+    });
+
+    it('removes toolCall blocks from assistant messages with orphaned IDs', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+            { type: 'toolCall', id: 'call-2', name: 'read', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 2,
+        },
+      ];
+
+      const cleaned = stripOrphanedResults(messages);
+      expect(cleaned).toHaveLength(2);
+      const assistant = cleaned[0] as any;
+      expect(assistant.content).toHaveLength(1);
+      expect(assistant.content[0].id).toBe('call-1');
+    });
+
+    it('removes entire assistant message if all toolCalls are orphaned', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+      ];
+
+      const cleaned = stripOrphanedResults(messages);
+      expect(cleaned).toHaveLength(0);
+    });
+
+    it('keeps assistant message if it has text content despite orphaned toolCall', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: 'thinking...' },
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+      ];
+
+      const cleaned = stripOrphanedResults(messages);
+      expect(cleaned).toHaveLength(1);
+      const assistant = cleaned[0] as any;
+      expect(assistant.content).toHaveLength(1);
+      expect(assistant.content[0].type).toBe('text');
+    });
+
+    it('returns original array if no orphans', () => {
+      const messages: Message[] = [
+        { role: 'user', content: 'hello', timestamp: 1 },
+      ];
+      const cleaned = stripOrphanedResults(messages);
+      expect(cleaned).toBe(messages); // Same reference
+    });
+  });
+
+  describe('validateAndRepair', () => {
+    it('returns wasRepaired=false for valid history', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 2,
+        },
+      ];
+
+      const result = validateAndRepair(messages);
+      expect(result.wasRepaired).toBe(false);
+      expect(result.strippedCount).toBe(0);
+      expect(result.messages).toBe(messages);
+    });
+
+    it('repairs and reports orphaned calls + results', () => {
+      const messages: Message[] = [
+        {
+          role: 'assistant',
+          content: [
+            { type: 'toolCall', id: 'call-1', name: 'bash', arguments: {} },
+            { type: 'toolCall', id: 'orphan-call', name: 'read', arguments: {} },
+          ],
+          api: 'bedrock-converse-stream',
+          provider: 'amazon-bedrock',
+          model: 'claude-opus',
+          usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+          stopReason: 'toolUse',
+          timestamp: 1,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'call-1',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'ok' }],
+          isError: false,
+          timestamp: 2,
+        },
+        {
+          role: 'toolResult',
+          toolCallId: 'orphan-result',
+          toolName: 'bash',
+          content: [{ type: 'text', text: 'orphan' }],
+          isError: false,
+          timestamp: 3,
+        },
+      ];
+
+      const result = validateAndRepair(messages);
+      expect(result.wasRepaired).toBe(true);
+      expect(result.strippedCount).toBe(2);
+      expect(result.strippedCallIds).toContain('orphan-call');
+      expect(result.strippedResultIds).toContain('orphan-result');
+    });
+  });
+});