rafcode 2.5.1-0 → 3.0.0

package/tests/unit/dependency-integration.test.ts

@@ -26,7 +26,7 @@ describe('Dependency Integration Flow', () => {
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-dep-integration-'));
-    projectPath = path.join(tempDir, 'aaaaab-test-project');
+    projectPath = path.join(tempDir, '1-test-project');
     fs.mkdirSync(projectPath, { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'plans'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'outcomes'), { recursive: true });
@@ -51,28 +51,28 @@ describe('Dependency Integration Flow', () => {
     beforeEach(() => {
       // Create plan files with dependency structure
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-setup.md'),
+        path.join(projectPath, 'plans', '1-setup.md'),
         '# Task: Setup\n\n## Objective\nSetup the project infrastructure.\n\n## Requirements\n- Initialize project'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-core.md'),
-        '# Task: Core\n\n## Objective\nBuild core functionality.\n\n## Dependencies\n01\n\n## Requirements\n- Build core'
+        path.join(projectPath, 'plans', '2-core.md'),
+        '# Task: Core\n\n## Objective\nBuild core functionality.\n\n## Dependencies\n1\n\n## Requirements\n- Build core'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '03-api.md'),
-        '# Task: API\n\n## Objective\nImplement API layer.\n\n## Dependencies\n01, 02\n\n## Requirements\n- Create API'
+        path.join(projectPath, 'plans', '3-api.md'),
+        '# Task: API\n\n## Objective\nImplement API layer.\n\n## Dependencies\n1, 2\n\n## Requirements\n- Create API'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '04-tests.md'),
-        '# Task: Tests\n\n## Objective\nWrite tests.\n\n## Dependencies\n03\n\n## Requirements\n- Write tests'
+        path.join(projectPath, 'plans', '4-tests.md'),
+        '# Task: Tests\n\n## Objective\nWrite tests.\n\n## Dependencies\n3\n\n## Requirements\n- Write tests'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '05-docs.md'),
-        '# Task: Docs\n\n## Objective\nWrite documentation.\n\n## Dependencies\n03\n\n## Requirements\n- Write docs'
+        path.join(projectPath, 'plans', '5-docs.md'),
+        '# Task: Docs\n\n## Objective\nWrite documentation.\n\n## Dependencies\n3\n\n## Requirements\n- Write docs'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '06-deploy.md'),
-        '# Task: Deploy\n\n## Objective\nDeploy the project.\n\n## Dependencies\n04, 05\n\n## Requirements\n- Deploy'
+        path.join(projectPath, 'plans', '6-deploy.md'),
+        '# Task: Deploy\n\n## Objective\nDeploy the project.\n\n## Dependencies\n4, 5\n\n## Requirements\n- Deploy'
       );
     });
 
@@ -85,25 +85,25 @@ describe('Dependency Integration Flow', () => {
 
       // Verify dependencies are parsed correctly
       expect(state.tasks[0]?.dependencies).toEqual([]);
-      expect(state.tasks[1]?.dependencies).toEqual(['01']);
-      expect(state.tasks[2]?.dependencies).toEqual(['01', '02']);
-      expect(state.tasks[3]?.dependencies).toEqual(['03']);
-      expect(state.tasks[4]?.dependencies).toEqual(['03']);
-      expect(state.tasks[5]?.dependencies).toEqual(['04', '05']);
+      expect(state.tasks[1]?.dependencies).toEqual(['1']);
+      expect(state.tasks[2]?.dependencies).toEqual(['1', '2']);
+      expect(state.tasks[3]?.dependencies).toEqual(['3']);
+      expect(state.tasks[4]?.dependencies).toEqual(['3']);
+      expect(state.tasks[5]?.dependencies).toEqual(['4', '5']);
     });
 
     it('should return first pending task when all are pending', () => {
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
-      expect(nextTask?.id).toBe('01');
+      expect(nextTask?.id).toBe('1');
       expect(nextTask?.status).toBe('pending');
     });
 
     it('should cascade blocks when task 001 fails', () => {
       // Task 001 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-setup.md'),
+        path.join(projectPath, 'outcomes', '1-setup.md'),
         '# Outcome\n\nSetup failed.\n\n<promise>FAILED</promise>'
       );
 
@@ -128,12 +128,12 @@ describe('Dependency Integration Flow', () => {
     it('should cascade blocks when task 002 fails (001 completed)', () => {
       // Task 001 completed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-setup.md'),
+        path.join(projectPath, 'outcomes', '1-setup.md'),
         '# Outcome\n\nSetup complete.\n\n<promise>COMPLETE</promise>'
       );
       // Task 002 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '02-core.md'),
+        path.join(projectPath, 'outcomes', '2-core.md'),
         '# Outcome\n\nCore failed.\n\n<promise>FAILED</promise>'
       );
 
@@ -157,16 +157,16 @@ describe('Dependency Integration Flow', () => {
     it('should cascade blocks when task 003 fails (001, 002 completed)', () => {
       // Tasks 001 and 002 completed
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-setup.md'),
+        path.join(projectPath, 'outcomes', '1-setup.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '02-core.md'),
+        path.join(projectPath, 'outcomes', '2-core.md'),
         '<promise>COMPLETE</promise>'
       );
       // Task 003 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '03-api.md'),
+        path.join(projectPath, 'outcomes', '3-api.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -188,24 +188,24 @@ describe('Dependency Integration Flow', () => {
     it('should handle partial failure in parallel branches', () => {
       // Complete chain up to 003
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-setup.md'),
+        path.join(projectPath, 'outcomes', '1-setup.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '02-core.md'),
+        path.join(projectPath, 'outcomes', '2-core.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '03-api.md'),
+        path.join(projectPath, 'outcomes', '3-api.md'),
         '<promise>COMPLETE</promise>'
       );
       // 004 succeeds but 005 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '04-tests.md'),
+        path.join(projectPath, 'outcomes', '4-tests.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '05-docs.md'),
+        path.join(projectPath, 'outcomes', '5-docs.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -226,7 +226,7 @@ describe('Dependency Integration Flow', () => {
 
     it('should mark project complete when all tasks succeed', () => {
       // All tasks complete
-      for (const taskNum of ['01', '02', '03', '04', '05', '06']) {
+      for (const taskNum of ['1', '2', '3', '4', '5', '6']) {
         const taskFile = fs.readdirSync(path.join(projectPath, 'plans'))
           .find((f) => f.startsWith(taskNum));
         const taskName = taskFile ? extractTaskNameFromPlanFile(`plans/${taskFile}`) : taskNum;
@@ -248,21 +248,21 @@ describe('Dependency Integration Flow', () => {
     it('should skip blocked tasks and find next available pending task', () => {
       // Setup: 001 fails, 002 depends on 001 (blocked), 003 has no deps (pending)
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-first.md'),
+        path.join(projectPath, 'plans', '1-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-second.md'),
-        '# Task: Second\n\n## Dependencies\n01'
+        path.join(projectPath, 'plans', '2-second.md'),
+        '# Task: Second\n\n## Dependencies\n1'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '03-third.md'),
+        path.join(projectPath, 'plans', '3-third.md'),
         '# Task: Third'
       );
 
-      // 001 fails
+      // 1 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-first.md'),
+        path.join(projectPath, 'outcomes', '1-first.md'),
         '<promise>FAILED</promise>'
       );
 
@@ -270,51 +270,51 @@ describe('Dependency Integration Flow', () => {
       const nextTask = getNextExecutableTask(state);
 
       // Should return 003 (pending) not 002 (blocked)
-      expect(nextTask?.id).toBe('03');
+      expect(nextTask?.id).toBe('3');
       expect(nextTask?.status).toBe('pending');
     });
 
     it('should return failed task for retry when no pending tasks exist', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-first.md'),
+        path.join(projectPath, 'plans', '1-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-second.md'),
-        '# Task: Second\n\n## Dependencies\n01'
+        path.join(projectPath, 'plans', '2-second.md'),
+        '# Task: Second\n\n## Dependencies\n1'
       );
 
-      // 001 fails
+      // 1 fails
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-first.md'),
+        path.join(projectPath, 'outcomes', '1-first.md'),
         '<promise>FAILED</promise>'
       );
 
       const state = deriveProjectState(projectPath);
       const nextTask = getNextExecutableTask(state);
 
-      // Should return 001 for retry (002 is blocked)
-      expect(nextTask?.id).toBe('01');
+      // Should return 1 for retry (2 is blocked)
+      expect(nextTask?.id).toBe('1');
       expect(nextTask?.status).toBe('failed');
     });
 
     it('should return null when all tasks are blocked with no failed tasks to retry', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-first.md'),
+        path.join(projectPath, 'plans', '1-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-second.md'),
+        path.join(projectPath, 'plans', '2-second.md'),
         '# Task: Second\n\n## Dependencies\n01'
       );
 
       // 001 completed, but 002 is marked as blocked explicitly (edge case)
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-first.md'),
+        path.join(projectPath, 'outcomes', '1-first.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '02-second.md'),
+        path.join(projectPath, 'outcomes', '2-second.md'),
         '<promise>BLOCKED</promise>'
       );
 
@@ -329,92 +329,92 @@ describe('Dependency Integration Flow', () => {
   describe('Execution prompt with dependency context', () => {
     it('should include dependency outcomes in execution prompt', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-setup.md'),
+        path.join(projectPath, 'plans', '1-setup.md'),
         '# Task: Setup\n\n## Objective\nSetup the project.'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-build.md'),
-        '# Task: Build\n\n## Objective\nBuild the project.\n\n## Dependencies\n01'
+        path.join(projectPath, 'plans', '2-build.md'),
+        '# Task: Build\n\n## Objective\nBuild the project.\n\n## Dependencies\n1'
       );
 
       // 001 completed with outcome
       const outcome001 = '# Outcome: Task 001\n\n## Summary\n\nInitialized project with configuration files.\n\n<promise>COMPLETE</promise>';
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-setup.md'),
+        path.join(projectPath, 'outcomes', '1-setup.md'),
         outcome001
       );
 
       const state = deriveProjectState(projectPath);
-      const task002 = state.tasks.find((t) => t.id === '02');
+      const task002 = state.tasks.find((t) => t.id === '2');
 
       expect(task002).toBeDefined();
-      expect(task002?.dependencies).toEqual(['01']);
+      expect(task002?.dependencies).toEqual(['1']);
 
       // Build execution prompt for task 002
       const prompt = getExecutionPrompt({
         projectPath,
-        planPath: path.join(projectPath, 'plans', '02-build.md'),
-        taskId: '02',
+        planPath: path.join(projectPath, 'plans', '2-build.md'),
+        taskId: '2',
         taskNumber: 2,
         totalTasks: 2,
-        previousOutcomes: [{ taskId: '01', content: outcome001 }],
+        previousOutcomes: [{ taskId: '1', content: outcome001 }],
         autoCommit: true,
-        projectNumber: '001',
-        outcomeFilePath: path.join(projectPath, 'outcomes', '02-build.md'),
-        dependencyIds: ['01'],
-        dependencyOutcomes: [{ taskId: '01', content: outcome001 }],
+        projectNumber: '1',
+        outcomeFilePath: path.join(projectPath, 'outcomes', '2-build.md'),
+        dependencyIds: ['1'],
+        dependencyOutcomes: [{ taskId: '1', content: outcome001 }],
       });
 
       expect(prompt).toContain('## Dependency Context');
-      expect(prompt).toContain('**Dependencies**: 01');
-      expect(prompt).toContain('### Task 01');
+      expect(prompt).toContain('**Dependencies**: 1');
+      expect(prompt).toContain('### Task 1');
       expect(prompt).toContain('Initialized project with configuration files');
     });
 
     it('should include multiple dependency outcomes', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-setup.md'),
+        path.join(projectPath, 'plans', '1-setup.md'),
         '# Task: Setup'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-core.md'),
+        path.join(projectPath, 'plans', '2-core.md'),
         '# Task: Core\n\n## Dependencies\n01'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '03-api.md'),
+        path.join(projectPath, 'plans', '3-api.md'),
         '# Task: API\n\n## Dependencies\n01, 02'
       );
 
       const outcome001 = '## Summary\n\nSetup complete.\n\n<promise>COMPLETE</promise>';
       const outcome002 = '## Summary\n\nCore complete.\n\n<promise>COMPLETE</promise>';
 
-      fs.writeFileSync(path.join(projectPath, 'outcomes', '01-setup.md'), outcome001);
-      fs.writeFileSync(path.join(projectPath, 'outcomes', '02-core.md'), outcome002);
+      fs.writeFileSync(path.join(projectPath, 'outcomes', '1-setup.md'), outcome001);
+      fs.writeFileSync(path.join(projectPath, 'outcomes', '2-core.md'), outcome002);
 
       const prompt = getExecutionPrompt({
         projectPath,
-        planPath: path.join(projectPath, 'plans', '03-api.md'),
-        taskId: '03',
+        planPath: path.join(projectPath, 'plans', '3-api.md'),
+        taskId: '3',
         taskNumber: 3,
         totalTasks: 3,
         previousOutcomes: [
-          { taskId: '01', content: outcome001 },
-          { taskId: '02', content: outcome002 },
+          { taskId: '1', content: outcome001 },
+          { taskId: '2', content: outcome002 },
         ],
         autoCommit: true,
-        projectNumber: '001',
-        outcomeFilePath: path.join(projectPath, 'outcomes', '03-api.md'),
-        dependencyIds: ['01', '02'],
+        projectNumber: '1',
+        outcomeFilePath: path.join(projectPath, 'outcomes', '3-api.md'),
+        dependencyIds: ['1', '2'],
         dependencyOutcomes: [
-          { taskId: '01', content: outcome001 },
-          { taskId: '02', content: outcome002 },
+          { taskId: '1', content: outcome001 },
+          { taskId: '2', content: outcome002 },
         ],
       });
 
-      expect(prompt).toContain('**Dependencies**: 01, 02');
-      expect(prompt).toContain('### Task 01');
+      expect(prompt).toContain('**Dependencies**: 1, 2');
+      expect(prompt).toContain('### Task 1');
       expect(prompt).toContain('Setup complete');
-      expect(prompt).toContain('### Task 02');
+      expect(prompt).toContain('### Task 2');
       expect(prompt).toContain('Core complete');
     });
   });
@@ -422,7 +422,7 @@ describe('Dependency Integration Flow', () => {
   describe('BLOCKED outcome file recognition', () => {
     it('should recognize BLOCKED marker and set status to blocked', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-task.md'),
+        path.join(projectPath, 'plans', '1-task.md'),
         '# Task: Task'
       );
 
@@ -448,7 +448,7 @@ To unblock this task:
 <promise>BLOCKED</promise>`;
 
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-task.md'),
+        path.join(projectPath, 'outcomes', '1-task.md'),
         blockedContent
       );
 
@@ -473,17 +473,17 @@ To unblock this task:
       // In practice, circular deps are prevented by only allowing deps on lower-numbered tasks
       // But if somehow created, should not infinite loop
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-first.md'),
-        '# Task: First\n\n## Dependencies\n02' // Invalid: depends on higher-numbered task
+        path.join(projectPath, 'plans', '1-first.md'),
+        '# Task: First\n\n## Dependencies\n2' // Invalid: depends on higher-numbered task
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-second.md'),
+        path.join(projectPath, 'plans', '2-second.md'),
         '# Task: Second'
       );
 
       // 002 succeeds
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '02-second.md'),
+        path.join(projectPath, 'outcomes', '2-second.md'),
         '<promise>COMPLETE</promise>'
       );
 
@@ -497,21 +497,21 @@ To unblock this task:
 
     it('should handle dependency on non-existent task gracefully', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-task.md'),
-        '# Task: Task\n\n## Dependencies\nzz' // 999 doesn't exist
+        path.join(projectPath, 'plans', '1-task.md'),
+        '# Task: Task\n\n## Dependencies\n999' // 999 doesn't exist
       );
 
       const state = deriveProjectState(projectPath);
       // Task should be pending since the non-existent dep doesn't block it
       // (The dependency 999 just won't be found, treated as if satisfied)
       expect(state.tasks[0]?.status).toBe('pending');
-      expect(state.tasks[0]?.dependencies).toEqual(['zz']);
+      expect(state.tasks[0]?.dependencies).toEqual(['999']);
     });
 
     it('should handle self-dependency gracefully', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-task.md'),
-        '# Task: Task\n\n## Dependencies\n01' // Self-dependency
+        path.join(projectPath, 'plans', '1-task.md'),
+        '# Task: Task\n\n## Dependencies\n1' // Self-dependency
       );
 
       const state = deriveProjectState(projectPath);
@@ -530,25 +530,25 @@ To unblock this task:
 
     it('should handle task with all dependencies completed', () => {
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '01-first.md'),
+        path.join(projectPath, 'plans', '1-first.md'),
         '# Task: First'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '02-second.md'),
+        path.join(projectPath, 'plans', '2-second.md'),
         '# Task: Second'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'plans', '03-third.md'),
+        path.join(projectPath, 'plans', '3-third.md'),
         '# Task: Third\n\n## Dependencies\n01, 02'
       );
 
       // Both deps complete
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '01-first.md'),
+        path.join(projectPath, 'outcomes', '1-first.md'),
         '<promise>COMPLETE</promise>'
       );
       fs.writeFileSync(
-        path.join(projectPath, 'outcomes', '02-second.md'),
+        path.join(projectPath, 'outcomes', '2-second.md'),
         '<promise>COMPLETE</promise>'
       );
 

package/tests/unit/do-blocked-tasks.test.ts

@@ -21,7 +21,7 @@ describe('do command blocked tasks', () => {
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-blocked-test-'));
-    projectPath = path.join(tempDir, 'aaaaab-test-project');
+    projectPath = path.join(tempDir, '1-test-project');
     fs.mkdirSync(projectPath, { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'plans'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'outcomes'), { recursive: true });

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

@@ -15,89 +15,89 @@ describe('Do Command - Identifier Support', () => {
   });
 
   describe('Single Project Full Folder Name Resolution', () => {
-    it('should resolve project by full 6-char prefix folder name: raf do aaaaab-fix-stuff', () => {
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-fix-stuff'));
-      const result = resolveProjectIdentifier(tempDir, 'aaaaab-fix-stuff');
-      expect(result).toBe(path.join(tempDir, 'aaaaab-fix-stuff'));
+    it('should resolve project by full numeric prefix folder name: raf do 1-fix-stuff', () => {
+      fs.mkdirSync(path.join(tempDir, '1-fix-stuff'));
+      const result = resolveProjectIdentifier(tempDir, '1-fix-stuff');
+      expect(result).toBe(path.join(tempDir, '1-fix-stuff'));
     });
 
-    it('should resolve project by full base26 folder name: raf do abcdef-project', () => {
-      fs.mkdirSync(path.join(tempDir, 'abcdef-project'));
-      const result = resolveProjectIdentifier(tempDir, 'abcdef-project');
-      expect(result).toBe(path.join(tempDir, 'abcdef-project'));
+    it('should resolve project by full numeric folder name: raf do 7-project', () => {
+      fs.mkdirSync(path.join(tempDir, '7-project'));
+      const result = resolveProjectIdentifier(tempDir, '7-project');
+      expect(result).toBe(path.join(tempDir, '7-project'));
     });
 
-    it('should resolve full folder name with all-numeric prefix', () => {
-      fs.mkdirSync(path.join(tempDir, 'aaaadt-all-letters'));
-      const result = resolveProjectIdentifier(tempDir, 'aaaadt-all-letters');
-      expect(result).toBe(path.join(tempDir, 'aaaadt-all-letters'));
+    it('should resolve full folder name with multi-digit numeric prefix', () => {
+      fs.mkdirSync(path.join(tempDir, '42-all-letters'));
+      const result = resolveProjectIdentifier(tempDir, '42-all-letters');
+      expect(result).toBe(path.join(tempDir, '42-all-letters'));
     });
   });
 
   describe('Error Messages for Non-Matching Full Folder Names', () => {
     it('should return null for non-existent full folder name', () => {
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-existing'));
-      const result = resolveProjectIdentifier(tempDir, 'aaaaac-non-existent');
+      fs.mkdirSync(path.join(tempDir, '1-existing'));
+      const result = resolveProjectIdentifier(tempDir, '2-non-existent');
       expect(result).toBeNull();
     });
 
     it('should return null when prefix exists but name differs', () => {
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-actual-name'));
-      const result = resolveProjectIdentifier(tempDir, 'aaaaab-different-name');
+      fs.mkdirSync(path.join(tempDir, '1-actual-name'));
+      const result = resolveProjectIdentifier(tempDir, '1-different-name');
       expect(result).toBeNull();
     });
 
     it('should return null when name exists but prefix differs', () => {
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
-      const result = resolveProjectIdentifier(tempDir, 'aaabmm-my-project');
+      fs.mkdirSync(path.join(tempDir, '1-my-project'));
+      const result = resolveProjectIdentifier(tempDir, '42-my-project');
       expect(result).toBeNull();
     });
 
     it('should return null for non-matching full folder name', () => {
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
-      const result = resolveProjectIdentifier(tempDir, 'abcdef-my-project');
+      fs.mkdirSync(path.join(tempDir, '1-my-project'));
+      const result = resolveProjectIdentifier(tempDir, '7-my-project');
       expect(result).toBeNull();
     });
   });
 
   describe('Identifier Formats', () => {
     beforeEach(() => {
-      fs.mkdirSync(path.join(tempDir, 'aaaaab-my-project'));
-      fs.mkdirSync(path.join(tempDir, 'aaaaac-another-project'));
-      fs.mkdirSync(path.join(tempDir, 'ghijkl-alpha-project'));
+      fs.mkdirSync(path.join(tempDir, '1-my-project'));
+      fs.mkdirSync(path.join(tempDir, '2-another-project'));
+      fs.mkdirSync(path.join(tempDir, '3-alpha-project'));
     });
 
-    it('should resolve by 6-char base26 prefix', () => {
-      expect(resolveProjectIdentifier(tempDir, 'aaaaab')).toBe(path.join(tempDir, 'aaaaab-my-project'));
-      expect(resolveProjectIdentifier(tempDir, 'aaaaac')).toBe(path.join(tempDir, 'aaaaac-another-project'));
+    it('should resolve by numeric prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, '1')).toBe(path.join(tempDir, '1-my-project'));
+      expect(resolveProjectIdentifier(tempDir, '2')).toBe(path.join(tempDir, '2-another-project'));
     });
 
-    it('should resolve by base26 prefix', () => {
-      expect(resolveProjectIdentifier(tempDir, 'ghijkl')).toBe(path.join(tempDir, 'ghijkl-alpha-project'));
+    it('should resolve by numeric prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, '3')).toBe(path.join(tempDir, '3-alpha-project'));
     });
 
     it('should resolve by project name', () => {
-      expect(resolveProjectIdentifier(tempDir, 'my-project')).toBe(path.join(tempDir, 'aaaaab-my-project'));
-      expect(resolveProjectIdentifier(tempDir, 'another-project')).toBe(path.join(tempDir, 'aaaaac-another-project'));
-      expect(resolveProjectIdentifier(tempDir, 'alpha-project')).toBe(path.join(tempDir, 'ghijkl-alpha-project'));
+      expect(resolveProjectIdentifier(tempDir, 'my-project')).toBe(path.join(tempDir, '1-my-project'));
+      expect(resolveProjectIdentifier(tempDir, 'another-project')).toBe(path.join(tempDir, '2-another-project'));
+      expect(resolveProjectIdentifier(tempDir, 'alpha-project')).toBe(path.join(tempDir, '3-alpha-project'));
     });
   });
 
   describe('Project Name Extraction with Full Folder Names', () => {
-    it('should extract name from 6-char prefix folder path', () => {
-      const projectPath = path.join(tempDir, 'aaaaab-my-project');
+    it('should extract name from numeric prefix folder path', () => {
+      const projectPath = path.join(tempDir, '1-my-project');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-project');
     });
 
-    it('should extract name from base26 full folder path', () => {
-      const projectPath = path.join(tempDir, 'abcdef-my-project');
+    it('should extract name from numeric full folder path', () => {
+      const projectPath = path.join(tempDir, '7-my-project');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-project');
     });
 
     it('should handle multi-hyphen names', () => {
-      const projectPath = path.join(tempDir, 'aaaaab-my-cool-project-name');
+      const projectPath = path.join(tempDir, '1-my-cool-project-name');
       const name = extractProjectName(projectPath);
       expect(name).toBe('my-cool-project-name');
     });

package/tests/unit/do-rerun.test.ts

@@ -18,7 +18,7 @@ describe('do command rerun functionality', () => {
 
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-do-rerun-test-'));
-    projectPath = path.join(tempDir, 'aaaaab-test-project');
+    projectPath = path.join(tempDir, '1-test-project');
     fs.mkdirSync(projectPath, { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'plans'), { recursive: true });
     fs.mkdirSync(path.join(projectPath, 'outcomes'), { recursive: true });