rafcode 2.4.1-0 → 2.5.0

package/src/utils/token-tracker.ts

@@ -1,12 +1,7 @@
-import { UsageData, PricingConfig } from '../types/config.js';
-import { resolveModelPricingCategory, getPricingConfig, getRateLimitWindowConfig } from './config.js';
+import { UsageData } from '../types/config.js';
 
 /** Cost breakdown for a single task or accumulated total. */
 export interface CostBreakdown {
-  inputCost: number;
-  outputCost: number;
-  cacheReadCost: number;
-  cacheCreateCost: number;
   totalCost: number;
 }
 
@@ -25,23 +20,11 @@ export interface TaskUsageEntry {
  * Sum multiple CostBreakdown objects into a single total.
  */
 export function sumCostBreakdowns(costs: CostBreakdown[]): CostBreakdown {
-  const result: CostBreakdown = {
-    inputCost: 0,
-    outputCost: 0,
-    cacheReadCost: 0,
-    cacheCreateCost: 0,
-    totalCost: 0,
-  };
-
+  let totalCost = 0;
   for (const cost of costs) {
-    result.inputCost += cost.inputCost;
-    result.outputCost += cost.outputCost;
-    result.cacheReadCost += cost.cacheReadCost;
-    result.cacheCreateCost += cost.cacheCreateCost;
-    result.totalCost += cost.totalCost;
+    totalCost += cost.totalCost;
   }
-
-  return result;
+  return { totalCost };
 }
 
 /**
@@ -55,6 +38,7 @@ export function accumulateUsage(attempts: UsageData[]): UsageData {
     cacheReadInputTokens: 0,
     cacheCreationInputTokens: 0,
     modelUsage: {},
+    totalCostUsd: 0,
   };
 
   for (const attempt of attempts) {
@@ -71,39 +55,39 @@ export function accumulateUsage(attempts: UsageData[]): UsageData {
         existing.outputTokens += modelUsage.outputTokens;
         existing.cacheReadInputTokens += modelUsage.cacheReadInputTokens;
         existing.cacheCreationInputTokens += modelUsage.cacheCreationInputTokens;
+        existing.costUsd += modelUsage.costUsd;
       } else {
         result.modelUsage[modelId] = { ...modelUsage };
       }
     }
+
+    // Sum totalCostUsd across attempts
+    result.totalCostUsd += attempt.totalCostUsd;
   }
 
   return result;
 }
 
 /**
- * Accumulates token usage across multiple task executions and calculates costs
- * using configurable per-model pricing.
+ * Accumulates token usage across multiple task executions using Claude-provided cost data.
  */
 export class TokenTracker {
   private entries: TaskUsageEntry[] = [];
-  private pricingConfig: PricingConfig;
 
-  constructor(pricingConfig?: PricingConfig) {
-    this.pricingConfig = pricingConfig ?? getPricingConfig();
+  constructor() {
+    // No pricing config needed - costs come from Claude
   }
 
   /**
    * Record usage data from a completed task.
    * Accepts an array of UsageData (one per attempt) and accumulates them.
-   * Cost is calculated per-attempt to avoid underreporting when some attempts
-   * have modelUsage and others only have aggregate fields.
+   * Costs are summed from Claude-provided totalCostUsd values.
    */
   addTask(taskId: string, attempts: UsageData[]): TaskUsageEntry {
     const usage = accumulateUsage(attempts);
-    // Calculate cost per-attempt, then sum. This ensures attempts with only
-    // aggregate fields use sonnet fallback pricing independently.
-    const perAttemptCosts = attempts.map((attempt) => this.calculateCost(attempt));
-    const cost = sumCostBreakdowns(perAttemptCosts);
+    // Sum costs from Claude-provided totalCostUsd
+    const totalCost = attempts.reduce((sum, attempt) => sum + attempt.totalCostUsd, 0);
+    const cost: CostBreakdown = { totalCost };
     const entry: TaskUsageEntry = { taskId, usage, cost, attempts };
     this.entries.push(entry);
     return entry;
@@ -126,12 +110,9 @@ export class TokenTracker {
       cacheReadInputTokens: 0,
       cacheCreationInputTokens: 0,
       modelUsage: {},
+      totalCostUsd: 0,
     };
     const totalCost: CostBreakdown = {
-      inputCost: 0,
-      outputCost: 0,
-      cacheReadCost: 0,
-      cacheCreateCost: 0,
       totalCost: 0,
     };
 
@@ -140,6 +121,7 @@ export class TokenTracker {
       totalUsage.outputTokens += entry.usage.outputTokens;
       totalUsage.cacheReadInputTokens += entry.usage.cacheReadInputTokens;
       totalUsage.cacheCreationInputTokens += entry.usage.cacheCreationInputTokens;
+      totalUsage.totalCostUsd += entry.usage.totalCostUsd;
 
       // Merge per-model usage
       for (const [modelId, modelUsage] of Object.entries(entry.usage.modelUsage)) {
@@ -149,92 +131,16 @@ export class TokenTracker {
           existing.outputTokens += modelUsage.outputTokens;
           existing.cacheReadInputTokens += modelUsage.cacheReadInputTokens;
           existing.cacheCreationInputTokens += modelUsage.cacheCreationInputTokens;
+          existing.costUsd += modelUsage.costUsd;
         } else {
           totalUsage.modelUsage[modelId] = { ...modelUsage };
         }
       }
 
-      totalCost.inputCost += entry.cost.inputCost;
-      totalCost.outputCost += entry.cost.outputCost;
-      totalCost.cacheReadCost += entry.cost.cacheReadCost;
-      totalCost.cacheCreateCost += entry.cost.cacheCreateCost;
       totalCost.totalCost += entry.cost.totalCost;
     }
 
     return { usage: totalUsage, cost: totalCost };
   }
 
-  /**
-   * Calculate cost for a given UsageData using per-model pricing.
-   * Uses per-model breakdown when available, falls back to aggregate with sonnet pricing.
-   */
-  calculateCost(usage: UsageData): CostBreakdown {
-    const result: CostBreakdown = {
-      inputCost: 0,
-      outputCost: 0,
-      cacheReadCost: 0,
-      cacheCreateCost: 0,
-      totalCost: 0,
-    };
-
-    const modelEntries = Object.entries(usage.modelUsage);
-
-    if (modelEntries.length > 0) {
-      // Use per-model breakdown for accurate pricing
-      for (const [modelId, modelUsage] of modelEntries) {
-        const category = resolveModelPricingCategory(modelId);
-        const pricing = this.pricingConfig[category ?? 'sonnet'];
-
-        result.inputCost += (modelUsage.inputTokens / 1_000_000) * pricing.inputPerMTok;
-        result.outputCost += (modelUsage.outputTokens / 1_000_000) * pricing.outputPerMTok;
-        result.cacheReadCost += (modelUsage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
-        result.cacheCreateCost += (modelUsage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
-      }
-    } else {
-      // Fallback: use aggregate totals with sonnet pricing
-      const pricing = this.pricingConfig.sonnet;
-      result.inputCost = (usage.inputTokens / 1_000_000) * pricing.inputPerMTok;
-      result.outputCost = (usage.outputTokens / 1_000_000) * pricing.outputPerMTok;
-      result.cacheReadCost = (usage.cacheReadInputTokens / 1_000_000) * pricing.cacheReadPerMTok;
-      result.cacheCreateCost = (usage.cacheCreationInputTokens / 1_000_000) * pricing.cacheCreatePerMTok;
-    }
-
-    result.totalCost = result.inputCost + result.outputCost + result.cacheReadCost + result.cacheCreateCost;
-    return result;
-  }
-
-  /**
-   * Calculate the 5h rate limit window percentage for a given cost.
-   * Converts cost to Sonnet-equivalent tokens using the configured Sonnet pricing,
-   * then divides by the configured cap.
-   *
-   * @param totalCost - The total cost in dollars
-   * @param sonnetTokenCap - Optional override for the Sonnet-equivalent token cap (defaults to config value)
-   * @returns The percentage of the 5h window consumed (0-100+)
-   */
-  calculateRateLimitPercentage(totalCost: number, sonnetTokenCap?: number): number {
-    if (totalCost === 0) return 0;
-
-    // Get the configured cap or use the provided override
-    const cap = sonnetTokenCap ?? getRateLimitWindowConfig().sonnetTokenCap;
-
-    // Calculate the average Sonnet cost per token
-    // Using the average of input and output pricing (simplified approach)
-    const sonnetPricing = this.pricingConfig.sonnet;
-    const avgSonnetCostPerToken = (sonnetPricing.inputPerMTok + sonnetPricing.outputPerMTok) / 2 / 1_000_000;
-
-    // Convert cost to Sonnet-equivalent tokens
-    const sonnetEquivalentTokens = totalCost / avgSonnetCostPerToken;
-
-    // Calculate percentage
-    return (sonnetEquivalentTokens / cap) * 100;
-  }
-
-  /**
-   * Get the cumulative 5h window percentage across all recorded tasks.
-   */
-  getCumulativeRateLimitPercentage(sonnetTokenCap?: number): number {
-    const totals = this.getTotals();
-    return this.calculateRateLimitPercentage(totals.cost.totalCost, sonnetTokenCap);
-  }
 }

package/tests/unit/claude-runner.test.ts

@@ -736,6 +736,7 @@ describe('ClaudeRunner', () => {
         outputTokens: 500,
         cacheReadInputTokens: 200,
         cacheCreationInputTokens: 100,
+        costUsd: 0,
       });
     });
 

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

@@ -277,18 +277,10 @@ describe('Config Command', () => {
 
     it('should handle nested keys', () => {
       const configPath = path.join(tempDir, 'raf.config.json');
-      fs.writeFileSync(configPath, JSON.stringify({ display: { showRateLimitEstimate: false } }, null, 2));
+      fs.writeFileSync(configPath, JSON.stringify({ display: { showCacheTokens: 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);
+      expect(config.display.showCacheTokens).toBe(false);
     });
   });
 
@@ -401,12 +393,11 @@ describe('Config Command', () => {
       const configPath = path.join(tempDir, 'raf.config.json');
 
       // Set a nested value
-      const userConfig = { display: { showRateLimitEstimate: false } };
+      const userConfig = { display: { showCacheTokens: 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);
+      expect(config.display.showCacheTokens).toBe(false);
     });
   });
 });

package/tests/unit/config.test.ts

@@ -25,9 +25,6 @@ import {
   saveConfig,
   renderCommitMessage,
   isValidModelName,
-  resolveModelPricingCategory,
-  getPricing,
-  getPricingConfig,
 } from '../../src/utils/config.js';
 import { DEFAULT_CONFIG } from '../../src/types/config.js';
 
@@ -538,97 +535,6 @@ describe('Config', () => {
     });
   });
 
-  describe('validateConfig - pricing', () => {
-    it('should accept valid pricing config', () => {
-      expect(() => validateConfig({
-        pricing: {
-          opus: { inputPerMTok: 15, outputPerMTok: 75 },
-        },
-      })).not.toThrow();
-    });
-
-    it('should accept partial pricing override', () => {
-      expect(() => validateConfig({
-        pricing: {
-          haiku: { outputPerMTok: 4 },
-        },
-      })).not.toThrow();
-    });
-
-    it('should reject non-object pricing', () => {
-      expect(() => validateConfig({ pricing: 'expensive' })).toThrow('pricing must be an object');
-    });
-
-    it('should reject unknown pricing categories', () => {
-      expect(() => validateConfig({ pricing: { gpt4: { inputPerMTok: 10 } } })).toThrow('Unknown config key: pricing.gpt4');
-    });
-
-    it('should reject non-object category value', () => {
-      expect(() => validateConfig({ pricing: { opus: 'expensive' } })).toThrow('pricing.opus must be an object');
-    });
-
-    it('should reject unknown pricing fields', () => {
-      expect(() => validateConfig({ pricing: { opus: { unknownField: 5 } } })).toThrow('Unknown config key: pricing.opus.unknownField');
-    });
-
-    it('should reject negative pricing values', () => {
-      expect(() => validateConfig({ pricing: { opus: { inputPerMTok: -1 } } })).toThrow('pricing.opus.inputPerMTok must be a non-negative number');
-    });
-
-    it('should reject non-number pricing values', () => {
-      expect(() => validateConfig({ pricing: { opus: { inputPerMTok: 'fifteen' } } })).toThrow('pricing.opus.inputPerMTok must be a non-negative number');
-    });
-
-    it('should accept zero pricing values', () => {
-      expect(() => validateConfig({ pricing: { haiku: { inputPerMTok: 0 } } })).not.toThrow();
-    });
-
-    it('should reject Infinity pricing values', () => {
-      expect(() => validateConfig({ pricing: { opus: { inputPerMTok: Infinity } } })).toThrow('must be a non-negative number');
-    });
-  });
-
-  describe('resolveModelPricingCategory', () => {
-    it('should map short aliases directly', () => {
-      expect(resolveModelPricingCategory('opus')).toBe('opus');
-      expect(resolveModelPricingCategory('sonnet')).toBe('sonnet');
-      expect(resolveModelPricingCategory('haiku')).toBe('haiku');
-    });
-
-    it('should extract family from full model IDs', () => {
-      expect(resolveModelPricingCategory('claude-opus-4-6')).toBe('opus');
-      expect(resolveModelPricingCategory('claude-sonnet-4-5-20250929')).toBe('sonnet');
-      expect(resolveModelPricingCategory('claude-haiku-4-5-20251001')).toBe('haiku');
-    });
-
-    it('should return null for unknown model families', () => {
-      expect(resolveModelPricingCategory('claude-unknown-3-0')).toBeNull();
-      expect(resolveModelPricingCategory('gpt-4')).toBeNull();
-      expect(resolveModelPricingCategory('')).toBeNull();
-    });
-  });
-
-  describe('resolveConfig - pricing', () => {
-    it('should include default pricing when no config file', () => {
-      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
-      expect(config.pricing.opus.inputPerMTok).toBe(15);
-      expect(config.pricing.sonnet.inputPerMTok).toBe(3);
-      expect(config.pricing.haiku.inputPerMTok).toBe(1);
-    });
-
-    it('should deep-merge partial pricing override', () => {
-      const configPath = path.join(tempDir, 'pricing.json');
-      fs.writeFileSync(configPath, JSON.stringify({
-        pricing: { opus: { inputPerMTok: 10 } },
-      }));
-
-      const config = resolveConfig(configPath);
-      expect(config.pricing.opus.inputPerMTok).toBe(10);
-      expect(config.pricing.opus.outputPerMTok).toBe(75); // default preserved
-      expect(config.pricing.sonnet.inputPerMTok).toBe(3); // default preserved
-    });
-  });
-
   describe('getModelShortName', () => {
     it('should return short aliases as-is', () => {
       expect(getModelShortName('opus')).toBe('opus');
@@ -709,7 +615,6 @@ describe('Config', () => {
     it('should accept valid display config', () => {
       expect(() => validateConfig({
         display: {
-          showRateLimitEstimate: true,
           showCacheTokens: false,
         },
       })).not.toThrow();
@@ -717,7 +622,7 @@ describe('Config', () => {
 
     it('should accept partial display override', () => {
       expect(() => validateConfig({
-        display: { showRateLimitEstimate: false },
+        display: { showCacheTokens: false },
       })).not.toThrow();
     });
 
@@ -730,78 +635,31 @@ describe('Config', () => {
     });
 
     it('should reject non-boolean display values', () => {
-      expect(() => validateConfig({ display: { showRateLimitEstimate: 'yes' } })).toThrow('display.showRateLimitEstimate must be a boolean');
-    });
-  });
-
-  describe('validateConfig - rateLimitWindow', () => {
-    it('should accept valid rateLimitWindow config', () => {
-      expect(() => validateConfig({
-        rateLimitWindow: { sonnetTokenCap: 100000 },
-      })).not.toThrow();
-    });
-
-    it('should reject non-object rateLimitWindow', () => {
-      expect(() => validateConfig({ rateLimitWindow: 88000 })).toThrow('rateLimitWindow must be an object');
-    });
-
-    it('should reject unknown rateLimitWindow keys', () => {
-      expect(() => validateConfig({ rateLimitWindow: { unknownKey: 50000 } })).toThrow('Unknown config key: rateLimitWindow.unknownKey');
-    });
-
-    it('should reject non-positive sonnetTokenCap', () => {
-      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: 0 } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
-      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: -100 } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
-    });
-
-    it('should reject non-number sonnetTokenCap', () => {
-      expect(() => validateConfig({ rateLimitWindow: { sonnetTokenCap: '88000' } })).toThrow('rateLimitWindow.sonnetTokenCap must be a positive number');
+      expect(() => validateConfig({ display: { showCacheTokens: 'yes' } })).toThrow('display.showCacheTokens must be a boolean');
     });
   });
 
-  describe('resolveConfig - display and rateLimitWindow', () => {
+  describe('resolveConfig - display', () => {
     it('should include default display when no config file', () => {
       const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
-      expect(config.display.showRateLimitEstimate).toBe(true);
       expect(config.display.showCacheTokens).toBe(true);
     });
 
-    it('should include default rateLimitWindow when no config file', () => {
-      const config = resolveConfig(path.join(tempDir, 'nonexistent.json'));
-      expect(config.rateLimitWindow.sonnetTokenCap).toBe(88000);
-    });
-
     it('should deep-merge partial display override', () => {
       const configPath = path.join(tempDir, 'display.json');
       fs.writeFileSync(configPath, JSON.stringify({
-        display: { showRateLimitEstimate: false },
+        display: { showCacheTokens: false },
       }));
 
       const config = resolveConfig(configPath);
-      expect(config.display.showRateLimitEstimate).toBe(false);
-      expect(config.display.showCacheTokens).toBe(true); // default preserved
-    });
-
-    it('should deep-merge partial rateLimitWindow override', () => {
-      const configPath = path.join(tempDir, 'rateLimit.json');
-      fs.writeFileSync(configPath, JSON.stringify({
-        rateLimitWindow: { sonnetTokenCap: 100000 },
-      }));
-
-      const config = resolveConfig(configPath);
-      expect(config.rateLimitWindow.sonnetTokenCap).toBe(100000);
+      expect(config.display.showCacheTokens).toBe(false);
     });
   });
 
-  describe('DEFAULT_CONFIG - display and rateLimitWindow', () => {
+  describe('DEFAULT_CONFIG - display', () => {
     it('should have default display settings', () => {
-      expect(DEFAULT_CONFIG.display.showRateLimitEstimate).toBe(true);
       expect(DEFAULT_CONFIG.display.showCacheTokens).toBe(true);
     });
-
-    it('should have default rateLimitWindow settings', () => {
-      expect(DEFAULT_CONFIG.rateLimitWindow.sonnetTokenCap).toBe(88000);
-    });
   });
 
   describe('getModelTier', () => {

package/tests/unit/plan-resume-worktree-resolution.test.ts

@@ -0,0 +1,153 @@
+import { jest } from '@jest/globals';
+
+/**
+ * Tests for worktree resolution in the --resume command.
+ *
+ * When `raf plan --resume <identifier>` is run, it should:
+ * 1. Search worktrees first
+ * 2. Fall back to main repo if not found in worktree
+ * 3. Auto-detect worktree mode without requiring --worktree flag
+ */
+
+describe('Plan Resume - Worktree Resolution Logic', () => {
+  describe('resolution flow logic', () => {
+    it('should prioritize worktree over main repo when both exist', () => {
+      // This test verifies the conceptual resolution order used in runResumeCommand:
+      // 1. Try worktree resolution via resolveWorktreeProjectByIdentifier()
+      // 2. If found and valid → use worktree path and worktree root as CWD
+      // 3. If not found → fall back to main repo resolution
+
+      // Simulating the flow:
+      const worktreeFound = true;
+      const worktreeValid = true;
+
+      let useWorktree = false;
+      let useMainRepo = false;
+
+      // Step 1: Try worktree
+      if (worktreeFound && worktreeValid) {
+        useWorktree = true;
+      }
+
+      // Step 2: Fall back to main repo if worktree not used
+      if (!useWorktree) {
+        useMainRepo = true;
+      }
+
+      expect(useWorktree).toBe(true);
+      expect(useMainRepo).toBe(false);
+    });
+
+    it('should fall back to main repo when worktree is invalid', () => {
+      const worktreeFound = true;
+      const worktreeValid = false;
+
+      let useWorktree = false;
+      let useMainRepo = false;
+
+      if (worktreeFound && worktreeValid) {
+        useWorktree = true;
+      }
+
+      if (!useWorktree) {
+        useMainRepo = true;
+      }
+
+      expect(useWorktree).toBe(false);
+      expect(useMainRepo).toBe(true);
+    });
+
+    it('should fall back to main repo when worktree not found', () => {
+      const worktreeFound = false;
+
+      let useWorktree = false;
+      let useMainRepo = false;
+
+      if (worktreeFound) {
+        useWorktree = true;
+      }
+
+      if (!useWorktree) {
+        useMainRepo = true;
+      }
+
+      expect(useWorktree).toBe(false);
+      expect(useMainRepo).toBe(true);
+    });
+  });
+
+  describe('resumeCwd determination', () => {
+    it('should set resumeCwd to worktree root when project found in valid worktree', () => {
+      // Simulated values
+      const worktreeRoot = '/Users/user/.raf/worktrees/RAF/ahwvrz-legacy-sunset';
+      const projectPath = '/Users/user/.raf/worktrees/RAF/ahwvrz-legacy-sunset/RAF/ahwvrz-legacy-sunset';
+
+      const worktreeValid = true;
+      let resumeCwd: string | undefined;
+
+      if (worktreeValid) {
+        resumeCwd = worktreeRoot;
+      }
+
+      expect(resumeCwd).toBe(worktreeRoot);
+    });
+
+    it('should set resumeCwd to project path when using main repo', () => {
+      const mainRepoProjectPath = '/Users/user/myapp/RAF/ahwvrz-legacy-sunset';
+
+      const worktreeFound = false;
+      let resumeCwd: string | undefined;
+
+      if (!worktreeFound) {
+        resumeCwd = mainRepoProjectPath;
+      }
+
+      expect(resumeCwd).toBe(mainRepoProjectPath);
+    });
+  });
+
+  describe('variable initialization', () => {
+    it('should handle undefined variables correctly when worktree is found', () => {
+      let projectPath: string | undefined;
+      let resumeCwd: string | undefined;
+      let folderName: string | undefined;
+
+      // Simulate worktree resolution
+      const worktreeResolution = {
+        folder: 'ahwvrz-legacy-sunset',
+        worktreeRoot: '/Users/user/.raf/worktrees/RAF/ahwvrz-legacy-sunset',
+      };
+
+      if (worktreeResolution) {
+        folderName = worktreeResolution.folder;
+        projectPath = `/path/to/${folderName}`;
+        resumeCwd = worktreeResolution.worktreeRoot;
+      }
+
+      expect(folderName).toBeDefined();
+      expect(projectPath).toBeDefined();
+      expect(resumeCwd).toBeDefined();
+    });
+
+    it('should handle undefined variables correctly when falling back to main repo', () => {
+      let projectPath: string | undefined;
+      let resumeCwd: string | undefined;
+      let folderName: string | undefined;
+
+      // Worktree resolution returns null
+      const worktreeResolution = null;
+
+      // Skip worktree assignment since it's null
+      if (!projectPath && !worktreeResolution) {
+        // Main repo resolution
+        projectPath = '/Users/user/myapp/RAF/ahwvrz-legacy-sunset';
+        folderName = 'ahwvrz-legacy-sunset';
+        resumeCwd = projectPath;
+      }
+
+      expect(folderName).toBeDefined();
+      expect(projectPath).toBeDefined();
+      expect(resumeCwd).toBeDefined();
+    });
+  });
+});