Add self-review, auto-merge, failure recovery, and board enhancements

CLAUDE.md

@@ -161,7 +161,7 @@ Use `resolveModelString()` from `@automaker/model-resolver` to convert model ali
 
 - `haiku` → `claude-haiku-4-5`
 - `sonnet` → `claude-sonnet-4-20250514`
-- `opus` → `claude-opus-4-5-20251101`
+- `opus` → `claude-opus-4-6`
 
 ## Environment Variables
 

apps/server/src/index.ts

@@ -83,6 +83,7 @@ import { createNotificationsRoutes } from './routes/notifications/index.js';
 import { getNotificationService } from './services/notification-service.js';
 import { createEventHistoryRoutes } from './routes/event-history/index.js';
 import { getEventHistoryService } from './services/event-history-service.js';
+import { createDebugRoutes } from './routes/debug/index.js';
 
 // Load environment variables
 dotenv.config();
@@ -344,6 +345,7 @@ app.use('/api/pipeline', createPipelineRoutes(pipelineService));
 app.use('/api/ideation', createIdeationRoutes(events, ideationService, featureLoader));
 app.use('/api/notifications', createNotificationsRoutes(notificationService));
 app.use('/api/event-history', createEventHistoryRoutes(eventHistoryService, settingsService));
+app.use('/api/debug', createDebugRoutes(settingsService));
 
 // Create HTTP server
 const server = createServer(app);

apps/server/src/providers/claude-provider.ts

@@ -349,9 +349,9 @@ export class ClaudeProvider extends BaseProvider {
   getAvailableModels(): ModelDefinition[] {
     const models = [
       {
-        id: 'claude-opus-4-5-20251101',
-        name: 'Claude Opus 4.5',
-        modelString: 'claude-opus-4-5-20251101',
+        id: 'claude-opus-4-6',
+        name: 'Claude Opus 4.6',
+        modelString: 'claude-opus-4-6',
         provider: 'anthropic',
         description: 'Most capable Claude model',
         contextWindow: 200000,

apps/server/src/providers/provider-factory.ts

@@ -94,7 +94,7 @@ export class ProviderFactory {
   /**
    * Get the appropriate provider for a given model ID
    *
-   * @param modelId Model identifier (e.g., "claude-opus-4-5-20251101", "cursor-gpt-4o", "cursor-auto")
+   * @param modelId Model identifier (e.g., "claude-opus-4-6", "cursor-gpt-4o", "cursor-auto")
    * @param options Optional settings
    * @param options.throwOnDisconnected Throw error if provider is disconnected (default: true)
    * @returns Provider instance for the model

apps/server/src/routes/debug/index.ts

@@ -0,0 +1,88 @@
+import type { Request, Response } from 'express';
+import express from 'express';
+
+import { resolveModelString, resolvePhaseModel } from '@automaker/model-resolver';
+import { DEFAULT_MODELS } from '@automaker/types';
+import type { SettingsService } from '../../services/settings-service.js';
+
+/**
+ * Debug routes (authenticated)
+ *
+ * These endpoints are intended for local verification and troubleshooting.
+ * Do not return secrets.
+ */
+export function createDebugRoutes(settingsService: SettingsService) {
+  const router = express.Router();
+
+  /**
+   * Return the raw configured model keys and their resolved effective model IDs.
+   *
+   * This is the authoritative source for "which model will be used" because it uses
+   * the same resolver as agent runs.
+   */
+  router.get('/resolved-models', async (_req: Request, res: Response) => {
+    const settings = await settingsService.getGlobalSettings();
+
+    const defaultFeatureModelKey = settings.defaultFeatureModel?.model;
+
+    const phaseModels = settings.phaseModels || ({} as any);
+
+    const specGeneration = resolvePhaseModel(
+      phaseModels.specGenerationModel,
+      DEFAULT_MODELS.claude
+    );
+    const backlogPlanning = resolvePhaseModel(
+      phaseModels.backlogPlanningModel,
+      DEFAULT_MODELS.claude
+    );
+    const validation = resolvePhaseModel(phaseModels.validationModel, DEFAULT_MODELS.claude);
+
+    // Also show what the legacy "validationModel" / "enhancementModel" shortcuts are set to (if present)
+    const legacyValidationModelKey = (settings as any).validationModel;
+    const legacyEnhancementModelKey = (settings as any).enhancementModel;
+
+    const result = {
+      now: new Date().toISOString(),
+      defaults: {
+        DEFAULT_MODELS,
+      },
+      configured: {
+        defaultFeatureModelKey,
+        phaseModels: {
+          specGenerationModel: phaseModels.specGenerationModel,
+          backlogPlanningModel: phaseModels.backlogPlanningModel,
+          validationModel: phaseModels.validationModel,
+        },
+        legacy: {
+          validationModelKey: legacyValidationModelKey,
+          enhancementModelKey: legacyEnhancementModelKey,
+        },
+      },
+      resolved: {
+        defaultFeatureModel: {
+          key: defaultFeatureModelKey,
+          resolved: resolveModelString(defaultFeatureModelKey, DEFAULT_MODELS.claude),
+        },
+        phaseModels: {
+          specGenerationModel: specGeneration,
+          backlogPlanningModel: backlogPlanning,
+          validationModel: validation,
+        },
+        legacy: {
+          validationModel: {
+            key: legacyValidationModelKey,
+            resolved: resolveModelString(legacyValidationModelKey, DEFAULT_MODELS.claude),
+          },
+          enhancementModel: {
+            key: legacyEnhancementModelKey,
+            resolved: resolveModelString(legacyEnhancementModelKey, DEFAULT_MODELS.claude),
+          },
+        },
+      },
+    };
+
+    res.json(result);
+  });
+
+  return router;
+}

apps/server/src/routes/features/routes/update.ts

@@ -11,7 +11,7 @@ import { createLogger } from '@automaker/utils';
 const logger = createLogger('features/update');
 
 // Statuses that should trigger syncing to app_spec.txt
-const SYNC_TRIGGER_STATUSES: FeatureStatus[] = ['verified', 'completed'];
+const SYNC_TRIGGER_STATUSES: FeatureStatus[] = ['verified', 'done', 'completed'];
 
 export function createUpdateHandler(featureLoader: FeatureLoader) {
   return async (req: Request, res: Response): Promise<void> => {

apps/server/src/routes/worktree/routes/merge.ts

@@ -8,13 +8,8 @@
  */
 
 import type { Request, Response } from 'express';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { getErrorMessage, logError, isValidBranchName, execGitCommand } from '../common.js';
-import { createLogger } from '@automaker/utils';
-
-const execAsync = promisify(exec);
-const logger = createLogger('Worktree');
+import { getErrorMessage, logError } from '../common.js';
+import { mergeWorktreeBranch, cleanupWorktree } from '@automaker/git-utils';
 
 export function createMergeHandler() {
   return async (req: Request, res: Response): Promise<void> => {
@@ -38,102 +33,41 @@ export function createMergeHandler() {
       // Determine the target branch (default to 'main')
       const mergeTo = targetBranch || 'main';
 
-      // Validate source branch exists
-      try {
-        await execAsync(`git rev-parse --verify ${branchName}`, { cwd: projectPath });
-      } catch {
-        res.status(400).json({
-          success: false,
-          error: `Branch "${branchName}" does not exist`,
-        });
-        return;
-      }
-
-      // Validate target branch exists
-      try {
-        await execAsync(`git rev-parse --verify ${mergeTo}`, { cwd: projectPath });
-      } catch {
-        res.status(400).json({
-          success: false,
-          error: `Target branch "${mergeTo}" does not exist`,
-        });
-        return;
-      }
-
-      // Merge the feature branch into the target branch
-      const mergeCmd = options?.squash
-        ? `git merge --squash ${branchName}`
-        : `git merge ${branchName} -m "${options?.message || `Merge ${branchName} into ${mergeTo}`}"`;
-
-      try {
-        await execAsync(mergeCmd, { cwd: projectPath });
-      } catch (mergeError: unknown) {
-        // Check if this is a merge conflict
-        const err = mergeError as { stdout?: string; stderr?: string; message?: string };
-        const output = `${err.stdout || ''} ${err.stderr || ''} ${err.message || ''}`;
-        const hasConflicts =
-          output.includes('CONFLICT') || output.includes('Automatic merge failed');
+      // Merge using shared utility
+      const result = await mergeWorktreeBranch(projectPath, branchName, mergeTo, {
+        squash: options?.squash,
+        message: options?.message,
+      });
 
-        if (hasConflicts) {
-          // Return conflict-specific error message that frontend can detect
+      if (!result.success) {
+        if (result.hasConflicts) {
           res.status(409).json({
             success: false,
-            error: `Merge CONFLICT: Automatic merge of "${branchName}" into "${mergeTo}" failed. Please resolve conflicts manually.`,
+            error: result.error,
             hasConflicts: true,
           });
           return;
         }
 
-        // Re-throw non-conflict errors to be handled by outer catch
-        throw mergeError;
-      }
-
-      // If squash merge, need to commit
-      if (options?.squash) {
-        await execAsync(`git commit -m "${options?.message || `Merge ${branchName} (squash)`}"`, {
-          cwd: projectPath,
+        res.status(400).json({
+          success: false,
+          error: result.error,
         });
+        return;
       }
 
       // Optionally delete the worktree and branch after merging
-      let worktreeDeleted = false;
-      let branchDeleted = false;
+      let deleted: { worktreeDeleted: boolean; branchDeleted: boolean } | undefined;
 
       if (options?.deleteWorktreeAndBranch) {
-        // Remove the worktree
-        try {
-          await execGitCommand(['worktree', 'remove', worktreePath, '--force'], projectPath);
-          worktreeDeleted = true;
-        } catch {
-          // Try with prune if remove fails
-          try {
-            await execGitCommand(['worktree', 'prune'], projectPath);
-            worktreeDeleted = true;
-          } catch {
-            logger.warn(`Failed to remove worktree: ${worktreePath}`);
-          }
-        }
-
-        // Delete the branch (but not main/master)
-        if (branchName !== 'main' && branchName !== 'master') {
-          if (!isValidBranchName(branchName)) {
-            logger.warn(`Invalid branch name detected, skipping deletion: ${branchName}`);
-          } else {
-            try {
-              await execGitCommand(['branch', '-D', branchName], projectPath);
-              branchDeleted = true;
-            } catch {
-              logger.warn(`Failed to delete branch: ${branchName}`);
-            }
-          }
-        }
+        deleted = await cleanupWorktree(projectPath, worktreePath, branchName);
       }
 
       res.json({
         success: true,
         mergedBranch: branchName,
         targetBranch: mergeTo,
-        deleted: options?.deleteWorktreeAndBranch ? { worktreeDeleted, branchDeleted } : undefined,
+        deleted,
       });
     } catch (error) {
       logError(error, 'Merge worktree failed');