circuschief 0.7.0 → 1.0.0

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

@@ -1,21 +1,42 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import path from 'path';
-import { realpath } from 'fs/promises';
+export {
+  _setManagedHooksPath,
+  clearWorktreeCommitAttribution,
+  configureWorktreeCommitAttribution,
+  ensureWorktreeCommitAttributionHook,
+  getManagedHooksPath,
+} from './gitCommitAttribution.js';
+export {
+  normalizeGitRemoteUrl,
+  getRepositoryUrl,
+  detectWorktreePath,
+} from './gitRepoUrl.js';
+export {
+  getDiff,
+  getStagedDiff,
+  getUntrackedFiles,
+  getDiffAgainstBranch,
+  getStagedDiffAgainstBranch,
+  getDiffBetweenRefs,
+  getModifiedFilesCount,
+} from './gitDiff.js';
+export {
+  branchExists,
+  checkoutBranch,
+  createWorktree,
+  removeWorktree,
+  createWorktreeForBranch,
+} from './gitWorktree.js';
 
 const execAsync = promisify(exec);
 
-// Cache for default branch detection per repository
-// Key: directory path, Value: { branch: string, timestamp: number }
+// Cache for default branch detection: directory -> { branch, timestamp }
 const defaultBranchCache = new Map();
 const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const MAX_CACHE_SIZE = 100; // Maximum number of repositories to cache
 
-// Configurable logger for warning messages
-// Can be overridden via setLogger() for custom logging behavior
-let logger = {
-  warn: (...args) => console.warn(...args),
-};
+import { _setWorktreeLogger } from './gitWorktree.js';
 
 /**
  * Set a custom logger for git service warnings.
@@ -24,19 +45,15 @@ let logger = {
  * @param {Function} customLogger.warn - Function to handle warning messages
  */
 export function setLogger(customLogger) {
-  logger = customLogger;
+  _setWorktreeLogger(customLogger);
 }
 
-/**
- * Evict oldest entries from cache if it exceeds MAX_CACHE_SIZE.
- * Uses LRU-like eviction based on timestamp.
- */
+/** Evict oldest cache entries if size exceeds MAX_CACHE_SIZE (LRU-like). */
 function evictOldestCacheEntries() {
   if (defaultBranchCache.size <= MAX_CACHE_SIZE) {
     return;
   }
 
-  // Sort entries by timestamp and remove oldest ones
   const entries = [...defaultBranchCache.entries()];
   entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
 
@@ -46,36 +63,27 @@ function evictOldestCacheEntries() {
   }
 }
 
-/**
- * Safely fetch from origin remote.
- * Logs a warning if fetch fails but does not throw.
- * @param {string} directory - The git repository directory
- * @returns {Promise<boolean>} - True if fetch succeeded, false otherwise
- */
-async function safeFetchOrigin(directory) {
-  try {
-    await git(directory, 'fetch origin');
-    return true;
-  } catch (err) {
-    // No origin or network unavailable, proceed without fetch
-    logger.warn('Could not fetch from origin, proceeding with local refs:', err.message);
-    return false;
-  }
-}
-
 /**
  * Execute a git command in a directory
  * @param {string} directory
  * @param {string} command
+ * @param {Object} [opts]
+ * @param {Object} [opts.env]
+ * @param {number} [opts.timeout]
  * @returns {Promise<string>}
  */
-async function git(directory, command, opts = {}) {
+export async function git(directory, command, opts = {}) {
   const execOpts = { cwd: directory };
   if (opts.env) execOpts.env = opts.env;
+  if (opts.timeout) execOpts.timeout = opts.timeout;
   const { stdout } = await execAsync(`git ${command}`, execOpts);
   return stdout.trim();
 }
 
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
 /**
  * Detect the default branch using git commands (symbolic-ref, rev-parse).
  * @param {string} directory
@@ -237,242 +245,9 @@ export async function getCurrentBranch(directory) {
   }
 }
 
-/**
- * Create a new worktree
- * @param {string} directory
- * @param {string} branch
- * @param {string} worktreePath
- * @param {Object} options
- * @param {boolean} options.skipFetch - Skip fetching from origin (default: false)
- * @returns {Promise<{path: string, branch: string}>}
- */
-export async function createWorktree(directory, branch, worktreePath, options = {}) {
-  const { skipFetch = false } = options;
-
-  // Fetch latest from origin to ensure we have up-to-date default branch
-  if (!skipFetch) {
-    await safeFetchOrigin(directory);
-  }
-
-  // Get the default branch from origin (main or master)
-  const defaultBranch = await getOriginDefaultBranch(directory);
-  // Base new branch on origin's default branch to avoid including unrelated commits from HEAD
-  // Use --no-track to prevent the new branch from tracking the start-point (main/master)
-  await git(directory, `worktree add --no-track "${worktreePath}" -b "${branch}" ${defaultBranch}`);
-  return { path: worktreePath, branch };
-}
-
-/**
- * Remove a worktree
- * @param {string} directory
- * @param {string} path
- * @param {boolean} force - Force removal even if worktree has uncommitted changes
- */
-export async function removeWorktree(directory, worktreePath, force = false) {
-  const forceFlag = force ? '--force' : '';
-  await git(directory, `worktree remove ${forceFlag} "${worktreePath}"`);
-}
-
-/**
- * Get diff for a directory
- * @param {string} directory
- * @returns {Promise<string>}
- */
-export async function getDiff(directory) {
-  try {
-    return await git(directory, 'diff');
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Get staged diff for a directory
- * @param {string} directory
- * @returns {Promise<string>}
- */
-export async function getStagedDiff(directory) {
-  try {
-    return await git(directory, 'diff --cached');
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Check if a branch exists
- * @param {string} directory
- * @param {string} branch
- * @returns {Promise<boolean>}
- */
-export async function branchExists(directory, branch) {
-  try {
-    await git(directory, `rev-parse --verify refs/heads/${branch}`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Checkout a branch, creating it if it doesn't exist
- * @param {string} directory
- * @param {string} branch
- * @returns {Promise<void>}
- */
-export async function checkoutBranch(directory, branch) {
-  const exists = await branchExists(directory, branch);
-  if (exists) {
-    await git(directory, `checkout "${branch}"`);
-  } else {
-    await git(directory, `checkout -b "${branch}"`);
-  }
-}
-
-/**
- * Create a worktree for a branch (creates branch if it doesn't exist)
- * @param {string} directory - Main repo directory
- * @param {string} branch - Branch name
- * @param {string} worktreePath - Path for the new worktree
- * @param {Object} options
- * @param {boolean} options.skipFetch - Skip fetching from origin (default: false)
- * @returns {Promise<{path: string, branch: string}>}
- */
-export async function createWorktreeForBranch(directory, branch, worktreePath, options = {}) {
-  const { skipFetch = false } = options;
-
-  // Fetch latest from origin to ensure we have up-to-date default branch
-  if (!skipFetch) {
-    await safeFetchOrigin(directory);
-  }
-
-  const exists = await branchExists(directory, branch);
-  if (exists) {
-    await git(directory, `worktree add "${worktreePath}" "${branch}"`);
-  } else {
-    // Get the default branch from origin (main or master)
-    const defaultBranch = await getOriginDefaultBranch(directory);
-    // Base new branch on origin's default branch to avoid including unrelated commits from HEAD
-    // Use --no-track to prevent the new branch from tracking the start-point (main/master)
-    await git(directory, `worktree add --no-track -b "${branch}" "${worktreePath}" ${defaultBranch}`);
-  }
-  return { path: worktreePath, branch };
-}
-
-/**
- * Get list of untracked files
- * @param {string} directory
- * @returns {Promise<string[]>}
- */
-export async function getUntrackedFiles(directory) {
-  try {
-    const output = await git(directory, 'ls-files --others --exclude-standard');
-    if (!output) return [];
-    return output.split('\n').filter((line) => line.trim());
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Get diff for a directory compared to a specific branch
- * @param {string} directory
- * @param {string} branch - Branch to compare against (e.g., 'origin/main')
- * @returns {Promise<string>}
- */
-export async function getDiffAgainstBranch(directory, branch) {
-  try {
-    return await git(directory, `diff ${branch}`);
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Get staged diff for a directory compared to a specific branch
- * @param {string} directory
- * @param {string} branch - Branch to compare against (e.g., 'origin/main')
- * @returns {Promise<string>}
- */
-export async function getStagedDiffAgainstBranch(directory, branch) {
-  try {
-    return await git(directory, `diff --cached ${branch}`);
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Get diff between two git refs (e.g., comparing HEAD to origin/main)
- * This shows the committed changes between two refs, ignoring working tree state
- * @param {string} directory
- * @param {string} fromRef - Base ref (e.g., 'origin/main')
- * @param {string} toRef - Target ref (e.g., 'HEAD')
- * @returns {Promise<string>}
- */
-export async function getDiffBetweenRefs(directory, fromRef, toRef) {
-  try {
-    return await git(directory, `diff ${fromRef} ${toRef}`);
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Get count of files modified/added compared to a branch
- * Includes committed changes + staged + unstaged + untracked files
- * @param {string} directory - The git repository directory
- * @param {string} branch - Branch to compare against (e.g., 'origin/main')
- * @returns {Promise<number>} - Total count of unique files modified/added
- */
-export async function getModifiedFilesCount(directory, branch) {
-  try {
-    // Get all modified files in one command using --name-only
-    // This includes: committed changes vs branch + staged
-    const committedAndStaged = await git(
-      directory,
-      `diff --name-only ${branch}...HEAD`
-    );
-
-    // Get unstaged changes (working tree vs index)
-    const unstaged = await git(directory, 'diff --name-only');
-
-    // Get untracked files
-    const untracked = await getUntrackedFiles(directory);
-
-    // Combine all files into a Set to get unique count
-    const allFiles = new Set();
-
-    // Parse committed+staged files
-    if (committedAndStaged) {
-      committedAndStaged.split('\n').forEach(f => {
-        if (f.trim()) allFiles.add(f.trim());
-      });
-    }
-
-    // Parse unstaged files
-    if (unstaged) {
-      unstaged.split('\n').forEach(f => {
-        if (f.trim()) allFiles.add(f.trim());
-      });
-    }
-
-    // Add untracked files
-    untracked.forEach(f => allFiles.add(f));
-
-    return allFiles.size;
-  } catch (error) {
-    logger.warn(`Failed to get modified files count for ${directory}:`, error.message);
-    return 0;
-  }
-}
-
 /**
  * Get the git author info from the global config (~/.gitconfig).
- *
- * Uses `--global` so that a contaminated local config (e.g. one that
- * already has Claude Code's identity) is bypassed.
- *
+ * Uses `--global` so that a contaminated local config is bypassed.
  * @param {string} directory
  * @param {Object} [options]
  * @param {Object} [options.env] - Custom environment variables (useful for tests)
@@ -493,17 +268,12 @@ export async function getGitAuthor(directory, { env } = {}) {
 
 /**
  * Pin the human developer's git identity in a worktree's config.
- *
- * Reads user.name/user.email from the main project directory and writes
- * them into the worktree-specific config (--worktree). This ensures the
- * human is always the commit Author, even if the session's environment
- * tries to override it. Claude Code already adds its own Co-Authored-By
- * trailer via its system prompt, so no hook is needed.
- *
- * Only call this for worktree directories, not the main repo.
- *
+ * Reads user.name/user.email from the main project directory and writes them
+ * into the worktree-specific config (--worktree). Only call for worktree dirs.
  * @param {string} worktreePath - The worktree directory
  * @param {string} projectDir - The main project directory (to read author from)
+ * @param {Object} [options]
+ * @param {Object} [options.env] - Custom environment variables (useful for tests)
  * @returns {Promise<boolean>} - True if author was pinned
  */
 export async function pinAuthorInWorktree(worktreePath, projectDir, { env } = {}) {
@@ -515,42 +285,9 @@ export async function pinAuthorInWorktree(worktreePath, projectDir, { env } = {}
 
   // Pin the human's identity in the worktree config so they are always
   // the commit Author, regardless of what the session does later
-  await git(worktreePath, `config --worktree user.name "${author.name}"`);
-  await git(worktreePath, `config --worktree user.email "${author.email}"`);
+  await git(worktreePath, `config --worktree user.name ${shellQuote(author.name)}`);
+  await git(worktreePath, `config --worktree user.email ${shellQuote(author.email)}`);
 
   return true;
 }
 
-/**
- * Detect the worktree path for a directory by inspecting existing worktrees.
- * If external worktrees exist, uses the parent directory of the first one.
- * Otherwise, falls back to {directory}/.worktrees.
- * @param {string} directory - The git repository directory
- * @returns {Promise<{worktreePath: string, source: 'detected' | 'default'}>}
- */
-export async function detectWorktreePath(directory) {
-  const isRepo = await isGitRepo(directory);
-  if (!isRepo) {
-    return { worktreePath: path.join(directory, '.worktrees'), source: 'default' };
-  }
-
-  // Resolve symlinks for consistent path comparison (e.g., /var -> /private/var on macOS)
-  let resolvedDir;
-  try {
-    resolvedDir = await realpath(directory);
-  } catch {
-    resolvedDir = path.resolve(directory);
-  }
-
-  const worktrees = await getWorktrees(directory);
-  // Filter out the main worktree (its path === directory or resolves to it)
-  const externalWorktrees = worktrees.filter(wt => path.resolve(wt.path) !== resolvedDir);
-
-  if (externalWorktrees.length > 0) {
-    // Use the parent directory of the first external worktree
-    const parentDir = path.dirname(path.resolve(externalWorktrees[0].path));
-    return { worktreePath: parentDir, source: 'detected' };
-  }
-
-  return { worktreePath: path.join(resolvedDir, '.worktrees'), source: 'default' };
-}

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

@@ -9,9 +9,17 @@ import * as gitService from './gitService.js';
  * @param {string|null} options.gitBranch - Branch name
  * @param {string} options.sessionId - Session ID
  * @param {string|null} [options.worktreeBasePath] - Custom base path for worktrees (overrides default .worktrees)
+ * @param {string|null} [options.commitAttributionOverride] - Deprecated; attribution is process-scoped at agent launch
  * @returns {Promise<{workingDirectory: string, gitWorktree: string|null}>}
  */
-export async function setupGitForSession({ projectDir, gitMode, gitBranch, sessionId, worktreeBasePath }) {
+export async function setupGitForSession({
+  projectDir,
+  gitMode,
+  gitBranch,
+  sessionId,
+  worktreeBasePath,
+  commitAttributionOverride = null,
+}) {
   // No git operations if gitMode is not specified
   if (!gitMode || !gitBranch) {
     return {
@@ -35,6 +43,8 @@ export async function setupGitForSession({ projectDir, gitMode, gitBranch, sessi
     await gitService.createWorktreeForBranch(projectDir, gitBranch, worktreePath);
     // Pin the human developer's git identity so they are the commit Author
     await gitService.pinAuthorInWorktree(worktreePath, projectDir);
+    void commitAttributionOverride;
+    await gitService.ensureWorktreeCommitAttributionHook(worktreePath);
     return {
       workingDirectory: worktreePath,
       gitWorktree: worktreePath,

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

@@ -0,0 +1,127 @@
+import { git, getOriginDefaultBranch } from './gitService.js';
+
+// Configurable logger for warning messages
+let logger = {
+  warn: (...args) => console.warn(...args),
+};
+
+/**
+ * Set a custom logger for git worktree warnings.
+ * @param {Object} customLogger - Logger object with a warn method
+ */
+export function _setWorktreeLogger(customLogger) {
+  logger = customLogger;
+}
+
+/**
+ * Safely fetch from origin remote.
+ * Logs a warning if fetch fails but does not throw.
+ * @param {string} directory - The git repository directory
+ * @returns {Promise<boolean>} - True if fetch succeeded, false otherwise
+ */
+async function safeFetchOrigin(directory) {
+  try {
+    await git(directory, 'fetch origin');
+    return true;
+  } catch (err) {
+    // No origin or network unavailable, proceed without fetch
+    logger.warn('Could not fetch from origin, proceeding with local refs:', err.message);
+    return false;
+  }
+}
+
+/**
+ * Check if a branch exists
+ * @param {string} directory
+ * @param {string} branch
+ * @returns {Promise<boolean>}
+ */
+export async function branchExists(directory, branch) {
+  try {
+    await git(directory, `rev-parse --verify refs/heads/${branch}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Checkout a branch, creating it if it doesn't exist
+ * @param {string} directory
+ * @param {string} branch
+ * @returns {Promise<void>}
+ */
+export async function checkoutBranch(directory, branch) {
+  const exists = await branchExists(directory, branch);
+  if (exists) {
+    await git(directory, `checkout "${branch}"`);
+  } else {
+    await git(directory, `checkout -b "${branch}"`);
+  }
+}
+
+/**
+ * Create a new worktree
+ * @param {string} directory
+ * @param {string} branch
+ * @param {string} worktreePath
+ * @param {Object} options
+ * @param {boolean} options.skipFetch - Skip fetching from origin (default: false)
+ * @returns {Promise<{path: string, branch: string}>}
+ */
+export async function createWorktree(directory, branch, worktreePath, options = {}) {
+  const { skipFetch = false } = options;
+
+  // Fetch latest from origin to ensure we have up-to-date default branch
+  if (!skipFetch) {
+    await safeFetchOrigin(directory);
+  }
+
+  // Get the default branch from origin (main or master)
+  const defaultBranch = await getOriginDefaultBranch(directory);
+  // Base new branch on origin's default branch to avoid including unrelated commits from HEAD
+  // Use --no-track to prevent the new branch from tracking the start-point (main/master)
+  await git(directory, `worktree add --no-track "${worktreePath}" -b "${branch}" ${defaultBranch}`);
+  return { path: worktreePath, branch };
+}
+
+/**
+ * Remove a worktree
+ * @param {string} directory
+ * @param {string} path
+ * @param {boolean} force - Force removal even if worktree has uncommitted changes
+ */
+export async function removeWorktree(directory, worktreePath, force = false) {
+  const forceFlag = force ? '--force' : '';
+  await git(directory, `worktree remove ${forceFlag} "${worktreePath}"`);
+}
+
+/**
+ * Create a worktree for a branch (creates branch if it doesn't exist)
+ * @param {string} directory - Main repo directory
+ * @param {string} branch - Branch name
+ * @param {string} worktreePath - Path for the new worktree
+ * @param {Object} options
+ * @param {boolean} options.skipFetch - Skip fetching from origin (default: false)
+ * @returns {Promise<{path: string, branch: string}>}
+ */
+export async function createWorktreeForBranch(directory, branch, worktreePath, options = {}) {
+  const { skipFetch = false } = options;
+
+  // Fetch latest from origin to ensure we have up-to-date default branch
+  if (!skipFetch) {
+    await safeFetchOrigin(directory);
+  }
+
+  const exists = await branchExists(directory, branch);
+  if (exists) {
+    await git(directory, `worktree add "${worktreePath}" "${branch}"`);
+  } else {
+    // Get the default branch from origin (main or master)
+    const defaultBranch = await getOriginDefaultBranch(directory);
+    // Base new branch on origin's default branch to avoid including unrelated commits from HEAD
+    // Use --no-track to prevent the new branch from tracking the start-point (main/master)
+    await git(directory, `worktree add --no-track -b "${branch}" "${worktreePath}" ${defaultBranch}`);
+  }
+  return { path: worktreePath, branch };
+}

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

@@ -5,11 +5,11 @@ import {
   projects,
 } from '../database.js';
 import { broadcastToProject } from '../websocket.js';
-import { WS_MESSAGE_TYPES } from '../../../shared/src/index.js';
+import { WS_MESSAGE_TYPES, DEFAULT_RESCHEDULE_DELAY_MINUTES } from '../../../shared/src/index.js';
 import { renderTemplatePrompt, getRootSession } from './templateTriggerService.js';
 import { setupGitForSession } from './gitSessionSetup.js';
 import { runSession } from './sessionManager.js';
-import { resolveAgentTypeFromModel } from './sessionProvider.js';
+import { resolveAgentTypeFromModel, resolveProviderMetadataFromModel } from './sessionProvider.js';
 
 // Maximum depth for recursive lane-entry template triggers
 export const MAX_LANE_TRIGGER_DEPTH = 5;
@@ -56,6 +56,8 @@ export async function determineWorkingDirectory(parentSession, project, gitOptio
       gitBranch: gitOptions.gitBranch || null,
       sessionId: gitOptions.sessionId,
       worktreeBasePath: project.worktreePath || null,
+      commitAttributionOverride:
+        resolveProviderMetadataFromModel(gitOptions.model)?.commitAttributionOverride ?? null,
     });
     return { workingDirectory: gitSetup.workingDirectory, gitWorktree: gitSetup.gitWorktree };
   }
@@ -190,6 +192,7 @@ export async function triggerOnEnterTemplate(sessionId, lane, options = {}) {
       gitMode: settings.gitMode,
       gitBranch: settings.gitBranch,
       sessionId: newSession.id,
+      model: settings.model,
     });
     if (gitWorktree) {
       sessions.update(newSession.id, { gitWorktree });
@@ -250,7 +253,7 @@ async function buildChildSessionFromPrompt(lane, session, depth) {
   if (lane.onEnterAutoRescheduleEnabled) {
     Object.assign(sessionUpdates, {
       autoRescheduleEnabled: true,
-      rescheduleDelayMinutes: lane.onEnterRescheduleDelayMinutes || 15,
+      rescheduleDelayMinutes: lane.onEnterRescheduleDelayMinutes || DEFAULT_RESCHEDULE_DELAY_MINUTES,
       rescheduleOnTokenLimit: lane.onEnterRescheduleOnTokenLimit ?? true,
       rescheduleOnServiceError: lane.onEnterRescheduleOnServiceError ?? true,
       maxRescheduleCount: lane.onEnterMaxRescheduleCount || null,

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

@@ -1,5 +1,10 @@
 import { spawn } from 'child_process';
 import path from 'path';
+import {
+  captureSpawnAttempt,
+  createCapturedSpawnProcess,
+  isE2ESpawnCaptureEnabled,
+} from './e2eSpawnCapture.js';
 
 /**
  * Get the directory containing the current Node.js executable.
@@ -42,6 +47,10 @@ export function createRobustEnv(baseEnv = process.env) {
 export function createClaudeCodeSpawner() {
   return (options) => {
     const { command, args, cwd, env, signal } = options;
+    if (isE2ESpawnCaptureEnabled()) {
+      captureSpawnAttempt('claude-code', options);
+      return createCapturedSpawnProcess('claude-code');
+    }
 
     // Replace 'node' with the absolute path to the current Node executable
     // This ensures we use the same Node that's running our app

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

@@ -126,8 +126,8 @@ export async function extractPrUrlIfNeeded(sessionId) {
   const session = sessions.getById(sessionId);
   if (!session) return;
 
-  // Skip if session already has a PR URL
-  if (session.prUrl) return;
+  // Skip if session already has a PR URL or the user cleared automatic PR linking.
+  if (session.prUrl || session.prUrlAutoLinkDisabled) return;
 
   // Extract PR URL from messages
   const prUrl = extractPrUrlFromMessages(sessionId);
@@ -145,7 +145,7 @@ export async function extractPrUrlIfNeeded(sessionId) {
     if (session.parentSessionId) {
       const rootId = sessions.getRootSessionId(sessionId);
       const root = rootId && rootId !== sessionId ? sessions.getById(rootId) : null;
-      if (root && !root.prUrl) {
+      if (root && !root.prUrl && !root.prUrlAutoLinkDisabled) {
         sessions.update(root.id, { prUrl });
         console.log(`[PrUrlService] Propagated PR URL from session ${sessionId} to root ${root.id}: ${prUrl}`);