rafcode 1.0.0

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

@@ -0,0 +1,271 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { resolveProjectIdentifier, extractProjectName } from '../../src/utils/paths.js';
+import { discoverProjects } from '../../src/core/state-derivation.js';
+
+describe('Status Command - Identifier Support', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-status-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Identifier Resolution for Status', () => {
+    it('should resolve project by numeric ID', () => {
+      fs.mkdirSync(path.join(tempDir, '003-fix-bug'));
+      const result = resolveProjectIdentifier(tempDir, '3');
+      expect(result).toBe(path.join(tempDir, '003-fix-bug'));
+    });
+
+    it('should resolve project by zero-padded numeric ID', () => {
+      fs.mkdirSync(path.join(tempDir, '003-fix-bug'));
+      const result = resolveProjectIdentifier(tempDir, '003');
+      expect(result).toBe(path.join(tempDir, '003-fix-bug'));
+    });
+
+    it('should resolve project by base36 ID', () => {
+      fs.mkdirSync(path.join(tempDir, 'a00-large-project'));
+      const result = resolveProjectIdentifier(tempDir, 'a00');
+      expect(result).toBe(path.join(tempDir, 'a00-large-project'));
+    });
+
+    it('should resolve project by name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      const result = resolveProjectIdentifier(tempDir, 'my-project');
+      expect(result).toBe(path.join(tempDir, '001-my-project'));
+    });
+
+    it('should resolve project by full numeric folder name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-fix-stuff'));
+      const result = resolveProjectIdentifier(tempDir, '001-fix-stuff');
+      expect(result).toBe(path.join(tempDir, '001-fix-stuff'));
+    });
+
+    it('should resolve project by full base36 folder name', () => {
+      fs.mkdirSync(path.join(tempDir, 'a00-important'));
+      const result = resolveProjectIdentifier(tempDir, 'a00-important');
+      expect(result).toBe(path.join(tempDir, 'a00-important'));
+    });
+
+    it('should return null for invalid identifier', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      const result = resolveProjectIdentifier(tempDir, 'non-existent');
+      expect(result).toBeNull();
+    });
+
+    it('should handle case-insensitive folder matching for full folder names', () => {
+      fs.mkdirSync(path.join(tempDir, 'A01-My-Project'));
+      const result = resolveProjectIdentifier(tempDir, 'a01-my-project');
+      expect(result).toBe(path.join(tempDir, 'A01-My-Project'));
+    });
+  });
+
+  describe('Project Name Extraction', () => {
+    it('should extract project name from numeric folder', () => {
+      const projectPath = path.join(tempDir, '001-my-project');
+      const name = extractProjectName(projectPath);
+      expect(name).toBe('my-project');
+    });
+
+    it('should extract project name from base36 folder', () => {
+      const projectPath = path.join(tempDir, 'a00-my-project');
+      const name = extractProjectName(projectPath);
+      expect(name).toBe('my-project');
+    });
+  });
+
+  describe('All Identifier Formats Work', () => {
+    beforeEach(() => {
+      // Create a numeric project
+      fs.mkdirSync(path.join(tempDir, '003-numeric-project'));
+      // Create a base36 project
+      fs.mkdirSync(path.join(tempDir, 'a01-base36-project'));
+    });
+
+    it('should work with number without leading zeros', () => {
+      expect(resolveProjectIdentifier(tempDir, '3')).toBe(path.join(tempDir, '003-numeric-project'));
+    });
+
+    it('should work with number with leading zeros', () => {
+      expect(resolveProjectIdentifier(tempDir, '003')).toBe(path.join(tempDir, '003-numeric-project'));
+    });
+
+    it('should work with base36 prefix', () => {
+      expect(resolveProjectIdentifier(tempDir, 'a01')).toBe(path.join(tempDir, 'a01-base36-project'));
+    });
+
+    it('should work with project name for numeric project', () => {
+      expect(resolveProjectIdentifier(tempDir, 'numeric-project')).toBe(path.join(tempDir, '003-numeric-project'));
+    });
+
+    it('should work with project name for base36 project', () => {
+      expect(resolveProjectIdentifier(tempDir, 'base36-project')).toBe(path.join(tempDir, 'a01-base36-project'));
+    });
+
+    it('should work with full numeric folder name', () => {
+      expect(resolveProjectIdentifier(tempDir, '003-numeric-project')).toBe(path.join(tempDir, '003-numeric-project'));
+    });
+
+    it('should work with full base36 folder name', () => {
+      expect(resolveProjectIdentifier(tempDir, 'a01-base36-project')).toBe(path.join(tempDir, 'a01-base36-project'));
+    });
+
+    it('should work with numeric value of base36 project', () => {
+      // a01 = 1001 in base36 encoding
+      expect(resolveProjectIdentifier(tempDir, '1001')).toBe(path.join(tempDir, 'a01-base36-project'));
+    });
+  });
+
+  describe('Error Cases', () => {
+    it('should return null for non-existent numeric ID', () => {
+      fs.mkdirSync(path.join(tempDir, '001-project'));
+      expect(resolveProjectIdentifier(tempDir, '999')).toBeNull();
+    });
+
+    it('should return null for non-existent base36 ID', () => {
+      fs.mkdirSync(path.join(tempDir, 'a00-project'));
+      expect(resolveProjectIdentifier(tempDir, 'b00')).toBeNull();
+    });
+
+    it('should return null for non-existent project name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      expect(resolveProjectIdentifier(tempDir, 'other-project')).toBeNull();
+    });
+
+    it('should return null for non-existent full folder name', () => {
+      fs.mkdirSync(path.join(tempDir, '001-my-project'));
+      expect(resolveProjectIdentifier(tempDir, '002-my-project')).toBeNull();
+    });
+
+    it('should return null for empty RAF directory', () => {
+      expect(resolveProjectIdentifier(tempDir, '001')).toBeNull();
+    });
+
+    it('should return null for non-existent RAF directory', () => {
+      expect(resolveProjectIdentifier('/non/existent/path', '001')).toBeNull();
+    });
+  });
+});
+
+describe('Status Command - Truncation Behavior', () => {
+  let tempDir: string;
+  const MAX_DISPLAYED_PROJECTS = 10;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-truncation-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  function createProject(number: number, name: string): void {
+    const projectNumber = String(number).padStart(3, '0');
+    fs.mkdirSync(path.join(tempDir, `${projectNumber}-${name}`));
+  }
+
+  describe('Project List Truncation Logic', () => {
+    it('should return all projects when count is less than max', () => {
+      createProject(1, 'project-a');
+      createProject(2, 'project-b');
+      createProject(3, 'project-c');
+
+      const projects = discoverProjects(tempDir);
+      expect(projects.length).toBe(3);
+      expect(projects.length).toBeLessThanOrEqual(MAX_DISPLAYED_PROJECTS);
+    });
+
+    it('should return all projects when count equals max', () => {
+      for (let i = 1; i <= MAX_DISPLAYED_PROJECTS; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const projects = discoverProjects(tempDir);
+      expect(projects.length).toBe(MAX_DISPLAYED_PROJECTS);
+    });
+
+    it('should have more than max projects for truncation testing', () => {
+      for (let i = 1; i <= 15; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const allProjects = discoverProjects(tempDir);
+      expect(allProjects.length).toBe(15);
+      expect(allProjects.length).toBeGreaterThan(MAX_DISPLAYED_PROJECTS);
+
+      // Verify truncation would yield correct hidden count
+      const hiddenCount = allProjects.length - MAX_DISPLAYED_PROJECTS;
+      expect(hiddenCount).toBe(5);
+    });
+
+    it('should slice to get last N projects (sorted by number ascending)', () => {
+      for (let i = 1; i <= 15; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const allProjects = discoverProjects(tempDir);
+      const displayedProjects = allProjects.slice(-MAX_DISPLAYED_PROJECTS);
+
+      // Should have projects 6-15 (last 10)
+      expect(displayedProjects.length).toBe(MAX_DISPLAYED_PROJECTS);
+      expect(displayedProjects[0].number).toBe(6);
+      expect(displayedProjects[9].number).toBe(15);
+    });
+
+    it('should keep projects in ascending order after slicing', () => {
+      for (let i = 1; i <= 12; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const allProjects = discoverProjects(tempDir);
+      const displayedProjects = allProjects.slice(-MAX_DISPLAYED_PROJECTS);
+
+      // Verify ascending order
+      for (let i = 1; i < displayedProjects.length; i++) {
+        expect(displayedProjects[i].number).toBeGreaterThan(displayedProjects[i - 1].number);
+      }
+    });
+
+    it('should calculate correct hidden count', () => {
+      // Test with 25 projects
+      for (let i = 1; i <= 25; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const allProjects = discoverProjects(tempDir);
+      const hiddenCount = Math.max(0, allProjects.length - MAX_DISPLAYED_PROJECTS);
+
+      expect(hiddenCount).toBe(15);
+    });
+
+    it('should have zero hidden count when projects are at or below max', () => {
+      for (let i = 1; i <= 5; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const allProjects = discoverProjects(tempDir);
+      const hiddenCount = Math.max(0, allProjects.length - MAX_DISPLAYED_PROJECTS);
+
+      expect(hiddenCount).toBe(0);
+    });
+
+    it('should handle exactly max + 1 projects', () => {
+      for (let i = 1; i <= MAX_DISPLAYED_PROJECTS + 1; i++) {
+        createProject(i, `project-${i}`);
+      }
+
+      const allProjects = discoverProjects(tempDir);
+      const hiddenCount = Math.max(0, allProjects.length - MAX_DISPLAYED_PROJECTS);
+      const displayedProjects = allProjects.slice(-MAX_DISPLAYED_PROJECTS);
+
+      expect(hiddenCount).toBe(1);
+      expect(displayedProjects.length).toBe(MAX_DISPLAYED_PROJECTS);
+      expect(displayedProjects[0].number).toBe(2);
+    });
+  });
+});

package/tests/unit/status-line.test.ts

@@ -0,0 +1,92 @@
+import { jest } from '@jest/globals';
+import { createStatusLine } from '../../src/utils/status-line.js';
+
+describe('StatusLine', () => {
+  let originalIsTTY: boolean | undefined;
+  let originalWrite: typeof process.stdout.write;
+  let writeOutput: string[];
+
+  beforeEach(() => {
+    originalIsTTY = process.stdout.isTTY;
+    originalWrite = process.stdout.write;
+    writeOutput = [];
+
+    // Mock stdout.write to capture output
+    process.stdout.write = jest.fn((data: string | Uint8Array) => {
+      writeOutput.push(data.toString());
+      return true;
+    }) as typeof process.stdout.write;
+  });
+
+  afterEach(() => {
+    process.stdout.isTTY = originalIsTTY;
+    process.stdout.write = originalWrite;
+  });
+
+  describe('when stdout is TTY', () => {
+    beforeEach(() => {
+      process.stdout.isTTY = true;
+    });
+
+    it('should write text with carriage return prefix', () => {
+      const statusLine = createStatusLine();
+      statusLine.update('Hello');
+
+      expect(writeOutput).toHaveLength(1);
+      expect(writeOutput[0]).toContain('\r');
+      expect(writeOutput[0]).toContain('Hello');
+    });
+
+    it('should clear previous content before writing new', () => {
+      const statusLine = createStatusLine();
+      statusLine.update('Short');
+      writeOutput = [];
+
+      statusLine.update('A');
+      // Should clear 5 chars (length of 'Short') before writing 'A'
+      expect(writeOutput[0]).toContain('     ');
+      expect(writeOutput[0]).toContain('A');
+    });
+
+    it('should clear line completely when clear() is called', () => {
+      const statusLine = createStatusLine();
+      statusLine.update('Test');
+      writeOutput = [];
+
+      statusLine.clear();
+      // Should clear 4 chars and reset
+      expect(writeOutput[0]).toContain('\r');
+    });
+
+    it('should not write again after clear() until update() is called', () => {
+      const statusLine = createStatusLine();
+      statusLine.update('Test');
+      statusLine.clear();
+      writeOutput = [];
+
+      statusLine.clear();
+      expect(writeOutput).toHaveLength(0);
+    });
+  });
+
+  describe('when stdout is not TTY', () => {
+    beforeEach(() => {
+      process.stdout.isTTY = false;
+    });
+
+    it('should not write anything on update', () => {
+      const statusLine = createStatusLine();
+      statusLine.update('Hello');
+
+      expect(writeOutput).toHaveLength(0);
+    });
+
+    it('should not write anything on clear', () => {
+      const statusLine = createStatusLine();
+      statusLine.update('Hello');
+      statusLine.clear();
+
+      expect(writeOutput).toHaveLength(0);
+    });
+  });
+});

package/tests/unit/terminal-symbols.test.ts

@@ -0,0 +1,214 @@
+import {
+  SYMBOLS,
+  formatTaskProgress,
+  formatProjectHeader,
+  formatSummary,
+  formatProgressBar,
+  TaskStatus,
+} from '../../src/utils/terminal-symbols.js';
+
+describe('Terminal Symbols', () => {
+  describe('SYMBOLS', () => {
+    it('should have all required symbols', () => {
+      expect(SYMBOLS.running).toBe('●');
+      expect(SYMBOLS.completed).toBe('✓');
+      expect(SYMBOLS.failed).toBe('✗');
+      expect(SYMBOLS.pending).toBe('○');
+      expect(SYMBOLS.blocked).toBe('⊘');
+      expect(SYMBOLS.project).toBe('▶');
+    });
+
+    it('should be a const object with correct types', () => {
+      // TypeScript's 'as const' provides compile-time immutability
+      // Verify all expected keys exist
+      expect(Object.keys(SYMBOLS)).toEqual(['running', 'completed', 'failed', 'pending', 'blocked', 'project']);
+    });
+  });
+
+  describe('formatTaskProgress', () => {
+    it('should format a running task with elapsed time', () => {
+      const result = formatTaskProgress(1, 5, 'running', 'auth-login', 83000);
+      expect(result).toBe('● auth-login 1m 23s');
+    });
+
+    it('should format a running task without elapsed time', () => {
+      const result = formatTaskProgress(1, 5, 'running', 'auth-login');
+      expect(result).toBe('● auth-login 1/5');
+    });
+
+    it('should format a completed task without elapsed time', () => {
+      const result = formatTaskProgress(3, 5, 'completed', 'setup-db');
+      expect(result).toBe('✓ setup-db 3/5');
+    });
+
+    it('should format a completed task with elapsed time', () => {
+      const result = formatTaskProgress(3, 5, 'completed', 'setup-db', 154000);
+      expect(result).toBe('✓ setup-db 2m 34s');
+    });
+
+    it('should format a failed task without elapsed time', () => {
+      const result = formatTaskProgress(2, 5, 'failed', 'deploy');
+      expect(result).toBe('✗ deploy 2/5');
+    });
+
+    it('should format a failed task with elapsed time', () => {
+      const result = formatTaskProgress(2, 5, 'failed', 'deploy', 45000);
+      expect(result).toBe('✗ deploy 45s');
+    });
+
+    it('should format a pending task', () => {
+      const result = formatTaskProgress(4, 5, 'pending', 'cleanup');
+      expect(result).toBe('○ cleanup 4/5');
+    });
+
+    it('should truncate long task names', () => {
+      const longName = 'this-is-a-very-long-task-name-that-should-be-truncated-for-display';
+      const result = formatTaskProgress(1, 1, 'running', longName);
+      expect(result).toContain('…');
+      expect(result.length).toBeLessThan(60);
+    });
+
+    it('should handle empty task name', () => {
+      const result = formatTaskProgress(1, 1, 'pending', '');
+      expect(result).toBe('○ task 1/1');
+    });
+
+    it('should handle zero elapsed time for running task', () => {
+      const result = formatTaskProgress(1, 1, 'running', 'test', 0);
+      expect(result).toBe('● test 0s');
+    });
+
+    it('should format a blocked task', () => {
+      const result = formatTaskProgress(2, 5, 'blocked', 'depends-on-failed');
+      expect(result).toBe('⊘ depends-on-failed 2/5');
+    });
+  });
+
+  describe('formatProjectHeader', () => {
+    it('should format project header with multiple tasks', () => {
+      const result = formatProjectHeader('my-project', 5);
+      expect(result).toBe('▶ my-project (5 tasks)');
+    });
+
+    it('should format project header with single task', () => {
+      const result = formatProjectHeader('small-project', 1);
+      expect(result).toBe('▶ small-project (1 task)');
+    });
+
+    it('should format project header with zero tasks', () => {
+      const result = formatProjectHeader('empty-project', 0);
+      expect(result).toBe('▶ empty-project (0 tasks)');
+    });
+
+    it('should truncate long project names', () => {
+      const longName = 'this-is-a-very-very-long-project-name-that-exceeds-fifty-chars';
+      const result = formatProjectHeader(longName, 3);
+      expect(result).toContain('…');
+      expect(result.length).toBeLessThan(70);
+    });
+
+    it('should handle empty project name', () => {
+      const result = formatProjectHeader('', 5);
+      expect(result).toBe('▶ project (5 tasks)');
+    });
+  });
+
+  describe('formatSummary', () => {
+    it('should format all completed with elapsed time', () => {
+      const result = formatSummary(5, 0, 0, 754000);
+      expect(result).toBe('✓ 5/5 completed in 12m 34s');
+    });
+
+    it('should format all completed without elapsed time', () => {
+      const result = formatSummary(5, 0, 0);
+      expect(result).toBe('✓ 5/5 completed');
+    });
+
+    it('should format with failures', () => {
+      const result = formatSummary(3, 2, 0);
+      expect(result).toBe('✗ 3/5 (2 failed)');
+    });
+
+    it('should format single failure', () => {
+      const result = formatSummary(4, 1, 0);
+      expect(result).toBe('✗ 4/5 (1 failed)');
+    });
+
+    it('should format with pending tasks', () => {
+      const result = formatSummary(3, 0, 2);
+      expect(result).toBe('✓ 3/5 completed');
+    });
+
+    it('should format with mixed status', () => {
+      const result = formatSummary(2, 1, 2);
+      expect(result).toBe('✗ 2/5 (1 failed)');
+    });
+
+    it('should handle zero total tasks', () => {
+      const result = formatSummary(0, 0, 0);
+      expect(result).toBe('○ no tasks');
+    });
+
+    it('should ignore elapsed time when there are failures', () => {
+      const result = formatSummary(3, 2, 0, 60000);
+      expect(result).toBe('✗ 3/5 (2 failed)');
+    });
+
+    it('should format with blocked tasks only', () => {
+      const result = formatSummary(3, 0, 0, undefined, 2);
+      expect(result).toBe('✗ 3/5 (2 blocked)');
+    });
+
+    it('should format single blocked task', () => {
+      const result = formatSummary(4, 0, 0, undefined, 1);
+      expect(result).toBe('✗ 4/5 (1 blocked)');
+    });
+
+    it('should format with failures and blocked tasks', () => {
+      const result = formatSummary(2, 1, 0, undefined, 2);
+      expect(result).toBe('✗ 2/5 (1 failed, 2 blocked)');
+    });
+
+    it('should include blocked in total count', () => {
+      const result = formatSummary(2, 1, 1, undefined, 1);
+      expect(result).toBe('✗ 2/5 (1 failed, 1 blocked)');
+    });
+  });
+
+  describe('formatProgressBar', () => {
+    it('should format a sequence of task statuses', () => {
+      const tasks: TaskStatus[] = ['completed', 'completed', 'running', 'pending', 'pending'];
+      const result = formatProgressBar(tasks);
+      expect(result).toBe('✓✓●○○');
+    });
+
+    it('should format all completed', () => {
+      const tasks: TaskStatus[] = ['completed', 'completed', 'completed'];
+      const result = formatProgressBar(tasks);
+      expect(result).toBe('✓✓✓');
+    });
+
+    it('should format with failures', () => {
+      const tasks: TaskStatus[] = ['completed', 'failed', 'pending'];
+      const result = formatProgressBar(tasks);
+      expect(result).toBe('✓✗○');
+    });
+
+    it('should format single task', () => {
+      const tasks: TaskStatus[] = ['running'];
+      const result = formatProgressBar(tasks);
+      expect(result).toBe('●');
+    });
+
+    it('should handle empty array', () => {
+      const result = formatProgressBar([]);
+      expect(result).toBe('');
+    });
+
+    it('should format blocked tasks', () => {
+      const tasks: TaskStatus[] = ['completed', 'failed', 'blocked', 'pending'];
+      const result = formatProgressBar(tasks);
+      expect(result).toBe('✓✗⊘○');
+    });
+  });
+});

package/tests/unit/timer.test.ts

@@ -0,0 +1,102 @@
+import { jest } from '@jest/globals';
+import { formatElapsedTime, createTaskTimer } from '../../src/utils/timer.js';
+
+describe('Timer', () => {
+  describe('formatElapsedTime', () => {
+    it('should format seconds only for less than a minute', () => {
+      expect(formatElapsedTime(0)).toBe('0s');
+      expect(formatElapsedTime(1000)).toBe('1s');
+      expect(formatElapsedTime(30000)).toBe('30s');
+      expect(formatElapsedTime(59000)).toBe('59s');
+    });
+
+    it('should format minutes and seconds for less than an hour', () => {
+      expect(formatElapsedTime(60000)).toBe('1m 0s');
+      expect(formatElapsedTime(90000)).toBe('1m 30s');
+      expect(formatElapsedTime(150000)).toBe('2m 30s');
+      expect(formatElapsedTime(3599000)).toBe('59m 59s');
+    });
+
+    it('should format hours and minutes for an hour or more', () => {
+      expect(formatElapsedTime(3600000)).toBe('1h 0m');
+      expect(formatElapsedTime(3660000)).toBe('1h 1m');
+      expect(formatElapsedTime(7200000)).toBe('2h 0m');
+      expect(formatElapsedTime(7290000)).toBe('2h 1m');
+      expect(formatElapsedTime(86400000)).toBe('24h 0m');
+    });
+
+    it('should round down to whole seconds', () => {
+      expect(formatElapsedTime(1500)).toBe('1s');
+      expect(formatElapsedTime(1999)).toBe('1s');
+    });
+  });
+
+  describe('createTaskTimer', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+
+    it('should track elapsed time', () => {
+      const timer = createTaskTimer();
+      timer.start();
+
+      jest.advanceTimersByTime(5000);
+      expect(timer.getElapsed()).toBeGreaterThanOrEqual(5000);
+
+      const elapsed = timer.stop();
+      expect(elapsed).toBeGreaterThanOrEqual(5000);
+    });
+
+    it('should return 0 when stopped before starting', () => {
+      const timer = createTaskTimer();
+      expect(timer.stop()).toBe(0);
+    });
+
+    it('should return 0 for getElapsed when not started', () => {
+      const timer = createTaskTimer();
+      expect(timer.getElapsed()).toBe(0);
+    });
+
+    it('should call onTick callback immediately and every second', () => {
+      const onTick = jest.fn();
+      const timer = createTaskTimer(onTick);
+
+      timer.start();
+      expect(onTick).toHaveBeenCalledWith(0);
+
+      jest.advanceTimersByTime(1000);
+      expect(onTick).toHaveBeenCalledTimes(2);
+
+      jest.advanceTimersByTime(2000);
+      expect(onTick).toHaveBeenCalledTimes(4);
+
+      timer.stop();
+    });
+
+    it('should stop calling onTick after stop()', () => {
+      const onTick = jest.fn();
+      const timer = createTaskTimer(onTick);
+
+      timer.start();
+      jest.advanceTimersByTime(2000);
+      const callCount = onTick.mock.calls.length;
+
+      timer.stop();
+      jest.advanceTimersByTime(5000);
+
+      expect(onTick.mock.calls.length).toBe(callCount);
+    });
+
+    it('should not call onTick when not provided', () => {
+      const timer = createTaskTimer();
+      timer.start();
+      jest.advanceTimersByTime(5000);
+      timer.stop();
+      // No assertion needed - just checking it doesn't throw
+    });
+  });
+});