fix: add retry logic with exponential backoff to hook fetch calls

src/hooks/context-hook.ts

@@ -7,7 +7,7 @@
  */
 
 import { stdin } from "process";
-import { ensureWorkerRunning, getWorkerPort } from "../shared/worker-utils.js";
+import { ensureWorkerRunning, getWorkerPort, fetchWithRetry } from "../shared/worker-utils.js";
 import { HOOK_TIMEOUTS } from "../shared/hook-constants.js";
 import { getProjectName } from "../utils/project-name.js";
 import { logger } from "../utils/logger.js";
@@ -29,9 +29,8 @@ async function contextHook(input?: SessionStartInput): Promise<string> {
 
   const url = `http://127.0.0.1:${port}/api/context/inject?project=${encodeURIComponent(project)}`;
 
-  // Note: Removed AbortSignal.timeout due to Windows Bun cleanup issue (libuv assertion)
-  // Worker service has its own timeouts, so client-side timeout is redundant
-  const response = await fetch(url);
+  // Uses fetchWithRetry to handle transient network errors like UND_ERR_SOCKET
+  const response = await fetchWithRetry(url, {});
 
   if (!response.ok) {
     throw new Error(`Context generation failed: ${response.status}`);

src/hooks/new-hook.ts

@@ -1,6 +1,6 @@
 import { stdin } from 'process';
 import { STANDARD_HOOK_RESPONSE } from './hook-response.js';
-import { ensureWorkerRunning, getWorkerPort } from '../shared/worker-utils.js';
+import { ensureWorkerRunning, getWorkerPort, fetchWithRetry } from '../shared/worker-utils.js';
 import { getProjectName } from '../utils/project-name.js';
 import { logger } from '../utils/logger.js';
 
@@ -32,16 +32,19 @@ async function newHook(input?: UserPromptSubmitInput): Promise<void> {
   logger.info('HOOK', 'new-hook: Calling /api/sessions/init', { contentSessionId: session_id, project, prompt_length: prompt?.length });
 
   // Initialize session via HTTP - handles DB operations and privacy checks
-  const initResponse = await fetch(`http://127.0.0.1:${port}/api/sessions/init`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      contentSessionId: session_id,
-      project,
-      prompt
-    })
-    // Note: Removed signal to avoid Windows Bun cleanup issue (libuv assertion)
-  });
+  // Uses fetchWithRetry to handle transient network errors like ECONNRESET
+  const initResponse = await fetchWithRetry(
+    `http://127.0.0.1:${port}/api/sessions/init`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contentSessionId: session_id,
+        project,
+        prompt
+      })
+    }
+  );
 
   if (!initResponse.ok) {
     throw new Error(`Session initialization failed: ${initResponse.status}`);
@@ -69,12 +72,15 @@ async function newHook(input?: UserPromptSubmitInput): Promise<void> {
   logger.info('HOOK', 'new-hook: Calling /sessions/{sessionDbId}/init', { sessionDbId, promptNumber, userPrompt_length: cleanedPrompt?.length });
 
   // Initialize SDK agent session via HTTP (starts the agent!)
-  const response = await fetch(`http://127.0.0.1:${port}/sessions/${sessionDbId}/init`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ userPrompt: cleanedPrompt, promptNumber })
-    // Note: Removed signal to avoid Windows Bun cleanup issue (libuv assertion)
-  });
+  // Uses fetchWithRetry to handle transient network errors like ECONNRESET
+  const response = await fetchWithRetry(
+    `http://127.0.0.1:${port}/sessions/${sessionDbId}/init`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ userPrompt: cleanedPrompt, promptNumber })
+    }
+  );
 
   if (!response.ok) {
     throw new Error(`SDK agent start failed: ${response.status}`);

src/hooks/save-hook.ts

@@ -9,7 +9,7 @@
 import { stdin } from 'process';
 import { STANDARD_HOOK_RESPONSE } from './hook-response.js';
 import { logger } from '../utils/logger.js';
-import { ensureWorkerRunning, getWorkerPort } from '../shared/worker-utils.js';
+import { ensureWorkerRunning, getWorkerPort, fetchWithRetry } from '../shared/worker-utils.js';
 import { HOOK_TIMEOUTS } from '../shared/hook-constants.js';
 
 export interface PostToolUseInput {
@@ -47,18 +47,21 @@ async function saveHook(input?: PostToolUseInput): Promise<void> {
   }
 
   // Send to worker - worker handles privacy check and database operations
-  const response = await fetch(`http://127.0.0.1:${port}/api/sessions/observations`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      contentSessionId: session_id,
-      tool_name,
-      tool_input,
-      tool_response,
-      cwd
-    })
-    // Note: Removed signal to avoid Windows Bun cleanup issue (libuv assertion)
-  });
+  // Uses fetchWithRetry to handle transient network errors like ECONNRESET
+  const response = await fetchWithRetry(
+    `http://127.0.0.1:${port}/api/sessions/observations`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contentSessionId: session_id,
+        tool_name,
+        tool_input,
+        tool_response,
+        cwd
+      })
+    }
+  );
 
   if (!response.ok) {
     throw new Error(`Observation storage failed: ${response.status}`);

src/hooks/summary-hook.ts

@@ -12,7 +12,7 @@
 import { stdin } from 'process';
 import { STANDARD_HOOK_RESPONSE } from './hook-response.js';
 import { logger } from '../utils/logger.js';
-import { ensureWorkerRunning, getWorkerPort } from '../shared/worker-utils.js';
+import { ensureWorkerRunning, getWorkerPort, fetchWithRetry } from '../shared/worker-utils.js';
 import { HOOK_TIMEOUTS } from '../shared/hook-constants.js';
 import { extractLastMessage } from '../shared/transcript-parser.js';
 
@@ -53,15 +53,18 @@ async function summaryHook(input?: StopInput): Promise<void> {
   });
 
   // Send to worker - worker handles privacy check and database operations
-  const response = await fetch(`http://127.0.0.1:${port}/api/sessions/summarize`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      contentSessionId: session_id,
-      last_assistant_message: lastAssistantMessage
-    })
-    // Note: Removed signal to avoid Windows Bun cleanup issue (libuv assertion)
-  });
+  // Uses fetchWithRetry to handle transient network errors like ECONNRESET
+  const response = await fetchWithRetry(
+    `http://127.0.0.1:${port}/api/sessions/summarize`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        contentSessionId: session_id,
+        last_assistant_message: lastAssistantMessage
+      })
+    }
+  );
 
   if (!response.ok) {
     console.log(STANDARD_HOOK_RESPONSE);

src/shared/worker-utils.ts

@@ -56,6 +56,68 @@ export function clearPortCache(): void {
   cachedHost = null;
 }
 
+/**
+ * Fetch with retry logic for transient network errors.
+ * Handles ECONNRESET, ECONNREFUSED, ETIMEDOUT, and socket errors.
+ *
+ * With default maxRetries=3, performs up to 4 total attempts:
+ * - Initial attempt
+ * - Up to 3 retries with exponential backoff (100ms, 200ms, 400ms)
+ */
+export async function fetchWithRetry(
+  url: string,
+  options: RequestInit,
+  config: {
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+  } = {}
+): Promise<Response> {
+  const {
+    maxRetries = 3,
+    initialDelayMs = 100,
+    maxDelayMs = 1000
+  } = config;
+
+  const retryableErrors = ['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'UND_ERR_SOCKET'];
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fetch(url, options);
+    } catch (error) {
+      const errorCode = (error as any)?.cause?.code || '';
+      const errorMessage = (error as Error).message || '';
+
+      const isRetryable = retryableErrors.some(code =>
+        errorCode.includes(code) || errorMessage.includes(code)
+      );
+
+      // Throw immediately for non-retryable errors or if we've exhausted retries
+      if (!isRetryable || attempt === maxRetries) {
+        throw error;
+      }
+
+      // Exponential backoff with jitter
+      const delay = Math.min(
+        initialDelayMs * Math.pow(2, attempt) + Math.random() * 50,
+        maxDelayMs
+      );
+
+      logger.debug('SYSTEM', 'Fetch failed, retrying', {
+        attempt: attempt + 1,
+        maxRetries,
+        delay: Math.round(delay),
+        error: errorMessage
+      });
+
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+
+  // This line is unreachable but satisfies TypeScript's control flow analysis
+  throw new Error('Unexpected: exhausted retries without throwing');
+}
+
 /**
  * Check if worker is responsive and fully initialized by trying the readiness endpoint
  * Changed from /health to /api/readiness to ensure MCP initialization is complete