rafcode 2.4.0 → 2.4.1-0

package/src/commands/plan.ts

@@ -1,6 +1,5 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as crypto from 'node:crypto';
 import { Command } from 'commander';
 import { ProjectManager } from '../core/project-manager.js';
 import { ClaudeRunner } from '../core/claude-runner.js';
@@ -16,10 +15,7 @@ import {
   resolveModelOption,
 } from '../utils/validation.js';
 import { logger } from '../utils/logger.js';
-import { getWorktreeDefault, getModel, getModelShortName, getDisplayConfig, getPricingConfig, getSyncMainBranch } from '../utils/config.js';
-import { TokenTracker } from '../utils/token-tracker.js';
-import { parseSessionById } from '../utils/session-parser.js';
-import { formatTokenTotalSummary, TokenSummaryOptions } from '../utils/terminal-symbols.js';
+import { getWorktreeDefault, getModel, getModelShortName, getSyncMainBranch } from '../utils/config.js';
 import { generateProjectNames } from '../utils/name-generator.js';
 import { pickProjectName } from '../ui/name-picker.js';
 import {
@@ -289,25 +285,17 @@ async function runPlanCommand(projectName?: string, model?: string, autoMode: bo
     worktreeMode,
   });
 
-  // Generate session ID for token tracking
-  const sessionId = crypto.randomUUID();
-  const sessionCwd = worktreePath ?? process.cwd();
-
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
       // Run Claude session in the worktree root if in worktree mode
       cwd: worktreePath ?? undefined,
-      sessionId,
     });
 
     if (exitCode !== 0) {
       logger.warn(`Claude exited with code ${exitCode}`);
     }
 
-    // Parse session file and display token usage summary
-    displayPlanSessionTokenSummary(sessionId, sessionCwd);
-
     // Check for created plan files
     const plansDir = getPlansDir(projectPath);
     const planFiles = fs.existsSync(plansDir)
@@ -604,25 +592,17 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
     worktreeMode,
   });
 
-  // Generate session ID for token tracking
-  const sessionId = crypto.randomUUID();
-  const sessionCwd = worktreePath ?? process.cwd();
-
   try {
     const exitCode = await claudeRunner.runInteractive(systemPrompt, userMessage, {
       dangerouslySkipPermissions: autoMode,
       // Run Claude session in the worktree root if in worktree mode
       cwd: worktreePath ?? undefined,
-      sessionId,
     });
 
     if (exitCode !== 0) {
       logger.warn(`Claude exited with code ${exitCode}`);
     }
 
-    // Parse session file and display token usage summary
-    displayPlanSessionTokenSummary(sessionId, sessionCwd);
-
     // Check for new plan files
     const allPlanFiles = fs.existsSync(plansDir)
       ? fs.readdirSync(plansDir).filter((f) => f.endsWith('.md')).sort()
@@ -647,11 +627,9 @@ async function runAmendCommand(identifier: string, model?: string, autoMode: boo
         logger.info(`  - plans/${planFile}`);
       }
 
-      // Commit planning artifacts (input.md, decisions.md, and new plan files)
-      const newPlanPaths = newPlanFiles.map(f => path.join(plansDir, f));
+      // Commit planning artifacts (input.md, decisions.md only — plan files committed during execution)
       await commitPlanningArtifacts(projectPath, {
         cwd: worktreePath ?? undefined,
-        additionalFiles: newPlanPaths,
         isAmend: true,
       });
 
@@ -698,44 +676,3 @@ ${taskList}
 # Describe what you want to add below:
 `;
 }
-
-/**
- * Display token usage summary for a plan/amend session.
- * Parses the Claude session file and displays formatted usage data.
- */
-function displayPlanSessionTokenSummary(sessionId: string, cwd: string): void {
-  const result = parseSessionById(sessionId, cwd);
-
-  if (!result.success) {
-    // Session file not found or couldn't be parsed - just log debug and continue
-    logger.debug(`Could not parse session file: ${result.error}`);
-    return;
-  }
-
-  // Check if there's any usage data
-  const totalTokens = result.usage.inputTokens + result.usage.outputTokens;
-  if (totalTokens === 0) {
-    logger.debug('No token usage data found in session file');
-    return;
-  }
-
-  // Create tracker and add the session as a single "task"
-  const pricingConfig = getPricingConfig();
-  const tracker = new TokenTracker(pricingConfig);
-  const entry = tracker.addTask('plan', [result.usage]);
-
-  // Get display options
-  const displayConfig = getDisplayConfig();
-  const options: TokenSummaryOptions = {
-    showCacheTokens: displayConfig.showCacheTokens,
-    showRateLimitEstimate: displayConfig.showRateLimitEstimate,
-    rateLimitPercentage: displayConfig.showRateLimitEstimate
-      ? tracker.calculateRateLimitPercentage(entry.cost.totalCost)
-      : undefined,
-  };
-
-  // Display the summary
-  logger.newline();
-  const summary = formatTokenTotalSummary(result.usage, entry.cost, options);
-  console.log(summary);
-}

package/src/core/claude-runner.ts

@@ -31,12 +31,6 @@ export interface ClaudeRunnerOptions {
    * Claude will still ask planning interview questions.
    */
   dangerouslySkipPermissions?: boolean;
-  /**
-   * Session ID for Claude CLI. When provided, passed as --session-id to enable
-   * locating the session file after the session ends for token tracking.
-   * Only used in interactive mode (runInteractive).
-   */
-  sessionId?: string;
   /**
    * Path to the outcome file. When provided, enables completion detection:
    * - Monitors stdout for completion markers (<promise>COMPLETE/FAILED</promise>)
@@ -286,7 +280,7 @@ export class ClaudeRunner {
     userMessage: string,
     options: ClaudeRunnerOptions = {}
   ): Promise<number> {
-    const { cwd = process.cwd(), dangerouslySkipPermissions = false, sessionId } = options;
+    const { cwd = process.cwd(), dangerouslySkipPermissions = false } = options;
 
     return new Promise((resolve) => {
       const args = ['--model', this.model];
@@ -296,11 +290,6 @@ export class ClaudeRunner {
         args.push('--dangerously-skip-permissions');
       }
 
-      // Add --session-id if provided (for token tracking)
-      if (sessionId) {
-        args.push('--session-id', sessionId);
-      }
-
       // System instructions via --append-system-prompt
       args.push('--append-system-prompt', systemPrompt);
 

package/src/core/worktree.ts

@@ -442,6 +442,11 @@ export interface SyncMainBranchResult {
   error?: string;
 }
 
+export interface RebaseResult {
+  success: boolean;
+  error?: string;
+}
+
 /**
  * Detect the main branch name from the remote.
  * Uses refs/remotes/origin/HEAD, falling back to main/master.
@@ -531,7 +536,7 @@ export function pullMainBranch(cwd?: string): SyncMainBranchResult {
         });
         logger.debug(`Fetched origin/${mainBranch} (local ${mainBranch} diverged, not updated)`);
         return {
-          success: true,
+          success: false,
           mainBranch,
           hadChanges: false,
           error: `Local ${mainBranch} has diverged from origin, not updated`,
@@ -662,3 +667,34 @@ export function pushMainBranch(cwd?: string): SyncMainBranchResult {
     };
   }
 }
+
+/**
+ * Rebase the current branch onto the main branch.
+ * If the rebase fails with conflicts, aborts the rebase and returns failure.
+ *
+ * @param mainBranch - The main branch name to rebase onto (e.g., 'main' or 'master')
+ * @param cwd - The directory to run git commands in (defaults to current directory)
+ */
+export function rebaseOntoMain(mainBranch: string, cwd: string): RebaseResult {
+  try {
+    execSync(`git rebase ${mainBranch}`, {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      cwd,
+    });
+    return { success: true };
+  } catch (error) {
+    // Abort the failed rebase to restore clean state
+    try {
+      execSync('git rebase --abort', {
+        encoding: 'utf-8',
+        stdio: 'pipe',
+        cwd,
+      });
+    } catch {
+      // Ignore abort errors
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    return { success: false, error: msg };
+  }
+}

package/src/prompts/amend.ts

@@ -135,9 +135,10 @@ After interviewing the user about all NEW tasks, create plan files starting from
 - ${projectPath}/plans/${encodeTaskId(nextTaskNumber + 1)}-task-name.md
 - etc.
 
-Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter format uses only a closing \`---\` delimiter (no opening delimiter):
+Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter uses standard YAML format with opening and closing \`---\` delimiters:
 
 \`\`\`markdown
+---
 effort: medium
 ---
 # Task: [Task Name]
@@ -186,6 +187,7 @@ The \`effort\` field is REQUIRED in every plan file. It indicates task complexit
 
 Optionally, you can add an explicit \`model\` field to override the effort-based model selection:
 \`\`\`markdown
+---
 effort: medium
 model: opus
 ---

package/src/prompts/planning.ts

@@ -80,9 +80,10 @@ After interviewing the user about all tasks, create plan files in the plans fold
 - ${projectPath}/plans/02-task-name.md
 - etc.
 
-Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter format uses only a closing \`---\` delimiter (no opening delimiter):
+Each plan file MUST have Obsidian-style frontmatter at the top, before the \`# Task:\` heading. The frontmatter uses standard YAML format with opening and closing \`---\` delimiters:
 
 \`\`\`markdown
+---
 effort: medium
 ---
 # Task: [Task Name]
@@ -128,6 +129,7 @@ The \`effort\` field is REQUIRED in every plan file. It indicates task complexit
 
 Optionally, you can add an explicit \`model\` field to override the effort-based model selection:
 \`\`\`markdown
+---
 effort: medium
 model: opus
 ---

package/src/utils/frontmatter.ts

@@ -26,10 +26,20 @@ export interface FrontmatterParseResult {
 /**
  * Parse Obsidian-style frontmatter from plan file content.
  *
- * Format: `key: value` lines at the top of the file, terminated by a `---` line.
- * There is NO opening `---` delimiter — just properties followed by `---`.
+ * Supports two formats:
+ * 1. Standard format (preferred): `---` delimiter at the top and bottom
+ * 2. Legacy format (backward compatibility): properties followed by closing `---` only
  *
- * Example:
+ * Standard format example:
+ * ```
+ * ---
+ * effort: medium
+ * model: sonnet
+ * ---
+ * # Task: ...
+ * ```
+ *
+ * Legacy format example:
  * ```
  * effort: medium
  * model: sonnet
@@ -50,15 +60,35 @@ export function parsePlanFrontmatter(content: string): FrontmatterParseResult {
     warnings: [],
   };
 
-  // Find the closing `---` delimiter
-  const delimiterIndex = content.indexOf('---');
-  if (delimiterIndex === -1) {
-    // No delimiter found - no frontmatter
-    return result;
-  }
+  const trimmedContent = content.trimStart();
 
-  // Extract the frontmatter section (everything before the delimiter)
-  const frontmatterSection = content.substring(0, delimiterIndex);
+  let frontmatterSection: string;
+
+  if (trimmedContent.startsWith('---')) {
+    // Standard format: ---\nkey: value\n---
+    const afterOpener = trimmedContent.substring(3);
+    // Skip the rest of the opener line (handles "---\n" or "--- \n")
+    const openerEnd = afterOpener.indexOf('\n');
+    if (openerEnd === -1) {
+      // No newline after opening delimiter - no valid frontmatter
+      return result;
+    }
+    const rest = afterOpener.substring(openerEnd + 1);
+    const closerIndex = rest.indexOf('---');
+    if (closerIndex === -1) {
+      // No closing delimiter - no valid frontmatter
+      return result;
+    }
+    frontmatterSection = rest.substring(0, closerIndex);
+  } else {
+    // Legacy format: key: value\n---
+    const delimiterIndex = content.indexOf('---');
+    if (delimiterIndex === -1) {
+      // No delimiter found - no frontmatter
+      return result;
+    }
+    frontmatterSection = content.substring(0, delimiterIndex);
+  }
 
   // Parse key: value lines
   const lines = frontmatterSection.split('\n');

package/src/utils/name-generator.ts

@@ -3,7 +3,9 @@ import { logger } from './logger.js';
 import { sanitizeProjectName } from './validation.js';
 import { getModel } from './config.js';
 
-const NAME_GENERATION_PROMPT = `Generate a short, punchy, creative project name (1-3 words, kebab-case).
+const NAME_GENERATION_PROMPT = `Output ONLY the kebab-case name. No introduction, no explanation, no quotes.
+
+Generate a short, punchy, creative project name (1-3 words, kebab-case).
 
 Be creative! Use metaphors, analogies, or evocative words that capture the SPIRIT of the project.
 Don't literally describe what it does - make it memorable and fun.
@@ -15,26 +17,15 @@ Good examples:
 - Refactoring → 'spring-cleaning', 'phoenix', 'makeover'
 - New feature → 'moonshot', 'secret-sauce', 'magic-wand'
 
-Output ONLY the kebab-case name. No quotes, no explanation.
-
 Project description:`;
 
-const MULTI_NAME_GENERATION_PROMPT = `Generate 5 creative project names for the description below.
-
-IMPORTANT: Each name should use a DIFFERENT naming style:
-1. **Metaphorical** - Use a metaphor or analogy (e.g., 'phoenix', 'lighthouse', 'compass')
-2. **Fun/Playful** - Make it fun or quirky (e.g., 'turbo-boost', 'magic-beans', 'ninja-move')
-3. **Action-oriented** - Focus on what it does with flair (e.g., 'bug-squasher', 'speed-demon', 'data-whisperer')
-4. **Abstract** - Use abstract/poetic concepts (e.g., 'horizon', 'cascade', 'catalyst')
-5. **Cultural reference** - Reference pop culture, mythology, or literature (e.g., 'atlas', 'merlin', 'gandalf')
+const MULTI_NAME_GENERATION_PROMPT = `Output EXACTLY 5 project names, one per line. Do NOT include any introduction, explanation, preamble, numbering, or quotes.
 
 Rules:
-- Each name should be 1-3 words in kebab-case
-- Names must be lowercase with hyphens only
+- Each name: 1-3 words, kebab-case, lowercase with hyphens only
+- Use varied styles: metaphorical, playful, action-oriented, abstract, cultural reference
 - Make them memorable and evocative
-- If the project has many unrelated tasks, prefer abstract/metaphorical/fun names over descriptive ones
-
-Output format: ONLY output 5 names, one per line, no numbers, no explanations, no quotes.
+- For projects with many unrelated tasks, prefer abstract/metaphorical names
 
 Project description:`;
 

package/src/utils/terminal-symbols.ts

@@ -177,7 +177,7 @@ function formatTokenLine(
   indent: string = '  ',
   options: TokenSummaryOptions = {}
 ): string {
-  const { showCacheTokens = true, showRateLimitEstimate = false, rateLimitPercentage } = options;
+  const { showCacheTokens = true, showRateLimitEstimate = true, rateLimitPercentage } = options;
   const parts: string[] = [];
   const tokenPart = `${formatNumber(usage.inputTokens)} in / ${formatNumber(usage.outputTokens)} out`;
   parts.push(prefix ? `${prefix}: ${tokenPart}` : `Tokens: ${tokenPart}`);
@@ -255,7 +255,7 @@ export function formatTokenTotalSummary(
   cost: CostBreakdown,
   options: TokenSummaryOptions = {}
 ): string {
-  const { showCacheTokens = true, showRateLimitEstimate = false, rateLimitPercentage } = options;
+  const { showCacheTokens = true, showRateLimitEstimate = true, rateLimitPercentage } = options;
   const lines: string[] = [];
   const divider = '── Token Usage Summary ──────────────────';
   lines.push(divider);

package/tests/unit/commit-planning-artifacts-worktree.test.ts

@@ -162,13 +162,9 @@ describe('commitPlanningArtifacts - worktree integration', () => {
       '# Task: New Task'
     );
 
-    // Call commitPlanningArtifacts with additional files
-    const additionalFiles = [
-      path.join(wtProjectPath, 'plans', '02-new-task.md'),
-    ];
+    // Call commitPlanningArtifacts (plan files not included in amend commit)
     await commitPlanningArtifacts(wtProjectPath, {
       cwd: worktreePath,
-      additionalFiles,
       isAmend: true,
     });
 
@@ -176,11 +172,11 @@ describe('commitPlanningArtifacts - worktree integration', () => {
     const lastMsg = getLastCommitMessage(worktreePath);
     expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
 
-    // Verify all three files are in the commit
+    // Verify only input.md and decisions.md are in the commit (not plan files)
     const committedFiles = getLastCommitFiles(worktreePath);
     expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
     expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
-    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+    expect(committedFiles).not.toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
   });
 
   it('should commit after worktree recreation from branch', async () => {
@@ -234,13 +230,9 @@ describe('commitPlanningArtifacts - worktree integration', () => {
       '# Task: New Task'
     );
 
-    // Call commitPlanningArtifacts with worktree cwd
-    const additionalFiles = [
-      path.join(recreatedProjectPath, 'plans', '02-new-task.md'),
-    ];
+    // Call commitPlanningArtifacts (plan files not included in amend commit)
     await commitPlanningArtifacts(recreatedProjectPath, {
       cwd: recreatedWtPath,
-      additionalFiles,
       isAmend: true,
     });
 
@@ -248,11 +240,11 @@ describe('commitPlanningArtifacts - worktree integration', () => {
     const lastMsg = getLastCommitMessage(recreatedWtPath);
     expect(lastMsg).toMatch(/RAF\[aatest\] Amend: my-project/);
 
-    // Verify all files are in the commit
+    // Verify only input.md and decisions.md are in the commit (not plan files)
     const committedFiles = getLastCommitFiles(recreatedWtPath);
     expect(committedFiles).toContain(`RAF/${projectFolder}/input.md`);
     expect(committedFiles).toContain(`RAF/${projectFolder}/decisions.md`);
-    expect(committedFiles).toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
+    expect(committedFiles).not.toContain(`RAF/${projectFolder}/plans/02-new-task.md`);
   });
 
   it('should work when only some files have changed', async () => {

package/tests/unit/commit-planning-artifacts.test.ts

@@ -252,7 +252,7 @@ describe('commitPlanningArtifacts', () => {
     );
   });
 
-  it('should stage additional files when provided', async () => {
+  it('should not stage plan files in amend mode', async () => {
     mockExecSync.mockImplementation((cmd: unknown) => {
       const cmdStr = cmd as string;
       if (cmdStr.includes('rev-parse')) {
@@ -262,32 +262,24 @@ describe('commitPlanningArtifacts', () => {
         return '';
       }
       if (cmdStr.includes('git diff --cached')) {
-        return 'RAF/aaaaar-decision-vault/input.md\nRAF/aaaaar-decision-vault/plans/04-new-task.md\n';
+        return 'RAF/aaaaar-decision-vault/input.md\n';
       }
       return '';
     });
 
-    const additionalFiles = [
-      '/Users/test/RAF/aaaaar-decision-vault/plans/04-new-task.md',
-      '/Users/test/RAF/aaaaar-decision-vault/plans/05-another-task.md',
-    ];
-
     await commitPlanningArtifacts('/Users/test/RAF/aaaaar-decision-vault', {
-      additionalFiles,
       isAmend: true,
     });
 
-    // Verify git add called for all 4 files (input, decisions, 2 plans)
+    // Verify git add called for only 2 files (input, decisions)
     const addCalls = mockExecSync.mock.calls.filter(
       (call) => (call[0] as string).includes('git add')
     );
-    expect(addCalls.length).toBe(4);
+    expect(addCalls.length).toBe(2);
 
     const addCmds = addCalls.map((c) => c[0] as string);
     expect(addCmds.some((cmd) => cmd.includes('input.md'))).toBe(true);
     expect(addCmds.some((cmd) => cmd.includes('decisions.md'))).toBe(true);
-    expect(addCmds.some((cmd) => cmd.includes('04-new-task.md'))).toBe(true);
-    expect(addCmds.some((cmd) => cmd.includes('05-another-task.md'))).toBe(true);
   });
 
   it('should pass cwd to isGitRepo for worktree support', async () => {

package/tests/unit/config-command.test.ts

@@ -50,6 +50,18 @@ describe('Config Command', () => {
       expect(resetOption).toBeDefined();
     });
 
+    it('should have a --get option', () => {
+      const cmd = createConfigCommand();
+      const getOption = cmd.options.find((o) => o.long === '--get');
+      expect(getOption).toBeDefined();
+    });
+
+    it('should have a --set option', () => {
+      const cmd = createConfigCommand();
+      const setOption = cmd.options.find((o) => o.long === '--set');
+      expect(setOption).toBeDefined();
+    });
+
     it('should register in a parent program', () => {
       const program = new Command();
       program.addCommand(createConfigCommand());
@@ -239,4 +251,162 @@ describe('Config Command', () => {
       expect(config2.timeout).toBe(120);
     });
   });
+
+  describe('--get flag', () => {
+    it('should return full config when no key is provided', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ timeout: 120 }, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.timeout).toBe(120);
+      expect(config.models.execute).toBe(DEFAULT_CONFIG.models.execute);
+
+      // Verify full config has all expected top-level keys
+      expect(config).toHaveProperty('models');
+      expect(config).toHaveProperty('effortMapping');
+      expect(config).toHaveProperty('timeout');
+    });
+
+    it('should return specific value for dot-notation key', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ models: { plan: 'sonnet' } }, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.models.plan).toBe('sonnet');
+    });
+
+    it('should handle nested keys', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ display: { showRateLimitEstimate: false } }, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.display.showRateLimitEstimate).toBe(false);
+    });
+
+    it('should handle deeply nested pricing keys', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+      fs.writeFileSync(configPath, JSON.stringify({ pricing: { opus: { inputPerMTok: 20 } } }, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.pricing.opus.inputPerMTok).toBe(20);
+    });
+  });
+
+  describe('--set flag', () => {
+    it('should set a string value', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      // Start with empty config
+      expect(fs.existsSync(configPath)).toBe(false);
+
+      // Simulate setting models.plan to sonnet
+      const userConfig: Record<string, unknown> = {};
+      const keys = 'models.plan'.split('.');
+      let current: Record<string, unknown> = userConfig;
+      for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i]!;
+        current[key] = {};
+        current = current[key] as Record<string, unknown>;
+      }
+      current[keys[keys.length - 1]!] = 'sonnet';
+
+      fs.writeFileSync(configPath, JSON.stringify(userConfig, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.models.plan).toBe('sonnet');
+    });
+
+    it('should set a number value', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      const userConfig = { timeout: 120 };
+      fs.writeFileSync(configPath, JSON.stringify(userConfig, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.timeout).toBe(120);
+    });
+
+    it('should set a boolean value', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      const userConfig = { autoCommit: false };
+      fs.writeFileSync(configPath, JSON.stringify(userConfig, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.autoCommit).toBe(false);
+    });
+
+    it('should remove key when value matches default', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      // Set a non-default value first
+      fs.writeFileSync(configPath, JSON.stringify({ models: { plan: 'sonnet' } }, null, 2));
+      let config = resolveConfig(configPath);
+      expect(config.models.plan).toBe('sonnet');
+
+      // Now set back to default (opus)
+      fs.writeFileSync(configPath, JSON.stringify({}, null, 2));
+      config = resolveConfig(configPath);
+      expect(config.models.plan).toBe(DEFAULT_CONFIG.models.plan);
+    });
+
+    it('should remove empty parent objects after key removal', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      // Start with a models override
+      const userConfig = { models: { plan: 'sonnet' } };
+      fs.writeFileSync(configPath, JSON.stringify(userConfig, null, 2));
+
+      // Remove the override (simulating setting to default)
+      fs.writeFileSync(configPath, JSON.stringify({}, null, 2));
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      const parsed = JSON.parse(content);
+
+      // Should be empty object
+      expect(Object.keys(parsed).length).toBe(0);
+    });
+
+    it('should validate config after modification', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      // Valid config
+      const validConfig = { models: { execute: 'sonnet' } };
+      fs.writeFileSync(configPath, JSON.stringify(validConfig, null, 2));
+      expect(() => validateConfig(validConfig)).not.toThrow();
+
+      // Invalid config
+      const invalidConfig = { models: { execute: 'invalid-model' } };
+      fs.writeFileSync(configPath, JSON.stringify(invalidConfig, null, 2));
+      expect(() => validateConfig(invalidConfig)).toThrow(ConfigValidationError);
+    });
+
+    it('should delete config file when it becomes empty', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      // Create a config file
+      fs.writeFileSync(configPath, JSON.stringify({ timeout: 120 }, null, 2));
+      expect(fs.existsSync(configPath)).toBe(true);
+
+      // Simulate removing all keys (setting everything to defaults)
+      fs.writeFileSync(configPath, JSON.stringify({}, null, 2));
+
+      // Check if file still exists (in the actual implementation, empty configs are deleted)
+      // For this test, we just verify the file operations work
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(JSON.parse(content)).toEqual({});
+    });
+
+    it('should handle nested value updates', () => {
+      const configPath = path.join(tempDir, 'raf.config.json');
+
+      // Set a nested value
+      const userConfig = { display: { showRateLimitEstimate: false } };
+      fs.writeFileSync(configPath, JSON.stringify(userConfig, null, 2));
+
+      const config = resolveConfig(configPath);
+      expect(config.display.showRateLimitEstimate).toBe(false);
+      expect(config.display.showCacheTokens).toBe(DEFAULT_CONFIG.display.showCacheTokens);
+    });
+  });
 });