circuschief 0.6.0 → 0.8.0

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

@@ -0,0 +1,154 @@
+import OpenAI from 'openai';
+import { callClaude, SESSION_SUMMARY_SCHEMA } from './summaryClaudeClient.js';
+import { agentCallLogger } from './agentCallLogger.js';
+import { buildProviderEnv } from './sessionProvider.js';
+import { resolveSummaryModel } from './summaryModelResolver.js';
+
+export { SESSION_SUMMARY_SCHEMA };
+
+export async function callSummaryModel(prompt, recentMessages, sessionStatus, options = {}) {
+  const resolution = options.resolvedModel || resolveSummaryModel(options.summarySettings || {});
+  if (resolution.kind === 'openai') {
+    return callOpenAISummaryModel(prompt, resolution, options);
+  }
+  return callAnthropicSummaryModel({ prompt, recentMessages, sessionStatus, resolution, options });
+}
+
+function callAnthropicSummaryModel({ prompt, recentMessages, sessionStatus, resolution, options }) {
+  const providerEnv = resolution.provider && !resolution.provider.isBuiltIn
+    ? { ...process.env, ...buildProviderEnv(resolution.provider) }
+    : null;
+
+  return callClaude(prompt, recentMessages, sessionStatus, {
+    ...options,
+    model: resolution.model,
+    providerId: resolution.providerId,
+    selectionReason: resolution.selectionReason,
+    ...(providerEnv ? { env: providerEnv } : {}),
+  });
+}
+
+async function callOpenAISummaryModel(prompt, resolution, options) {
+  const { logMeta = null, systemPrompt = null, jsonSchema = null } = options || {};
+  const schema = jsonSchema || SESSION_SUMMARY_SCHEMA;
+  const provider = resolution.provider;
+  const client = createOpenAIClient(provider);
+
+  const callId = startOpenAISummaryLog(logMeta, resolution, prompt.length);
+
+  try {
+    const response = await createOpenAIChatCompletion(client, {
+      model: resolution.model,
+      prompt,
+      systemPrompt,
+      schema,
+      structured: true,
+    }).catch(async (error) => {
+      if (!isStructuredOutputUnsupported(error)) throw error;
+      return createOpenAIChatCompletion(client, {
+        model: resolution.model,
+        prompt: withJsonOnlyInstruction(prompt, schema),
+        systemPrompt,
+        schema,
+        structured: false,
+      });
+    });
+
+    logOpenAIUsage(callId, response.usage);
+
+    if (callId) {
+      agentCallLogger.completeCall(callId, { success: true });
+    }
+    return extractOpenAIContent(response);
+  } catch (error) {
+    if (callId) {
+      agentCallLogger.completeCall(callId, { success: false, error });
+    }
+    throw error;
+  }
+}
+
+function startOpenAISummaryLog(logMeta, resolution, promptLength) {
+  if (!logMeta) return null;
+  return agentCallLogger.startCall({
+    sessionId: logMeta.sessionId,
+    conversationId: logMeta.conversationId || null,
+    agentType: 'summary',
+    model: resolution.model,
+    callType: logMeta.callType,
+    promptLength,
+    metadata: {
+      ...(resolution.providerId ? { providerId: resolution.providerId } : {}),
+      ...(resolution.selectionReason ? { selectionReason: resolution.selectionReason } : {}),
+    },
+  });
+}
+
+function logOpenAIUsage(callId, usage) {
+  if (!callId || !usage) return;
+  agentCallLogger.updateUsage(callId, {
+    inputTokens: usage.prompt_tokens || 0,
+    outputTokens: usage.completion_tokens || 0,
+    thinkingTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+  });
+}
+
+function createOpenAIClient(provider) {
+  const options = {
+    apiKey: provider?.authToken || process.env.OPENAI_API_KEY || 'missing',
+  };
+  if (provider?.baseUrl) options.baseURL = provider.baseUrl;
+  if (provider?.apiTimeoutMs) options.timeout = provider.apiTimeoutMs;
+  return new OpenAI(options);
+}
+
+function createOpenAIChatCompletion(client, { model, prompt, systemPrompt, schema, structured }) {
+  const messages = [];
+  if (systemPrompt) messages.push({ role: 'system', content: systemPrompt });
+  messages.push({ role: 'user', content: prompt });
+
+  const request = {
+    model,
+    messages,
+    temperature: 0,
+  };
+
+  if (structured) {
+    request.response_format = {
+      type: 'json_schema',
+      json_schema: {
+        name: 'session_summary',
+        schema,
+        strict: false,
+      },
+    };
+  } else {
+    request.response_format = { type: 'json_object' };
+  }
+
+  return client.chat.completions.create(request);
+}
+
+function extractOpenAIContent(response) {
+  const content = response?.choices?.[0]?.message?.content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => part?.text || part?.content || '')
+      .join('');
+  }
+  return content || '';
+}
+
+function isStructuredOutputUnsupported(error) {
+  const message = `${error?.message || ''} ${error?.code || ''} ${error?.type || ''}`.toLowerCase();
+  return [400, 404, 422].includes(error?.status)
+    || message.includes('response_format')
+    || message.includes('json_schema')
+    || message.includes('unsupported');
+}
+
+function withJsonOnlyInstruction(prompt, schema) {
+  return `${prompt}\n\nReturn only a valid JSON object matching this JSON Schema:\n${JSON.stringify(schema)}`;
+}

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

@@ -0,0 +1,148 @@
+import { modelProviders, sessions } from '../database.js';
+import { ACTIVITY_FIELDS_SQL } from '../db/session-helpers.js';
+
+export const DEFAULT_ANTHROPIC_SUMMARY_MODEL = 'claude-haiku-4-5-20251001';
+export const DEFAULT_OPENAI_SUMMARY_MODEL = 'gpt-5.4-mini';
+export const BUILT_IN_ANTHROPIC_PROVIDER_ID = 'anthropic-default';
+export const BUILT_IN_OPENAI_PROVIDER_ID = 'openai-default';
+
+export const CHEAPEST_SUMMARY_MODEL_BY_BUILT_IN_PROVIDER = Object.freeze({
+  [BUILT_IN_ANTHROPIC_PROVIDER_ID]: DEFAULT_ANTHROPIC_SUMMARY_MODEL,
+  [BUILT_IN_OPENAI_PROVIDER_ID]: DEFAULT_OPENAI_SUMMARY_MODEL,
+});
+
+const ANTHROPIC_TIER_NAMES = new Set(['sonnet', 'opus', 'haiku']);
+
+export function isKnownBuiltInAnthropicModel(modelId) {
+  if (!modelId || typeof modelId !== 'string') return false;
+  if (ANTHROPIC_TIER_NAMES.has(modelId.toLowerCase())) return true;
+  if (modelId === DEFAULT_ANTHROPIC_SUMMARY_MODEL) return true;
+
+  const anthropicProvider = modelProviders.getById(BUILT_IN_ANTHROPIC_PROVIDER_ID);
+  return Boolean(
+    anthropicProvider?.models?.some((model) => model.modelId === modelId)
+      || modelId.startsWith('claude-')
+  );
+}
+
+export function resolveSummaryModel(summarySettings = {}) {
+  const summaryModel = summarySettings?.summaryModel || '';
+  const summaryProviderId = summarySettings?.summaryProviderId || null;
+
+  if (summaryModel) {
+    return resolveExplicitSummaryModel(summaryModel, summaryProviderId);
+  }
+  if (summaryProviderId) {
+    throw new Error('summaryModel is required when summaryProviderId is set');
+  }
+
+  const recentFamily = findRecentBuiltInProviderFamily();
+  if (recentFamily === BUILT_IN_OPENAI_PROVIDER_ID) {
+    return {
+      model: DEFAULT_OPENAI_SUMMARY_MODEL,
+      provider: modelProviders.getById(BUILT_IN_OPENAI_PROVIDER_ID),
+      providerId: BUILT_IN_OPENAI_PROVIDER_ID,
+      kind: 'openai',
+      isDefault: true,
+      selectionReason: 'recent-built-in-provider',
+    };
+  }
+
+  if (recentFamily === BUILT_IN_ANTHROPIC_PROVIDER_ID) {
+    return defaultAnthropicResolution('recent-built-in-provider');
+  }
+
+  return defaultAnthropicResolution('fallback');
+}
+
+function resolveExplicitSummaryModel(summaryModel, summaryProviderId) {
+  if (!summaryProviderId) {
+    throw new Error('summaryProviderId is required when summaryModel is set');
+  }
+
+  const provider = modelProviders.getById(summaryProviderId);
+  if (!provider) {
+    throw new Error(`Summary provider not found: ${summaryProviderId}`);
+  }
+
+  const ownsModel = provider.models?.some((model) => model.modelId === summaryModel);
+  if (!ownsModel) {
+    throw new Error(`Summary provider ${summaryProviderId} does not own model ${summaryModel}`);
+  }
+  return providerResolution(summaryModel, provider, 'explicit');
+}
+
+function providerResolution(model, provider, selectionReason) {
+  const kind = provider.kind || 'anthropic';
+  return {
+    model,
+    provider,
+    providerId: provider.id,
+    kind,
+    isDefault: false,
+    selectionReason,
+  };
+}
+
+function defaultAnthropicResolution(selectionReason) {
+  return {
+    model: DEFAULT_ANTHROPIC_SUMMARY_MODEL,
+    provider: null,
+    providerId: null,
+    kind: 'anthropic',
+    isDefault: true,
+    selectionReason,
+  };
+}
+
+function findRecentBuiltInProviderFamily() {
+  for (const usage of getRecentSessionModelUsage()) {
+    const providerId = usage.providerId || null;
+    if (providerId) {
+      const provider = modelProviders.getById(providerId);
+      const family = builtInFamilyForProvider(provider);
+      if (family) return family;
+      continue;
+    }
+
+    const model = usage.model || null;
+    if (!model) continue;
+
+    const provider = modelProviders.getProviderByModelId(model);
+    const family = builtInFamilyForProvider(provider);
+    if (family) return family;
+
+    if (!provider && isKnownBuiltInAnthropicModel(model)) {
+      return BUILT_IN_ANTHROPIC_PROVIDER_ID;
+    }
+  }
+  return null;
+}
+
+function builtInFamilyForProvider(provider) {
+  if (!provider?.isBuiltIn) return null;
+  if (provider.id === BUILT_IN_OPENAI_PROVIDER_ID || provider.kind === 'openai') return BUILT_IN_OPENAI_PROVIDER_ID;
+  if (provider.id === BUILT_IN_ANTHROPIC_PROVIDER_ID || (provider.kind || 'anthropic') === 'anthropic') {
+    return BUILT_IN_ANTHROPIC_PROVIDER_ID;
+  }
+  return null;
+}
+
+export function getRecentSessionModelUsage(limit = 50) {
+  const rows = sessions.db
+    .prepare(
+      `SELECT s.model, s.provider_id, ${ACTIVITY_FIELDS_SQL}
+       FROM sessions s
+       ORDER BY COALESCE(last_activity_at, s.updated_at, s.created_at) DESC,
+                s.updated_at DESC,
+                s.created_at DESC,
+                s.rowid DESC
+       LIMIT ?`
+    )
+    .all(limit);
+
+  return rows.map((row) => ({
+    model: row.model || null,
+    providerId: row.provider_id || null,
+  }));
+}

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

@@ -13,7 +13,7 @@
 
 import { sessions, messages, sessionSummaries, projects, settings } from '../database.js';
 import { createConcurrencyGuard } from './withConcurrencyGuard.js';
-import { callClaude } from './summaryClaudeClient.js';
+import { callSummaryModel } from './summaryModelClient.js';
 import {
   MAX_MESSAGES,
   MIN_MESSAGES_FOR_SUMMARY,
@@ -200,18 +200,19 @@ function updateSessionFromSummary(sessionId, session, summaryData) {
   if (summaryData.sessionTitle || summaryData.prUrl) {
     const updateData = {};
     const freshSession = sessions.getById(sessionId);
+    const shouldApplySummaryPrUrl = summaryData.prUrl && !freshSession.prUrlAutoLinkDisabled;
 
     if (summaryData.sessionTitle && !freshSession.manuallyNamed) {
       updateData.name = summaryData.sessionTitle;
     }
 
-    if (summaryData.prUrl) {
+    if (shouldApplySummaryPrUrl) {
       updateData.prUrl = summaryData.prUrl;
     }
 
     const updatedSession = sessions.update(sessionId, updateData);
 
-    if (summaryData.prUrl) {
+    if (shouldApplySummaryPrUrl) {
       propagatePrUrlToParent(sessionId, summaryData.prUrl);
     }
 
@@ -299,10 +300,11 @@ async function _doGenerateSummary(sessionId, retryCount = 0, force = false, user
     // Build conversation context and prompt
     const { prompt } = fetchConversationContext(sessionId, { existingSummary, recentMessages, session, globalSettings });
 
-    // Call Claude via SDK
-    const responseText = await callClaude(prompt, recentMessages, session.status, {
+    // Call the configured summary model.
+    const responseText = await callSummaryModel(prompt, recentMessages, session.status, {
       logMeta: { sessionId, callType: 'generateSessionSummary' },
       systemPrompt: SUMMARY_SYSTEM_PROMPT,
+      summarySettings: globalSettings,
     });
 
     // Parse response and retry if needed
@@ -520,7 +522,7 @@ export function propagatePrUrlToParent(sessionId, prUrl) {
   if (!rootId || rootId === sessionId) return;
 
   const root = sessions.getById(rootId);
-  if (!root || root.prUrl) return; // Don't overwrite existing PR URL
+  if (!root || root.prUrl || root.prUrlAutoLinkDisabled) return; // Don't overwrite existing or user-cleared PR URL
 
   sessions.update(root.id, { prUrl });
 
@@ -535,8 +537,10 @@ export {
   MAX_MESSAGES, MIN_MESSAGES_FOR_SUMMARY, MAX_RETRIES, DEFAULT_SESSION_TITLE_PROMPT,
   SUMMARY_SYSTEM_PROMPT, formatMessages, buildIncrementalPrompt, parseSummaryResponse,
   stripMarkdownCodeBlock as _stripMarkdownCodeBlock, trackMessageMetadata as _trackMessageMetadata,
+  updateSessionFromSummary as _updateSessionFromSummary,
 };
-export { callClaude };
+export { callSummaryModel };
+export { callClaude } from './summaryClaudeClient.js';
 export { parsePrUrl, validatePrUrl, extractPrUrlIfNeeded, enrichPrData as _enrichPrData };
 export { getChildSessions, buildChildSessionContext, aggregateFilesModified };
 

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

@@ -3,10 +3,24 @@
  * Extracted from summaryService.js for modularity.
  */
 
-import { sessionSummaries, messages } from '../database.js';
+import { sessionSummaries, messages, sessions } from '../database.js';
 
 /**
- * Check if a summary is stale (message count or last message ID has changed)
+ * Check if any descendant session has a summary newer than the given timestamp.
+ * @param {string} sessionId
+ * @param {number} generatedAt
+ * @returns {boolean}
+ */
+function hasNewerDescendantSummary(sessionId, generatedAt) {
+  const descendantIds = sessions.getAllDescendantIds(sessionId);
+  if (descendantIds.length === 0) return false;
+
+  const descendantSummaries = sessionSummaries.getBySessionIds(descendantIds);
+  return descendantSummaries.some(ds => ds.generatedAt > generatedAt);
+}
+
+/**
+ * Check if a summary is stale (message count, last message ID, or descendant summaries have changed)
  * @param {string} sessionId
  * @returns {boolean}
  */
@@ -27,9 +41,14 @@ export function isSummaryStale(sessionId) {
     }
 
     // Also validate count as a secondary check (defensive programming)
-    return allMessages.length !== summary.messageCount;
+    if (allMessages.length !== summary.messageCount) return true;
   }
 
   // Fallback to count-based staleness detection for old summaries
-  return allMessages.length !== summary.messageCount;
+  if (allMessages.length !== summary.messageCount) return true;
+
+  // Check if any descendant session has a newer summary
+  if (hasNewerDescendantSummary(sessionId, summary.generatedAt)) return true;
+
+  return false;
 }

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

@@ -4,7 +4,7 @@ import { setupGitForSession } from './gitSessionSetup.js';
 import { runSession } from './sessionManager.js';
 import { broadcastToProject } from '../websocket.js';
 import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
-import { resolveAgentTypeFromModel } from './sessionProvider.js';
+import { resolveAgentTypeFromModel, resolveProviderMetadataFromModel } from './sessionProvider.js';
 
 const liquid = new Liquid();
 
@@ -100,6 +100,8 @@ async function resolveWorkingDirectory(parentSession, project, settings, newSess
     gitBranch: settings.gitBranch,
     sessionId: newSessionId,
     worktreeBasePath: project.worktreePath || null,
+    commitAttributionOverride:
+      resolveProviderMetadataFromModel(settings.model)?.commitAttributionOverride ?? null,
   });
   return { workingDirectory: gitSetup.workingDirectory, gitWorktree: gitSetup.gitWorktree };
 }

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

@@ -1,4 +1,4 @@
-/** @type {Map<string, {inputTokens: number, outputTokens: number, lastMessageOutput: number, cacheReadInputTokens: number, cacheCreationInputTokens: number}>}
+/** @type {Map<string, {inputTokens: number, outputTokens: number, thinkingTokens: number, lastMessageOutput: number, cacheReadInputTokens: number, cacheCreationInputTokens: number}>}
  * Current turn usage - accumulates across multiple messages within a turn
  * Keyed by conversationId (Issue #175)
  * - inputTokens: MAX seen across all messages (larger context with tool results)
@@ -31,6 +31,7 @@ function updateTurnUsage(conversationId, usage, eventType) {
   const current = currentTurnUsage.get(conversationId) || {
     inputTokens: 0,
     outputTokens: 0,
+    thinkingTokens: 0,
     lastMessageOutput: 0,
     cacheReadInputTokens: 0,
     cacheCreationInputTokens: 0,
@@ -46,11 +47,13 @@ function updateTurnUsage(conversationId, usage, eventType) {
     estimatedOutputTokens.delete(conversationId);
     // 4. For input tokens, keep the MAX (larger context with tool results)
     current.inputTokens = Math.max(current.inputTokens, usage.input_tokens || 0);
+    current.thinkingTokens = Math.max(current.thinkingTokens, usage.thinking_tokens || usage.thinkingTokens || 0);
     current.cacheReadInputTokens = Math.max(current.cacheReadInputTokens, usage.cache_read_input_tokens || 0);
     current.cacheCreationInputTokens = Math.max(current.cacheCreationInputTokens, usage.cache_creation_input_tokens || 0);
   } else if (eventType === 'message_delta') {
     // OUTPUT STREAMING - output_tokens is cumulative within this message
     current.lastMessageOutput = usage.output_tokens || 0;
+    current.thinkingTokens = Math.max(current.thinkingTokens, usage.thinking_tokens || usage.thinkingTokens || 0);
     // Clear estimate when actual output tokens arrive
     estimatedOutputTokens.delete(conversationId);
   }
@@ -61,6 +64,7 @@ function updateTurnUsage(conversationId, usage, eventType) {
   return {
     inputTokens: current.inputTokens,
     outputTokens: current.outputTokens + current.lastMessageOutput,
+    thinkingTokens: current.thinkingTokens,
     cacheReadInputTokens: current.cacheReadInputTokens,
     cacheCreationInputTokens: current.cacheCreationInputTokens,
   };

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

@@ -0,0 +1,123 @@
+import { sessions, conversations, messages } from '../database.js';
+import { broadcastToSession } from '../websocket.js';
+import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+
+export function normalizeFinalErrorMessage(error) {
+  if (error?.message) {
+    return error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  if (error == null) {
+    return 'Unknown error';
+  }
+  return String(error);
+}
+
+function normalizeMessageContent(content) {
+  return (content || '').trim().replace(/\s+/g, ' ');
+}
+
+function buildVisibleErrorContent(agentType, errorMessage) {
+  if (agentType === 'codex') {
+    return `Codex failed before completing this turn:\n\n${errorMessage}`;
+  }
+  if (agentType === 'claude-code') {
+    return `Claude Code failed before completing this turn:\n\n${errorMessage}`;
+  }
+  return `The agent failed before completing this turn:\n\n${errorMessage}`;
+}
+
+/**
+ * Check if a visible error message already exists to prevent duplicates.
+ *
+ * Uses two strategies to detect existing failures:
+ *
+ * Strategy 1: Exact match with generated content
+ * - Checks if the latest message is an assistant message with content exactly matching
+ *   what we would generate (e.g., "Codex failed before completing this turn:\n\nerror")
+ * - This catches cases where we already created the formatted error message
+ *
+ * Strategy 2: Raw error in messages after latest user message
+ * - Finds the latest user message, then checks all subsequent assistant messages
+ * - Returns true if any assistant message contains the raw error text
+ * - This catches cases where the agent itself already reported the error
+ *   (e.g., "Run failed: usage limit reached" contains "usage limit reached")
+ *
+ * @param {Array} conversationMessages - All messages in the conversation
+ * @param {string} generatedContent - The formatted error content we would create
+ * @param {string} rawErrorMessage - The raw error message text
+ * @returns {boolean} True if a duplicate error message already exists
+ */
+function hasExistingVisibleFailure(conversationMessages, generatedContent, rawErrorMessage) {
+  const normalizedGenerated = normalizeMessageContent(generatedContent);
+  const normalizedError = normalizeMessageContent(rawErrorMessage);
+  const latestMessage = conversationMessages[conversationMessages.length - 1];
+
+  // Strategy 1: Check if the latest message is an exact match with our generated content
+  if (
+    latestMessage?.role === 'assistant' &&
+    normalizeMessageContent(latestMessage.content) === normalizedGenerated
+  ) {
+    return true;
+  }
+
+  // Find the index of the latest user message
+  let latestUserIndex = -1;
+  for (let i = conversationMessages.length - 1; i >= 0; i -= 1) {
+    if (conversationMessages[i].role === 'user') {
+      latestUserIndex = i;
+      break;
+    }
+  }
+
+  // Strategy 2: Check if any assistant message after the latest user message contains the raw error
+  return conversationMessages
+    .slice(latestUserIndex + 1)
+    .some((message) => {
+      if (message.role !== 'assistant') {
+        return false;
+      }
+      const normalizedContent = normalizeMessageContent(message.content);
+      return normalizedContent === normalizedGenerated ||
+        (normalizedError && normalizedContent.includes(normalizedError));
+    });
+}
+
+function resolveErrorConversationId(sessionId, activeConversationIds) {
+  const activeConversationId = activeConversationIds.get(sessionId);
+  if (activeConversationId) {
+    return activeConversationId;
+  }
+  const activeConversation = conversations.ensureActiveConversation(sessionId);
+  if (activeConversation?.id) {
+    activeConversationIds.set(sessionId, activeConversation.id);
+    return activeConversation.id;
+  }
+  return null;
+}
+
+export function createVisibleFinalErrorMessage(sessionId, error, activeConversationIds) {
+  const conversationId = resolveErrorConversationId(sessionId, activeConversationIds);
+  if (!conversationId) {
+    return null;
+  }
+
+  const session = sessions.getById(sessionId);
+  const errorMessage = normalizeFinalErrorMessage(error);
+  const content = buildVisibleErrorContent(session?.agentType, errorMessage);
+  const conversationMessages = messages.getByConversationId(conversationId) || [];
+
+  if (hasExistingVisibleFailure(conversationMessages, content, errorMessage)) {
+    return null;
+  }
+
+  const message = messages.create(sessionId, 'assistant', content, { conversationId });
+  sessions.touch(sessionId);
+  broadcastToSession(sessionId, WS_MESSAGE_TYPES.SESSION_MESSAGE, {
+    message,
+    conversationId,
+  });
+  return message;
+}

package/packages/shared/src/constants.js

@@ -4,8 +4,7 @@ export const API_PREFIX = '/api';
 export const WS_PATH = '/ws';
 
 /**
- * Default token cost weights for calculating Billable Token Equivalent (BTE)
- * These weights represent relative costs compared to input tokens (1.0 = base rate)
+ * Legacy token cost weights kept for settings API compatibility.
  */
 export const DEFAULT_TOKEN_COST_WEIGHTS = {
   input: 1.0,        // Base rate
@@ -21,6 +20,9 @@ export const WS_RECONNECT_MAX_DELAY = 30000;
 
 export const TOAST_DURATION = 5000;
 
+/** Default delay (in minutes) before auto-rescheduling a session. */
+export const DEFAULT_RESCHEDULE_DELAY_MINUTES = 60;
+
 export const DEFAULT_SYSTEM_PROMPT = `You are Claude Code, an AI coding assistant. You help users with software engineering tasks including writing code, debugging, refactoring, and explaining code. You have full access to the shell and can execute any commands needed to assist the user. Be helpful, accurate, and thorough.
 
 IMPORTANT: Your working directory is already set correctly for this session. NEVER use \`cd\` to change to a hardcoded project path before running commands (e.g., \`cd /path/to/project && git status\`). This bypasses git worktree isolation and causes commands to run in the wrong directory. Always run commands directly without changing directory.

package/packages/shared/src/contracts/commandButtons.js

@@ -1,15 +1,29 @@
 import { z } from 'zod';
 
+const OPTION_TOKEN_DASHES = /(^|\s)([-\u2010-\u2015\u2212]+)(?=[A-Za-z0-9-])/g;
+const UNICODE_DASHES = /[\u2010-\u2015\u2212]/g;
+const HAS_UNICODE_DASH = /[\u2010-\u2015\u2212]/;
+
+export function normalizeCommandOptionDashes(command) {
+  return command.replace(OPTION_TOKEN_DASHES, (match, prefix, dashes) => {
+    if (!HAS_UNICODE_DASH.test(dashes)) {
+      return match;
+    }
+
+    return `${prefix}${dashes.replace(UNICODE_DASHES, '-')}`;
+  });
+}
+
 export const CreateCommandButtonRequest = z.object({
   label: z.string().min(1, 'Label is required'),
-  command: z.string().min(1, 'Command is required'),
+  command: z.string().min(1, 'Command is required').transform(normalizeCommandOptionDashes),
   sortOrder: z.number().int().optional().default(0),
   showOnList: z.boolean().optional().default(false),
 });
 
 export const UpdateCommandButtonRequest = z.object({
   label: z.string().min(1).optional(),
-  command: z.string().min(1).optional(),
+  command: z.string().min(1).transform(normalizeCommandOptionDashes).optional(),
   sortOrder: z.number().int().optional(),
   showOnList: z.boolean().optional(),
 }).refine(obj => Object.keys(obj).length > 0, 'At least one field must be provided for update');

package/packages/shared/src/contracts/projects.js

@@ -46,9 +46,10 @@ export const ProjectSessionDefaultsRequest = z.object({
   thinkingEnabled: z.boolean().nullable().optional(),
   effortLevel: z.enum(['low', 'medium', 'high', 'max', 'auto']).nullable().optional(),
   startImmediately: z.boolean().nullable().optional(),
-  gitMode: z.enum(['branch', 'worktree']).nullable().optional(),
+  gitMode: z.enum(['branch', 'worktree', 'current']).nullable().optional(),
   gitBranch: z.string().nullable().optional(),
   model: z.string().nullable().optional(),
+  providerId: z.string().nullable().optional(),
 });
 
 export const ProjectSessionDefaultsResponse = z.object({
@@ -58,9 +59,10 @@ export const ProjectSessionDefaultsResponse = z.object({
   thinkingEnabled: z.boolean().nullable(),
   effortLevel: z.enum(['low', 'medium', 'high', 'max', 'auto']).nullable(),
   startImmediately: z.boolean().nullable(),
-  gitMode: z.enum(['branch', 'worktree']).nullable(),
+  gitMode: z.enum(['branch', 'worktree', 'current']).nullable(),
   gitBranch: z.string().nullable(),
   model: z.string().nullable(),
+  providerId: z.string().nullable(),
   createdAt: z.number(),
   updatedAt: z.number(),
 });