circuschief 0.1.4 → 0.2.0

package/packages/server/src/services/schedulerService.js

@@ -75,6 +75,70 @@ class SchedulerService {
     }
   }
 
+  /**
+   * Resolve skill/command invocations in the prompt, returning the effective prompt and system prompt.
+   * @param {object} session - Session object
+   * @param {string} workingDirectory - Working directory
+   * @param {string} projectSystemPrompt - Project-level system prompt
+   * @returns {Promise<{prompt: string, effectivePrompt: string, effectiveSystemPrompt: string, sessionAttachments: Array}>}
+   */
+  async resolveScheduledPrompt(session, workingDirectory, projectSystemPrompt) {
+    const prompt = session.pendingPrompt.trim();
+    const sessionAttachments = attachments.getBySessionId(session.id);
+
+    const resolved = await slashCommandService.resolvePromptSkillOrCommand(
+      workingDirectory, prompt, projectSystemPrompt
+    );
+
+    return {
+      prompt,
+      effectivePrompt: resolved ? resolved.userMessage : prompt,
+      effectiveSystemPrompt: resolved ? resolved.systemPrompt : projectSystemPrompt,
+      sessionAttachments,
+    };
+  }
+
+  /**
+   * Handle the fresh-session branch of startScheduledSession.
+   * Creates the initial user message, updates status, and starts the session.
+   * @param {object} session - Session object
+   * @param {string} prompt - Raw prompt text
+   * @param {string} effectivePrompt - Prompt after slash command resolution
+   * @param {string} effectiveSystemPrompt - System prompt after resolution
+   * @param {string} workingDirectory - Working directory
+   * @param {Array} sessionAttachments - Attachments for context
+   */
+  async startFreshScheduledSession({ session, prompt, effectivePrompt, effectiveSystemPrompt, workingDirectory, sessionAttachments }) {
+    const activeConv = conversations.getActiveBySessionId(session.id);
+    if (!activeConv) {
+      throw new Error(`No active conversation found for session ${session.id}`);
+    }
+
+    // Create the initial user message
+    const userMessage = messages.create(session.id, 'user', prompt, { toolUse: null, conversationId: activeConv.id });
+
+    // Broadcast the new message so UI updates
+    broadcastToSession(session.id, WS_MESSAGE_TYPES.MESSAGE_CREATED, {
+      sessionId: session.id,
+      message: userMessage,
+    });
+
+    // Update status from 'scheduled' to 'starting' and clear pendingPrompt
+    sessions.update(session.id, {
+      status: 'starting',
+      scheduledAt: null,
+      pendingPrompt: null,
+    });
+    broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId: session.id, status: 'starting' });
+
+    await this.sessionManager.runSession(
+      session.id,
+      effectivePrompt,
+      workingDirectory,
+      { systemPrompt: effectiveSystemPrompt, fileAttachments: sessionAttachments, model: session.pendingModel }
+    );
+  }
+
   /**
    * Start a scheduled session
    * @param {object} session - Session to start
@@ -100,27 +164,17 @@ class SchedulerService {
       throw new Error(`No pendingPrompt found for session ${session.id}`);
     }
 
-    const prompt = session.pendingPrompt.trim();
+    // Resolve skill/command invocations
+    const { prompt, effectivePrompt, effectiveSystemPrompt, sessionAttachments } =
+      await this.resolveScheduledPrompt(session, workingDirectory, project.systemPrompt);
 
     // Get the session messages to determine if this is initial or continuation
     const sessionMessages = messages.getBySessionId(session.id);
     const hasAssistantResponses = sessionMessages.some((msg) => msg.role === 'assistant');
 
-    // Get attachments for context
-    const sessionAttachments = attachments.getBySessionId(session.id);
-
-    // Resolve skill/command invocations so skill body goes into system prompt
-    const resolved = await slashCommandService.resolvePromptSkillOrCommand(
-      workingDirectory, prompt, project.systemPrompt
-    );
-    const effectivePrompt = resolved ? resolved.userMessage : prompt;
-    const effectiveSystemPrompt = resolved ? resolved.systemPrompt : project.systemPrompt;
-
     // Determine if this is an initial run or a continuation
     if (hasAssistantResponses) {
       // Session has conversation history - this is a scheduled continuation
-
-      // Update status from 'scheduled' to 'starting' and clear pendingPrompt
       sessions.update(session.id, {
         status: 'starting',
         scheduledAt: null,
@@ -136,37 +190,7 @@ class SchedulerService {
       );
     } else {
       // Fresh session - initial run
-      // First, create the user message so it appears in the conversation
-
-      // Get the active conversation
-      const activeConv = conversations.getActiveBySessionId(session.id);
-      if (!activeConv) {
-        throw new Error(`No active conversation found for session ${session.id}`);
-      }
-
-      // Create the initial user message
-      const userMessage = messages.create(session.id, 'user', prompt, { toolUse: null, conversationId: activeConv.id });
-
-      // Broadcast the new message so UI updates
-      broadcastToSession(session.id, WS_MESSAGE_TYPES.MESSAGE_CREATED, {
-        sessionId: session.id,
-        message: userMessage,
-      });
-
-      // Update status from 'scheduled' to 'starting' and clear pendingPrompt
-      sessions.update(session.id, {
-        status: 'starting',
-        scheduledAt: null,
-        pendingPrompt: null,
-      });
-      broadcastToSession(session.id, WS_MESSAGE_TYPES.SESSION_STATUS, { sessionId: session.id, status: 'starting' });
-
-      await this.sessionManager.runSession(
-        session.id,
-        effectivePrompt,
-        workingDirectory,
-        { systemPrompt: effectiveSystemPrompt, fileAttachments: sessionAttachments, model: session.pendingModel }
-      );
+      await this.startFreshScheduledSession({ session, prompt, effectivePrompt, effectiveSystemPrompt, workingDirectory, sessionAttachments });
     }
   }
 

package/packages/server/src/services/sessionExecution.js

@@ -158,66 +158,14 @@ async function buildPromptForContinue(modelChanged, conversationId, promptWithAt
 }
 
 /**
- * Continue a session with a follow-up message (core implementation)
- * @param {string} sessionId
- * @param {string} content
- * @param {string} workingDirectory
- * @param {Object} config - Session options and callbacks
- * @param {Object} [config.options] - Session options (systemPrompt, fileAttachments, model)
- * @param {Object} config.callbacks - Callback functions from sessionManager
+ * Resolve model/provider and build session environment for a continue operation.
+ * Also detects model changes and updates the session record.
+ * @param {Object} session - Current session object
+ * @param {string} sessionId - Session ID
+ * @param {string|null} model - Requested model (null to keep current)
+ * @returns {{ effectiveModel: string|null, sessionEnv: Object, modelChanged: boolean, session: Object }}
  */
-export async function continueSessionCore(sessionId, content, workingDirectory, config = {}) {
-  const { options = {}, callbacks } = config;
-  const { systemPrompt = null, fileAttachments = [], model = null } = options;
-  // Check if session is already running
-  if (activeSessions.has(sessionId)) {
-    throw new Error('Session is already processing');
-  }
-
-  // Get the session to retrieve the Claude session ID and settings
-  let session = sessions.getById(sessionId);
-  if (!session) {
-    throw new Error('Session not found');
-  }
-
-  const controller = new AbortController();
-  activeSessions.set(sessionId, { controller });
-
-  // Ensure there's an active conversation for this session
-  const activeConversation = conversations.ensureActiveConversation(sessionId);
-  activeConversationIds.set(sessionId, activeConversation.id);
-  console.log(`[SESSION] continueSession: ensured active conversation ${activeConversation.id} for session ${sessionId}`);
-
-  // Each conversation has its own Claude session context
-  // If null, Claude will start a fresh session (no resume)
-
-  // Store the user message with conversation ID
-  const { broadcastToSession } = await import('../websocket.js');
-  const { WS_MESSAGE_TYPES } = await import('@circuschief/shared');
-  const message = messages.create(sessionId, 'user', content, { toolUse: null, conversationId: activeConversation.id });
-  console.log(`[SESSION] continueSession: created user message ${message.id} in conversation ${activeConversation.id}`);
-  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_MESSAGE, {
-    message,
-    conversationId: activeConversation.id, // Include conversation context
-  });
-  console.log(`[SESSION] continueSession: broadcast user message ${message.id} to conversation ${activeConversation.id}`);
-
-  // Associate any pending attachments with the message
-  if (fileAttachments.length > 0) {
-    attachments.updateMessageIdForSession(sessionId, message.id);
-  }
-
-  // Build prompt with attachment context
-  const promptWithAttachments = buildPromptWithAttachments(content, fileAttachments);
-
-  // Update status to running
-  sessions.update(sessionId, { status: 'running' });
-  broadcastSessionStatus(sessionId, 'running');
-
-  // Create agent via gateway (or mock agent in mock mode)
-  const agentType = session.agentType || 'claude-code';
-  const agent = createAgentForSession(agentType);
-
+function buildContinueModelAndEnv(session, sessionId, model) {
   // Resolve the effective model: fall back to session.model so that resuming
   // without an explicit model still resolves the correct provider (e.g.
   // third-party base URL and auth tokens).
@@ -230,15 +178,29 @@ export async function continueSessionCore(sessionId, content, workingDirectory,
   // Check if model changed from the session's last requested model
   // When model changes, we can't resume the previous session - thinking blocks and
   // session context may be incompatible between different models/providers
-  const modelChanged = model && session.model && model !== session.model;
+  const modelChanged = Boolean(model && session.model && model !== session.model);
 
   // Update session.model to track the user-requested model (short format)
   // This must happen AFTER modelChanged detection so we compare old vs new
+  let updatedSession = session;
   if (model) {
     sessions.update(sessionId, { model });
-    session = sessions.getById(sessionId); // refresh
+    updatedSession = sessions.getById(sessionId); // refresh
   }
 
+  return { effectiveModel, sessionEnv, modelChanged, session: updatedSession };
+}
+
+/**
+ * Build query params and agent call meta for a continue session operation.
+ * @param {Object} opts
+ * @returns {{ queryParams: Object, agentCallMeta: Object }}
+ */
+async function buildContinueParams({
+  sessionId, session, model, systemPrompt, effectiveModel, sessionEnv,
+  modelChanged, activeConversation, promptWithAttachments,
+  workingDirectory, controller, agentType,
+}) {
   // Only resume if we have a session ID AND model hasn't changed
   const canResume = activeConversation.claudeSessionId && !modelChanged;
 
@@ -269,6 +231,85 @@ export async function continueSessionCore(sessionId, content, workingDirectory,
     promptLength: promptWithContext.length,
   };
 
+  return { queryParams, agentCallMeta };
+}
+
+/**
+ * Set up the active conversation, create the user message, broadcast it,
+ * associate attachments, and build the prompt with attachment context.
+ * @returns {{ activeConversation: Object, promptWithAttachments: string }}
+ */
+async function setupConversationAndMessage(sessionId, content, fileAttachments) {
+  const activeConversation = conversations.ensureActiveConversation(sessionId);
+  activeConversationIds.set(sessionId, activeConversation.id);
+
+  const { broadcastToSession } = await import('../websocket.js');
+  const { WS_MESSAGE_TYPES } = await import('@circuschief/shared');
+  const message = messages.create(sessionId, 'user', content, { toolUse: null, conversationId: activeConversation.id });
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_MESSAGE, {
+    message,
+    conversationId: activeConversation.id,
+  });
+
+  if (fileAttachments.length > 0) {
+    attachments.updateMessageIdForSession(sessionId, message.id);
+  }
+
+  const promptWithAttachments = buildPromptWithAttachments(content, fileAttachments);
+  return { activeConversation, promptWithAttachments };
+}
+
+/**
+ * Continue a session with a follow-up message (core implementation)
+ * @param {string} sessionId
+ * @param {string} content
+ * @param {string} workingDirectory
+ * @param {Object} config - Session options and callbacks
+ * @param {Object} [config.options] - Session options (systemPrompt, fileAttachments, model)
+ * @param {Object} config.callbacks - Callback functions from sessionManager
+ */
+export async function continueSessionCore(sessionId, content, workingDirectory, config = {}) {
+  const { options = {}, callbacks } = config;
+  const { systemPrompt = null, fileAttachments = [], model = null } = options;
+  // Check if session is already running
+  if (activeSessions.has(sessionId)) {
+    throw new Error('Session is already processing');
+  }
+
+  // Get the session to retrieve the Claude session ID and settings
+  let session = sessions.getById(sessionId);
+  if (!session) {
+    throw new Error('Session not found');
+  }
+
+  const controller = new AbortController();
+  activeSessions.set(sessionId, { controller });
+
+  // Ensure there's an active conversation and create the user message
+  const { activeConversation, promptWithAttachments } = await setupConversationAndMessage(
+    sessionId, content, fileAttachments
+  );
+
+  // Update status to running
+  sessions.update(sessionId, { status: 'running' });
+  broadcastSessionStatus(sessionId, 'running');
+
+  // Create agent via gateway (or mock agent in mock mode)
+  const agentType = session.agentType || 'claude-code';
+  const agent = createAgentForSession(agentType);
+
+  // Resolve model/provider and detect model changes
+  const modelEnv = buildContinueModelAndEnv(session, sessionId, model);
+  session = modelEnv.session;
+
+  // Build query params and agent call meta
+  const { queryParams, agentCallMeta } = await buildContinueParams({
+    sessionId, session, model, systemPrompt,
+    effectiveModel: modelEnv.effectiveModel, sessionEnv: modelEnv.sessionEnv,
+    modelChanged: modelEnv.modelChanged, activeConversation, promptWithAttachments,
+    workingDirectory, controller, agentType,
+  });
+
   await _executeSession({
     sessionId,
     agent,

package/packages/server/src/services/sessionManager.js

@@ -217,50 +217,39 @@ function validateAndFetchContinueContext(sessionId, conversationId) {
   return { session, conversation, lastUserMessage };
 }
 
-export async function continueSessionWithExistingMessage(sessionId, conversationId, workingDirectory, options = {}) {
-  const { systemPrompt = null, model = null } = options;
-  const context = validateAndFetchContinueContext(sessionId, conversationId);
-  let session = context.session;
-  const { conversation, lastUserMessage } = context;
-
-  const controller = new AbortController();
-  activeSessions.set(sessionId, { controller });
-
-  // Make sure this conversation is active
-  if (!conversation.isActive) {
-    conversations.update(conversationId, { isActive: true });
-  }
-  activeConversationIds.set(sessionId, conversationId);
-
-  // Update status to running
-  sessions.update(sessionId, { status: 'running' });
-  broadcastSessionStatus(sessionId, 'running');
-
-  // Use the existing user message content as the prompt
-  // Note: We do NOT create a new user message here - it already exists
-
-  // Create agent via gateway (or mock agent in mock mode)
-  const agentType = session.agentType || 'claude-code';
-  const agent = createAgentForSession(agentType);
-
-  // Resolve the effective model: fall back to session.model so that resuming
-  // without an explicit model still resolves the correct provider (e.g.
-  // third-party base URL and auth tokens).
+/**
+ * Resolve the effective model, provider, and session env from a model override.
+ * Detects model changes and updates the session record when needed.
+ * @param {Object} session - Current session object
+ * @param {string} sessionId - Session ID
+ * @param {string|null} model - Requested model (null to keep current)
+ * @returns {{ effectiveModel: string|null, sessionEnv: Object, modelChanged: boolean, session: Object }}
+ */
+function buildModelAndProvider(session, sessionId, model) {
   const effectiveModel = model || session.model;
-
-  // Derive provider from the effective model ID (returns null for Anthropic/SDK defaults)
   const provider = resolveProviderFromModel(effectiveModel);
   const sessionEnv = buildSessionEnv(provider, session.thinkingEnabled, session.effortLevel);
+  const modelChanged = Boolean(model && session.model && model !== session.model);
 
-  // Check if model changed (can't resume with different model/provider)
-  const modelChanged = model && session.model && model !== session.model;
-
-  // Update session.model after detecting change
+  let updatedSession = session;
   if (model) {
     sessions.update(sessionId, { model });
-    session = sessions.getById(sessionId);
+    updatedSession = sessions.getById(sessionId);
   }
 
+  return { effectiveModel, sessionEnv, modelChanged, session: updatedSession };
+}
+
+/**
+ * Build query params for continueSessionWithExistingMessage.
+ * Handles context building (model switch / branch) and resume detection.
+ * @returns {{ queryParams: Object, agentCallMeta: Object }}
+ */
+function buildExistingMessageQueryParams({
+  sessionId, conversationId, session, model, systemPrompt,
+  effectiveModel, sessionEnv, modelChanged, conversation,
+  lastUserMessage, workingDirectory, controller, agentType,
+}) {
   // Determine context needs and build context
   const { needsContext, contextType } = determineContextNeed(conversation, modelChanged);
   if (needsContext) {
@@ -284,7 +273,6 @@ export async function continueSessionWithExistingMessage(sessionId, conversation
     resumeSessionId: canResume ? conversation.claudeSessionId : null,
   });
 
-  // Logging metadata for agent call tracking
   const agentCallMeta = {
     sessionId,
     conversationId,
@@ -296,6 +284,44 @@ export async function continueSessionWithExistingMessage(sessionId, conversation
     promptLength: promptWithContext.length,
   };
 
+  return { queryParams, agentCallMeta };
+}
+
+export async function continueSessionWithExistingMessage(sessionId, conversationId, workingDirectory, options = {}) {
+  const { systemPrompt = null, model = null } = options;
+  const context = validateAndFetchContinueContext(sessionId, conversationId);
+  let session = context.session;
+  const { conversation, lastUserMessage } = context;
+
+  const controller = new AbortController();
+  activeSessions.set(sessionId, { controller });
+
+  // Make sure this conversation is active
+  if (!conversation.isActive) {
+    conversations.update(conversationId, { isActive: true });
+  }
+  activeConversationIds.set(sessionId, conversationId);
+
+  // Update status to running
+  sessions.update(sessionId, { status: 'running' });
+  broadcastSessionStatus(sessionId, 'running');
+
+  // Create agent via gateway (or mock agent in mock mode)
+  const agentType = session.agentType || 'claude-code';
+  const agent = createAgentForSession(agentType);
+
+  // Resolve model/provider and detect model changes
+  const modelEnv = buildModelAndProvider(session, sessionId, model);
+  session = modelEnv.session;
+
+  // Build query params and agent call meta
+  const { queryParams, agentCallMeta } = buildExistingMessageQueryParams({
+    sessionId, conversationId, session, model, systemPrompt,
+    effectiveModel: modelEnv.effectiveModel, sessionEnv: modelEnv.sessionEnv,
+    modelChanged: modelEnv.modelChanged, conversation,
+    lastUserMessage, workingDirectory, controller, agentType,
+  });
+
   await _executeSession({
     sessionId,
     agent,

package/packages/server/src/services/summaryService.js

@@ -36,6 +36,9 @@ import { isSummaryStale } from './summaryStaleCheck.js';
 // Create the concurrency guard instance for summary generation
 const guard = createConcurrencyGuard();
 
+// Track scheduled CI-check timers so they can be cleared on shutdown
+const activeTimers = new Set();
+
 /**
  * Generate summary for a session using Claude Code SDK (with concurrency guard)
  * Only one generation can be in-flight per session at a time. If a generation is already
@@ -252,30 +255,45 @@ function createMinimalSummary(sessionId, session, allMessages) {
 }
 
 /**
- * Internal implementation of generateSummary (called by concurrency guard wrapper)
+ * Retry summary generation if parsing failed and retries remain.
+ * Returns { shouldRetry: true, result } if a retry was performed,
+ * or { shouldRetry: false } if no retry is needed.
+ * @param {Object} summaryData - Parsed summary data (may have _parseFailed flag)
+ * @param {number} retryCount - Current retry count
  * @param {string} sessionId
- * @param {number} retryCount
  * @param {boolean} force
  * @param {boolean} userInitiated
- * @returns {Promise<Object|null>}
+ * @returns {Promise<{ shouldRetry: boolean, result?: Object|null }>}
  */
+async function retryIfParseFailed(summaryData, retryCount, { sessionId, force, userInitiated }) {
+  if (!summaryData._parseFailed || retryCount >= MAX_RETRIES) {
+    return { shouldRetry: false };
+  }
+
+  console.log(
+    `[SummaryService] Parse failed for session ${sessionId}, retrying (attempt ${retryCount + 2}/${MAX_RETRIES + 1})`
+  );
+  const backoffMs = 1000 * (retryCount + 1);
+  await new Promise((resolve) => setTimeout(resolve, backoffMs));
+  const result = await _doGenerateSummary(sessionId, retryCount + 1, force, userInitiated);
+  return { shouldRetry: true, result };
+}
+
 async function _doGenerateSummary(sessionId, retryCount = 0, force = false, userInitiated = false) {
-  try {
-    // Early-exit checks
-    const check = shouldGenerateSummary(sessionId, force, userInitiated);
-    if (check.skip) return check.result;
+  // Early-exit checks
+  const check = shouldGenerateSummary(sessionId, force, userInitiated);
+  if (check.skip) return check.result;
 
-    const { session, globalSettings, existingSummary, allMessages } = check;
-    const recentMessages = allMessages.slice(-MAX_MESSAGES);
+  const { session, globalSettings, existingSummary, allMessages } = check;
+  const recentMessages = allMessages.slice(-MAX_MESSAGES);
 
-    // Broadcast that we're generating (do this early so UI always gets the event)
-    broadcastGeneratingStatus(sessionId, true);
+  // Broadcast that we're generating (do this early so UI always gets the event)
+  broadcastGeneratingStatus(sessionId, true);
 
+  try {
     // Handle sessions with too few messages
     if (allMessages.length < MIN_MESSAGES_FOR_SUMMARY) {
-      const summary = createMinimalSummary(sessionId, session, allMessages);
-      broadcastGeneratingStatus(sessionId, false);
-      return summary;
+      return createMinimalSummary(sessionId, session, allMessages);
     }
 
     // Build conversation context and prompt
@@ -287,25 +305,14 @@ async function _doGenerateSummary(sessionId, retryCount = 0, force = false, user
       systemPrompt: SUMMARY_SYSTEM_PROMPT,
     });
 
-    // Parse response
+    // Parse response and retry if needed
     const summaryData = parseSummaryResponse(responseText);
-
-    // Retry if parsing failed and we haven't exhausted retries
-    if (summaryData._parseFailed && retryCount < MAX_RETRIES) {
-      console.log(
-        `[SummaryService] Parse failed for session ${sessionId}, retrying (attempt ${retryCount + 2}/${MAX_RETRIES + 1})`
-      );
-      const backoffMs = 1000 * (retryCount + 1);
-      await new Promise((resolve) => setTimeout(resolve, backoffMs));
-      return _doGenerateSummary(sessionId, retryCount + 1, force, userInitiated);
-    }
+    const retryResult = await retryIfParseFailed(summaryData, retryCount, { sessionId, force, userInitiated });
+    if (retryResult.shouldRetry) return retryResult.result;
 
     // Persist summary and broadcast updates
     const summary = await saveSummaryResult(sessionId, summaryData, session, allMessages);
 
-    // Clear the generating flag so the UI knows generation is complete
-    broadcastGeneratingStatus(sessionId, false);
-
     console.log(`[SummaryService] Successfully generated summary for session ${sessionId}`);
 
     // Propagate summary updates to parent sessions (workflow-aware)
@@ -320,11 +327,9 @@ async function _doGenerateSummary(sessionId, retryCount = 0, force = false, user
       stack: error.stack,
       sessionId,
     });
-
-    // Broadcast that generation stopped
-    broadcastGeneratingStatus(sessionId, false);
-
     return null;
+  } finally {
+    broadcastGeneratingStatus(sessionId, false);
   }
 }
 
@@ -366,14 +371,17 @@ export function onSessionActivity(sessionId) {
  * @param {string} sessionId
  */
 function scheduleCiChecks(sessionId) {
-  const scheduleCiCheck = async () => {
+  const makeCheck = (timerId) => async () => {
+    activeTimers.delete(timerId);
     const prStatusService = await import('./prStatusService.js');
     prStatusService.checkSessionCiStatusNow(sessionId);
   };
   // Check after 2 minutes (CI often takes a few minutes)
-  setTimeout(scheduleCiCheck, 2 * 60 * 1000);
+  const timerId1 = setTimeout(() => makeCheck(timerId1)(), 2 * 60 * 1000);
+  activeTimers.add(timerId1);
   // Check again after 5 minutes
-  setTimeout(scheduleCiCheck, 5 * 60 * 1000);
+  const timerId2 = setTimeout(() => makeCheck(timerId2)(), 5 * 60 * 1000);
+  activeTimers.add(timerId2);
 }
 
 /**
@@ -523,30 +531,25 @@ export function propagatePrUrlToParent(sessionId, prUrl) {
 }
 
 // Re-export from extracted modules for backward compatibility
-// These are used by external consumers and tests
 export {
-  // From summaryPrompts.js
-  MAX_MESSAGES,
-  MIN_MESSAGES_FOR_SUMMARY,
-  MAX_RETRIES,
-  DEFAULT_SESSION_TITLE_PROMPT,
-  SUMMARY_SYSTEM_PROMPT,
-  formatMessages,
-  buildIncrementalPrompt,
-  parseSummaryResponse,
-  stripMarkdownCodeBlock as _stripMarkdownCodeBlock,
-  trackMessageMetadata as _trackMessageMetadata,
+  MAX_MESSAGES, MIN_MESSAGES_FOR_SUMMARY, MAX_RETRIES, DEFAULT_SESSION_TITLE_PROMPT,
+  SUMMARY_SYSTEM_PROMPT, formatMessages, buildIncrementalPrompt, parseSummaryResponse,
+  stripMarkdownCodeBlock as _stripMarkdownCodeBlock, trackMessageMetadata as _trackMessageMetadata,
 };
-
-// From summaryClaudeClient.js
 export { callClaude };
-
-// From prUrlService.js
 export { parsePrUrl, validatePrUrl, extractPrUrlIfNeeded, enrichPrData as _enrichPrData };
-
-// From childSessionContext.js
 export { getChildSessions, buildChildSessionContext, aggregateFilesModified };
 
+/**
+ * Clear all pending CI-check timers (called during graceful shutdown).
+ */
+export function clearScheduledTimers() {
+  for (const id of activeTimers) {
+    clearTimeout(id);
+  }
+  activeTimers.clear();
+}
+
 // Read-only accessors for concurrency guard state
 export const isGenerationActive = (key) => guard.isActive(key);
 export const isRegenerationPending = (key) => guard.isPending(key);