nova-terminal-assistant 0.1.0

package/src/core/session/AgentLoop.ts

@@ -0,0 +1,501 @@
+// ============================================================================
+// AgentLoop - Core agent execution loop with tool use
+// ============================================================================
+
+import type {
+  SessionId,
+  Message,
+  ContentBlock,
+  ToolUseContent,
+  ToolResultContent,
+  ToolCallId,
+  SessionConfig,
+  ApprovalMode,
+  ApprovalRequest,
+  ApprovalResponse,
+} from '../types/session.js';
+import type { ToolDefinition, ToolHandlerInput, ToolHandlerOutput } from '../types/tools.js';
+import type { ModelClient } from '../model/ModelClient.js';
+import type { SessionManager } from './SessionManager.js';
+import type { ContextCompressor } from '../context/ContextCompressor.js';
+import { ToolRegistry } from '../tools/ToolRegistry.js';
+import { createMessageId, createToolCallId } from '../types/session.js';
+import { ToolError, CancelledError, SessionError, TimeoutError } from '../types/errors.js';
+
+/** Maximum tool result size in characters (to prevent token waste) */
+const MAX_TOOL_RESULT_CHARS = 10_000;
+
+function truncateToolResult(content: string): string {
+  if (content.length <= MAX_TOOL_RESULT_CHARS) return content;
+  return content.slice(0, MAX_TOOL_RESULT_CHARS) +
+    `\n... [truncated: ${content.length} total chars, showing first ${MAX_TOOL_RESULT_CHARS}]`;
+}
+
+export interface AgentLoopOptions {
+  modelClient: ModelClient;
+  sessionManager: SessionManager;
+  toolRegistry: ToolRegistry;
+  /** System prompt to send with every request */
+  systemPrompt?: string;
+  /** Context compressor for intelligent context management */
+  contextCompressor?: ContextCompressor;
+  /** Maximum context window tokens (for compression decisions) */
+  maxContextTokens?: number;
+  /** Control thinking mode: enabled|disabled|auto */
+  thinking?: string;
+  /** Called when tool approval is needed */
+  onApprovalRequired?: (request: ApprovalRequest) => Promise<ApprovalResponse>;
+  /** Called for each streaming text delta */
+  onTextDelta?: (text: string) => void;
+  /** Called when a tool starts executing */
+  onToolStart?: (toolName: string, toolCallId: string) => void;
+  /** Called when a tool finishes */
+  onToolComplete?: (toolName: string, toolCallId: string, result: ToolHandlerOutput) => void;
+  /** Called when the loop iteration starts */
+  onTurnStart?: (turn: number) => void;
+  /** Called when the loop iteration ends */
+  onTurnEnd?: (turn: number) => void;
+  /** Called when thinking/reasoning content starts streaming */
+  onThinkingStart?: () => void;
+  /** Called for each thinking content delta */
+  onThinkingDelta?: (delta: string) => void;
+  /** Called when thinking content ends */
+  onThinkingEnd?: () => void;
+  /** Called when context compression happens */
+  onContextCompress?: (originalTokens: number, resultingTokens: number, action: string) => void;
+}
+
+export interface AgentLoopResult {
+  messages: Message[];
+  turnsCompleted: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  stopReason: string;
+}
+
+export class AgentLoop {
+  private modelClient: ModelClient;
+  private sessionManager: SessionManager;
+  private toolRegistry: ToolRegistry;
+  private options: Omit<AgentLoopOptions, 'modelClient' | 'sessionManager' | 'toolRegistry'>;
+  private systemPrompt?: string;
+  private abortController: AbortController | null = null;
+  private isRunning = false;
+  private contextCompressor?: ContextCompressor;
+  private maxContextTokens: number;
+  private thinking?: string;
+
+  constructor(options: AgentLoopOptions) {
+    this.modelClient = options.modelClient;
+    this.sessionManager = options.sessionManager;
+    this.toolRegistry = options.toolRegistry;
+    this.systemPrompt = options.systemPrompt;
+    this.contextCompressor = options.contextCompressor;
+    this.maxContextTokens = options.maxContextTokens || 128000;
+    this.thinking = options.thinking;
+    this.options = {
+      onApprovalRequired: options.onApprovalRequired,
+      onTextDelta: options.onTextDelta,
+      onToolStart: options.onToolStart,
+      onToolComplete: options.onToolComplete,
+      onTurnStart: options.onTurnStart,
+      onTurnEnd: options.onTurnEnd,
+      onThinkingStart: options.onThinkingStart,
+      onThinkingDelta: options.onThinkingDelta,
+      onThinkingEnd: options.onThinkingEnd,
+      onContextCompress: options.onContextCompress,
+    };
+  }
+
+  /**
+   * Check if context compression is needed and apply it.
+   * Returns the (possibly compressed) message list.
+   */
+  private maybeCompressContext(messages: Message[]): Message[] {
+    if (!this.contextCompressor) return messages;
+
+    const result = this.contextCompressor.compress(messages, {
+      maxTokens: this.maxContextTokens,
+    });
+
+    if (result.action !== 'keep' && result.originalTokens !== result.resultingTokens) {
+      this.options.onContextCompress?.(
+        result.originalTokens,
+        result.resultingTokens,
+        result.action
+      );
+    }
+
+    return result.messages;
+  }
+
+  /** Run the agent loop until completion or max turns */
+  async run(sessionId: SessionId, userMessage?: string): Promise<AgentLoopResult> {
+    if (this.isRunning) {
+      throw new SessionError('Agent loop is already running', sessionId);
+    }
+
+    this.isRunning = true;
+    this.abortController = new AbortController();
+
+    const sessionManager = this.sessionManager;
+    const config = sessionManager.getConfig(sessionId);
+
+    // Set state to running
+    sessionManager.setState(sessionId, 'running');
+
+    try {
+      // Add user message if provided
+      if (userMessage) {
+        sessionManager.addMessage(sessionId, 'user', [
+          { type: 'text', text: userMessage },
+        ]);
+      }
+
+      let turnsCompleted = 0;
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      let finalStopReason = 'end_turn';
+
+      // Agent loop
+      while (turnsCompleted < (config.maxTurns || 100)) {
+        if (this.abortController.signal.aborted) {
+          throw new CancelledError('Agent loop cancelled');
+        }
+
+        turnsCompleted++;
+        this.options.onTurnStart?.(turnsCompleted);
+
+        // Get current messages (with optional context compression)
+        let messages = sessionManager.getMessages(sessionId);
+        messages = this.maybeCompressContext(messages);
+        const tools = this.toolRegistry.getAllDefinitions();
+
+        // Call the model
+        const response = await this.modelClient.complete(messages, tools, sessionId, {
+          systemPrompt: this.systemPrompt,
+          thinking: this.thinking,
+        });
+
+        // Update token usage
+        totalInputTokens += response.usage.inputTokens;
+        totalOutputTokens += response.usage.outputTokens;
+        sessionManager.updateTokenUsage(sessionId, response.usage.inputTokens, response.usage.outputTokens);
+
+        // Add assistant message
+        sessionManager.addMessage(sessionId, 'assistant', response.content);
+
+        // Check if we need to execute tools
+        const toolUseBlocks = response.content.filter(
+          (c): c is ToolUseContent => c.type === 'tool_use'
+        );
+
+        if (toolUseBlocks.length === 0 || response.stopReason === 'end_turn') {
+          finalStopReason = response.stopReason;
+          break;
+        }
+
+        // Execute each tool
+        for (const toolUse of toolUseBlocks) {
+          if (this.abortController.signal.aborted) {
+            throw new CancelledError('Agent loop cancelled');
+          }
+
+          const result = await this.executeTool(
+            sessionId,
+            toolUse.id,
+            toolUse.name,
+            toolUse.input,
+            config
+          );
+
+          // Add tool result message
+          const truncatedContent = truncateToolResult(
+            typeof result.content === 'string' ? result.content : JSON.stringify(result.content)
+          );
+          sessionManager.addMessage(sessionId, 'tool', [
+            {
+              type: 'tool_result',
+              tool_use_id: toolUse.id,
+              content: truncatedContent,
+              is_error: result.isError,
+            } as ToolResultContent,
+          ]);
+        }
+
+        finalStopReason = response.stopReason;
+        this.options.onTurnEnd?.(turnsCompleted);
+
+        // Increment turn
+        const newTurn = sessionManager.incrementTurn(sessionId);
+        if (sessionManager.getState(sessionId) === 'completed') {
+          break;
+        }
+      }
+
+      sessionManager.setState(sessionId, 'idle');
+      return {
+        messages: sessionManager.getMessages(sessionId),
+        turnsCompleted,
+        totalInputTokens,
+        totalOutputTokens,
+        stopReason: finalStopReason,
+      };
+    } catch (err) {
+      sessionManager.setState(sessionId, 'error');
+      throw err;
+    } finally {
+      this.isRunning = false;
+      this.abortController = null;
+    }
+  }
+
+  /** Run the agent loop with streaming */
+  async runStream(sessionId: SessionId, userMessage?: string): Promise<AgentLoopResult> {
+    if (this.isRunning) {
+      throw new SessionError('Agent loop is already running', sessionId);
+    }
+
+    this.isRunning = true;
+    this.abortController = new AbortController();
+
+    const sessionManager = this.sessionManager;
+    const config = sessionManager.getConfig(sessionId);
+
+    sessionManager.setState(sessionId, 'running');
+
+    try {
+      if (userMessage) {
+        sessionManager.addMessage(sessionId, 'user', [
+          { type: 'text', text: userMessage },
+        ]);
+      }
+
+      let turnsCompleted = 0;
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      let finalStopReason = 'end_turn';
+
+      while (turnsCompleted < (config.maxTurns || 100)) {
+        if (this.abortController.signal.aborted) {
+          throw new CancelledError('Agent loop cancelled');
+        }
+
+        turnsCompleted++;
+        this.options.onTurnStart?.(turnsCompleted);
+
+        // Get current messages (with optional context compression)
+        let messages = sessionManager.getMessages(sessionId);
+        messages = this.maybeCompressContext(messages);
+        const tools = this.toolRegistry.getAllDefinitions();
+
+        // Streaming call
+        let currentText = '';
+        let currentThinking = '';
+        let thinkingActive = false;
+        const toolCalls = new Map<string, { name: string; inputJson: string }>();
+
+        for await (const event of this.modelClient.stream(messages, tools, sessionId, {
+          systemPrompt: this.systemPrompt,
+          thinking: this.thinking,
+        })) {
+          if (event.type === 'text_delta') {
+            // If we were thinking and now get text, close thinking block
+            if (thinkingActive) {
+              this.options.onThinkingEnd?.();
+              thinkingActive = false;
+            }
+            currentText += event.delta;
+            this.options.onTextDelta?.(event.delta);
+          } else if (event.type === 'thinking_delta') {
+            // If thinking just started, emit start event
+            if (!thinkingActive) {
+              this.options.onThinkingStart?.();
+              thinkingActive = true;
+            }
+            currentThinking += event.delta;
+            this.options.onThinkingDelta?.(event.delta);
+          } else if (event.type === 'tool_call_start') {
+            // Close thinking block if active
+            if (thinkingActive) {
+              this.options.onThinkingEnd?.();
+              thinkingActive = false;
+            }
+            toolCalls.set(event.toolCallId, { name: event.toolName, inputJson: '' });
+            this.options.onToolStart?.(event.toolName, event.toolCallId);
+          } else if (event.type === 'tool_call_delta') {
+            const tc = toolCalls.get(event.toolCallId);
+            if (tc) tc.inputJson += event.delta;
+          } else if (event.type === 'message_complete') {
+            // Close thinking block if still active
+            if (thinkingActive) {
+              this.options.onThinkingEnd?.();
+              thinkingActive = false;
+            }
+            totalInputTokens += event.usage.inputTokens;
+            totalOutputTokens += event.usage.outputTokens;
+            sessionManager.updateTokenUsage(sessionId, event.usage.inputTokens, event.usage.outputTokens);
+            finalStopReason = event.stopReason;
+          } else if (event.type === 'error') {
+            throw event.error;
+          }
+        }
+
+        // Build assistant content blocks
+        const content: ContentBlock[] = [];
+        if (currentThinking) {
+          content.push({ type: 'thinking', thinking: currentThinking });
+        }
+        if (currentText) {
+          content.push({ type: 'text', text: currentText });
+        }
+
+        for (const [id, tc] of toolCalls) {
+          let input: Record<string, unknown>;
+          try {
+            input = JSON.parse(tc.inputJson);
+          } catch {
+            input = { raw: tc.inputJson };
+          }
+          content.push({
+            type: 'tool_use',
+            id: id as ToolCallId,
+            name: tc.name,
+            input,
+          });
+        }
+
+        sessionManager.addMessage(sessionId, 'assistant', content);
+
+        const toolUseBlocks = content.filter(
+          (c): c is ToolUseContent => c.type === 'tool_use'
+        );
+
+        if (toolUseBlocks.length === 0 || finalStopReason === 'end_turn') {
+          break;
+        }
+
+        for (const toolUse of toolUseBlocks) {
+          if (this.abortController.signal.aborted) {
+            throw new CancelledError('Agent loop cancelled');
+          }
+
+          const result = await this.executeTool(
+            sessionId,
+            toolUse.id,
+            toolUse.name,
+            toolUse.input,
+            config
+          );
+
+          const truncatedContent = truncateToolResult(
+            typeof result.content === 'string' ? result.content : JSON.stringify(result.content)
+          );
+
+          sessionManager.addMessage(sessionId, 'tool', [
+            {
+              type: 'tool_result',
+              tool_use_id: toolUse.id,
+              content: truncatedContent,
+              is_error: result.isError,
+            } as ToolResultContent,
+          ]);
+        }
+
+        this.options.onTurnEnd?.(turnsCompleted);
+        const newTurn = sessionManager.incrementTurn(sessionId);
+        if (sessionManager.getState(sessionId) === 'completed') {
+          break;
+        }
+      }
+
+      sessionManager.setState(sessionId, 'idle');
+      return {
+        messages: sessionManager.getMessages(sessionId),
+        turnsCompleted,
+        totalInputTokens,
+        totalOutputTokens,
+        stopReason: finalStopReason,
+      };
+    } catch (err) {
+      sessionManager.setState(sessionId, 'error');
+      throw err;
+    } finally {
+      this.isRunning = false;
+      this.abortController = null;
+    }
+  }
+
+  /** Cancel the running agent loop */
+  cancel(): void {
+    this.abortController?.abort();
+  }
+
+  /** Check if the loop is running */
+  isActive(): boolean {
+    return this.isRunning;
+  }
+
+  /** Execute a single tool */
+  private async executeTool(
+    sessionId: SessionId,
+    toolCallId: string,
+    toolName: string,
+    toolInput: Record<string, unknown>,
+    config: SessionConfig
+  ): Promise<ToolHandlerOutput> {
+    // Check if tool requires approval
+    if (this.toolRegistry.requiresApproval(toolName, toolInput, config.approvalMode)) {
+      if (this.options.onApprovalRequired) {
+        const request: ApprovalRequest = {
+          id: toolCallId,
+          sessionId,
+          toolName,
+          toolInput,
+          risk: this.toolRegistry.getRiskLevel(toolName),
+          description: `Tool "${toolName}" with input: ${JSON.stringify(toolInput).slice(0, 200)}`,
+          timestamp: Date.now(),
+        };
+
+        const response = await this.options.onApprovalRequired(request);
+        if (!response.approved) {
+          return {
+            content: `Tool execution denied by user: ${response.reason || 'No reason provided'}`,
+            isError: true,
+          };
+        }
+
+        // Use modified input if provided
+        if (response.modifiedInput) {
+          toolInput = response.modifiedInput;
+        }
+      }
+    }
+
+    const context: ToolHandlerInput = {
+      params: toolInput,
+      context: {
+        sessionId,
+        workingDirectory: config.workingDirectory,
+        environment: {},
+        model: config.model,
+        approvalMode: config.approvalMode,
+      },
+      abortSignal: this.abortController?.signal,
+    };
+
+    try {
+      const startTime = Date.now();
+      const result = await this.toolRegistry.execute(toolName, context);
+      const duration = Date.now() - startTime;
+
+      this.options.onToolComplete?.(toolName, toolCallId, result);
+      return result;
+    } catch (err) {
+      if (err instanceof ToolError) {
+        return { content: `[${err.code}] ${err.message}`, isError: true };
+      }
+      return { content: `Tool error: ${(err as Error).message}`, isError: true };
+    }
+  }
+}

package/src/core/session/SessionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SessionManager.d.ts","sourceRoot":"","sources":["SessionManager.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,SAAS,EAET,OAAO,EACP,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,YAAY,EAEb,MAAM,qBAAqB,CAAC;AAI7B,MAAM,MAAM,eAAe,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAE5E,8DAA8D;AAC9D,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,aAAa,CAAC;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,SAAS,CAA2C;IAC5D,OAAO,CAAC,UAAU,CAAS;gBAEf,UAAU,CAAC,EAAE,MAAM;IAI/B,2BAA2B;IAC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG;QAAE,gBAAgB,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO;IA0C9E,0BAA0B;IAC1B,GAAG,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,GAAG,SAAS;IAIvC,uBAAuB;IACvB,MAAM,IAAI,OAAO,EAAE;IAInB,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAWrD,wCAAwC;IACxC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,OAAO;IAmBtF,gCAAgC;IAChC,WAAW,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,EAAE;IAMrC,2BAA2B;IAC3B,eAAe,CAAC,EAAE,EAAE,SAAS,GAAG,YAAY;IAM5C,6BAA6B;IAC7B,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,MAAM;IAepC,yBAAyB;IACzB,gBAAgB,CAAC,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAShF,yBAAyB;IACzB,SAAS,CAAC,EAAE,EAAE,SAAS,GAAG,aAAa;IAMvC,wBAAwB;IACxB,QAAQ,CAAC,EAAE,EAAE,SAAS,GAAG,YAAY;IAMrC,6CAA6C;IAC7C,eAAe,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAMjE,+BAA+B;IAC/B,aAAa,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAKlD,qDAAqD;IACrD,oBAAoB,CAAC,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,kBAAkB,GAAE,OAAc,GAAG,OAAO,EAAE;IAuBvG,2CAA2C;IAC3C,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAOhE,iCAAiC;IACjC,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAY3F,oBAAoB;IACpB,OAAO,CAAC,IAAI;IAkCZ,uBAAuB;IACvB,MAAM,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO;IAI9B,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,EAAE,SAAS;;;;;;;;;;IAmBtB,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,eAAe;IAIvB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,EAAE,SAAS,GAAG,IAAI;IAkC5B,mEAAmE;IACnE,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI;IAoC3C,oEAAoE;IACpE,iBAAiB,IAAI,OAAO,GAAG,IAAI;IAmBnC,uDAAuD;IACvD,qBAAqB,CAAC,KAAK,SAAK,GAAG,eAAe,EAAE;IA2BpD,gDAAgD;IAChD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAYxC;AAED,sCAAsC;AACtC,UAAU,OAAO;IACf,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,YAAY,CAAC;IACpB,YAAY,EAAE,YAAY,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;CAC3B"}

package/src/core/session/SessionManager.test.ts

@@ -0,0 +1,183 @@
+// ============================================================================
+// SessionManager Tests
+// ============================================================================
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SessionManager } from './SessionManager.js';
+import type { Message } from '../types/session.js';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+describe('SessionManager', () => {
+  let sessionManager: SessionManager;
+  const testSessionDir = path.join(os.tmpdir(), 'nova-test-sessions-' + Date.now());
+
+  beforeEach(() => {
+    if (!fs.existsSync(testSessionDir)) {
+      fs.mkdirSync(testSessionDir, { recursive: true });
+    }
+    sessionManager = new SessionManager(testSessionDir);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testSessionDir)) {
+      fs.rmSync(testSessionDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('create()', () => {
+    it('should create a new session with unique ID', () => {
+      const session1 = sessionManager.create({ workingDirectory: process.cwd() });
+      const session2 = sessionManager.create({ workingDirectory: process.cwd() });
+
+      expect(session1.id).toBeDefined();
+      expect(session2.id).toBeDefined();
+      expect(session1.id).not.toBe(session2.id);
+    });
+
+    it('should create session with messages array', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+      const messages = session.conversation.messages;
+
+      expect(messages).toBeDefined();
+      expect(Array.isArray(messages)).toBe(true);
+    });
+  });
+
+  describe('get()', () => {
+    it('should return undefined for non-existent session', () => {
+      const session = sessionManager.get('non-existent-id' as any);
+      expect(session).toBeUndefined();
+    });
+
+    it('should return session for valid ID', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+      const retrieved = sessionManager.get(session.id);
+
+      expect(retrieved).toBeDefined();
+      expect(retrieved?.id).toBe(session.id);
+    });
+  });
+
+  describe('addMessage()', () => {
+    it('should add message to session', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+
+      sessionManager.addMessage(session.id, 'user', 'Hello, world!');
+      const messages = session.conversation.messages;
+
+      expect(messages).toHaveLength(1);
+      expect(messages[0].content).toBe('Hello, world!');
+    });
+
+    it('should maintain message order', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+
+      sessionManager.addMessage(session.id, 'user', 'First');
+      sessionManager.addMessage(session.id, 'assistant', 'Second');
+      sessionManager.addMessage(session.id, 'user', 'Third');
+
+      const messages = session.conversation.messages;
+      expect(messages).toHaveLength(3);
+      expect(messages[0].content).toBe('First');
+      expect(messages[1].content).toBe('Second');
+      expect(messages[2].content).toBe('Third');
+    });
+
+    it('should throw for non-existent session', () => {
+      expect(() => {
+        sessionManager.addMessage('non-existent' as any, 'user', 'test');
+      }).toThrow();
+    });
+  });
+
+  describe('getMessages()', () => {
+    it('should return empty array for new session', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+      const messages = session.conversation.messages;
+
+      expect(messages).toHaveLength(0);
+    });
+
+    it('should return messages array', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+      sessionManager.addMessage(session.id, 'user', 'test');
+
+      const messages = session.conversation.messages;
+      expect(messages).toHaveLength(1);
+      expect(messages[0].content).toBe('test');
+    });
+  });
+
+  describe('persist() and loadLatestSession()', () => {
+    it('should persist and load session', async () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+      sessionManager.addMessage(session.id, 'user', 'Test message');
+
+      await sessionManager.persist(session.id);
+
+      // Create new SessionManager instance
+      const sessionManager2 = new SessionManager(testSessionDir);
+      const loadedSession = await sessionManager2.loadLatestSession();
+
+      expect(loadedSession).toBeDefined();
+      const messages = loadedSession!.conversation.messages;
+      expect(messages).toHaveLength(1);
+      expect(messages[0].content).toBe('Test message');
+    });
+
+    it('should return null when no persisted sessions', async () => {
+      const loadedSession = await sessionManager.loadLatestSession();
+      expect(loadedSession).toBeNull();
+    });
+
+    it('should load most recent session', async () => {
+      const session1 = sessionManager.create({ workingDirectory: process.cwd() });
+      sessionManager.addMessage(session1.id, 'user', 'Session 1');
+      await sessionManager.persist(session1.id);
+
+      // Wait a bit to ensure different mtime
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      const session2 = sessionManager.create({ workingDirectory: process.cwd() });
+      sessionManager.addMessage(session2.id, 'user', 'Session 2');
+      await sessionManager.persist(session2.id);
+
+      const loadedSession = await sessionManager.loadLatestSession();
+      const messages = loadedSession!.conversation.messages;
+
+      expect(messages[0].content).toBe('Session 2');
+    });
+  });
+
+  describe('listPersistedSessions()', () => {
+    it('should return empty array when no sessions', async () => {
+      const sessions = await sessionManager.listPersistedSessions();
+      expect(sessions).toHaveLength(0);
+    });
+
+    it('should list persisted sessions', async () => {
+      const session1 = sessionManager.create({ workingDirectory: process.cwd() });
+      sessionManager.addMessage(session1.id, 'user', 'Test 1');
+      await sessionManager.persist(session1.id);
+
+      const session2 = sessionManager.create({ workingDirectory: process.cwd() });
+      sessionManager.addMessage(session2.id, 'user', 'Test 2');
+      await sessionManager.persist(session2.id);
+
+      const sessions = await sessionManager.listPersistedSessions();
+      expect(sessions.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('delete()', () => {
+    it('should delete session from memory', () => {
+      const session = sessionManager.create({ workingDirectory: process.cwd() });
+      expect(sessionManager.get(session.id)).toBeDefined();
+
+      sessionManager.delete(session.id);
+      expect(sessionManager.get(session.id)).toBeUndefined();
+    });
+  });
+});