maskweaver 0.9.4 → 0.9.6

package/dist/shared-context/test/storage.test.js

@@ -1,176 +1,114 @@
-/**
- * Storage Adapter Unit Tests
- *
- * "First make it work, then make it right, then make it fast."
- * - Kent Beck
- *
- * @author Kent Beck's Dummy Human
- */
 import { test, expect, describe, beforeEach, afterEach } from "vitest";
 import { mkdtemp, rm, readFile, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
 import { validatePath, FileStorageAdapter } from "../storage.js";
-// ============================================================
-// validatePath Tests - Path Traversal Prevention
-// ============================================================
 describe("validatePath", () => {
     const baseDir = "/home/user/data";
     test("should allow valid paths within base directory", () => {
-        // Arrange & Act & Assert
         expect(validatePath("/home/user/data/file.json", baseDir)).toBe(true);
         expect(validatePath("/home/user/data/sub/file.json", baseDir)).toBe(true);
     });
     test("should reject paths containing '..' (Path Traversal attack)", () => {
-        // Arrange
         const maliciousPath = "/home/user/data/../secret/passwords.json";
-        // Act & Assert
         expect(validatePath(maliciousPath, baseDir)).toBe(false);
     });
     test("should reject paths outside base directory", () => {
-        // Arrange
         const outsidePath = "/home/user/other/file.json";
-        // Act & Assert
         expect(validatePath(outsidePath, baseDir)).toBe(false);
     });
     test("should reject hidden path traversal attempts", () => {
-        // Arrange - Various traversal attempts
         const traversalAttempts = [
             "/home/user/data/../../etc/passwd",
             "/home/user/data/sub/../../../root",
             "/home/user/data/..\\windows\\system32",
         ];
-        // Act & Assert
         for (const path of traversalAttempts) {
             expect(validatePath(path, baseDir)).toBe(false);
         }
     });
 });
-// ============================================================
-// FileStorageAdapter Tests
-// ============================================================
 describe("FileStorageAdapter", () => {
     let tempDir;
     let storage;
     beforeEach(async () => {
-        // Create isolated temp directory for each test
         tempDir = await mkdtemp(join(tmpdir(), "storage-test-"));
         storage = new FileStorageAdapter(tempDir);
     });
     afterEach(async () => {
-        // Clean up temp directory
         await rm(tempDir, { recursive: true, force: true });
     });
-    // ----------------------------------------------------------
-    // write & read Tests
-    // ----------------------------------------------------------
     describe("write and read", () => {
         test("should write and read JSON data successfully", async () => {
-            // Arrange
             const testData = { name: "Kent Beck", role: "TDD Master" };
             const path = "test.json";
-            // Act
             await storage.write(path, testData);
             const result = await storage.read(path);
-            // Assert
             expect(result).toEqual(testData);
         });
         test("should return null when reading non-existent file", async () => {
-            // Arrange
             const path = "non-existent.json";
-            // Act
             const result = await storage.read(path);
-            // Assert
             expect(result).toBeNull();
         });
         test("should handle nested paths correctly", async () => {
-            // Arrange
             const testData = { nested: true };
             const path = "deep/nested/path/data.json";
-            // Act
             await storage.write(path, testData);
             const result = await storage.read(path);
-            // Assert
             expect(result).toEqual(testData);
         });
         test("should throw error on Path Traversal in read", async () => {
-            // Arrange
             const maliciousPath = "../../../etc/passwd";
-            // Act & Assert
             await expect(storage.read(maliciousPath)).rejects.toThrow("Path traversal detected");
         });
         test("should throw error on Path Traversal in write", async () => {
-            // Arrange
             const maliciousPath = "../../../tmp/hack.json";
             const data = { hacked: true };
-            // Act & Assert
             await expect(storage.write(maliciousPath, data)).rejects.toThrow("Path traversal detected");
         });
     });
-    // ----------------------------------------------------------
-    // append Tests
-    // ----------------------------------------------------------
     describe("append", () => {
         test("should append line to file", async () => {
-            // Arrange
             const path = "log.txt";
             const line1 = "First line";
             const line2 = "Second line";
-            // Act
             await storage.append(path, line1);
             await storage.append(path, line2);
-            // Assert - Read raw file content
             const fullPath = storage.getFullPath(path);
             const content = await readFile(fullPath, "utf-8");
             expect(content).toBe("First line\nSecond line\n");
         });
         test("should throw error on Path Traversal in append", async () => {
-            // Arrange
             const maliciousPath = "../../../tmp/inject.txt";
-            // Act & Assert
             await expect(storage.append(maliciousPath, "hacked")).rejects.toThrow("Path traversal detected");
         });
     });
-    // ----------------------------------------------------------
-    // exists Tests
-    // ----------------------------------------------------------
     describe("exists", () => {
         test("should return true for existing file", async () => {
-            // Arrange
             const path = "exists.json";
             await storage.write(path, { exists: true });
-            // Act & Assert
             expect(storage.exists(path)).toBe(true);
         });
         test("should return false for non-existing file", () => {
-            // Arrange
             const path = "ghost.json";
-            // Act & Assert
             expect(storage.exists(path)).toBe(false);
         });
     });
-    // ----------------------------------------------------------
-    // ensureDir Tests
-    // ----------------------------------------------------------
     describe("ensureDir", () => {
         test("should create nested directories", async () => {
-            // Arrange - use absolute path directly (ensureDir takes absolute paths)
             const nestedPath = join(tempDir, "level1", "level2", "level3");
-            // Act - ensureDir expects absolute paths
             const { mkdir } = await import("fs/promises");
             await mkdir(nestedPath, { recursive: true });
-            // Assert - Write a file to verify directory exists
             const testFile = join(nestedPath, "test.txt");
             await writeFile(testFile, "test");
             const content = await readFile(testFile, "utf-8");
             expect(content).toBe("test");
         });
         test("should not throw when directory already exists", async () => {
-            // Arrange - use absolute path directly
             const existingPath = join(tempDir, "existing");
             const { mkdir } = await import("fs/promises");
             await mkdir(existingPath, { recursive: true });
-            // Act & Assert - mkdir with recursive: true is idempotent
             let error = null;
             try {
                 await mkdir(existingPath, { recursive: true });
@@ -181,16 +119,10 @@ describe("FileStorageAdapter", () => {
             expect(error).toBeNull();
         });
     });
-    // ----------------------------------------------------------
-    // getFullPath Tests
-    // ----------------------------------------------------------
     describe("getFullPath", () => {
         test("should return correct full path", () => {
-            // Arrange
             const relativePath = "sub/data.json";
-            // Act
             const fullPath = storage.getFullPath(relativePath);
-            // Assert
             expect(fullPath).toBe(join(tempDir, "sub/data.json"));
         });
     });

package/dist/shared-context/test/task.test.d.ts

@@ -1,8 +1 @@
-/**
- * Task Management Tests
- *
- * "테스트가 없으면 버그가 아니다" - Kent Beck
- *
- * @author Kent Beck's TDD Approach
- */
 export {};

package/dist/shared-context/test/task.test.js

@@ -1,10 +1,3 @@
-/**
- * Task Management Tests
- *
- * "테스트가 없으면 버그가 아니다" - Kent Beck
- *
- * @author Kent Beck's TDD Approach
- */
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
@@ -15,9 +8,6 @@ import { createSession } from "../session.js";
 import { createSquad, getSquad } from "../squad.js";
 import { assignTask, getTask, updateTask, completeTask } from "../task.js";
 import { LIMITS } from "../types.js";
-// ============================================================================
-// Test Fixtures
-// ============================================================================
 let tempDir;
 let storage;
 let session;
@@ -40,9 +30,6 @@ afterEach(async () => {
         await rm(tempDir, { recursive: true, force: true });
     }
 });
-// ============================================================================
-// assignTask Tests
-// ============================================================================
 describe("assignTask", () => {
     test("should successfully assign a task to a squad", async () => {
         const task = await assignTask(session, squadId, {
@@ -71,14 +58,12 @@ describe("assignTask", () => {
         })).rejects.toThrow("Squad not found: squad-nonexistent");
     });
     test("should throw ValidationError when max tasks per squad exceeded", async () => {
-        // Arrange: 최대 개수만큼 Task 생성
         for (let i = 0; i < LIMITS.maxTasksPerSquad; i++) {
             await assignTask(session, squadId, {
                 assignee: `worker-${i}`,
                 description: `Task ${i}`,
             });
         }
-        // Act & Assert: 한도 초과 시 에러
         await expect(assignTask(session, squadId, {
             assignee: "worker-overflow",
             description: "One too many",
@@ -141,9 +126,6 @@ describe("assignTask", () => {
         expect(squad?.state.tasks.map((t) => t.taskId)).toContain(task3.taskId);
     });
 });
-// ============================================================================
-// updateTask Tests - State Transition through Aggregate Root
-// ============================================================================
 describe("updateTask", () => {
     test("should successfully update a task status", async () => {
         const task = await assignTask(session, squadId, {
@@ -232,20 +214,14 @@ describe("updateTask", () => {
         expect(completed.result).toEqual({ done: true });
     });
 });
-// ============================================================================
-// getTask Tests - Domain Entity Lookup
-// ============================================================================
 describe("getTask", () => {
     test("should return task when it exists", async () => {
-        // Arrange: assign a task
         const createdTask = await assignTask(session, squadId, {
             assignee: "worker-1",
             description: "Find me later",
             priority: "high",
         });
-        // Act: retrieve the task
         const foundTask = await getTask(session, squadId, createdTask.taskId);
-        // Assert: task should match
         expect(foundTask).not.toBeNull();
         expect(foundTask?.taskId).toBe(createdTask.taskId);
         expect(foundTask?.description).toBe("Find me later");
@@ -253,17 +229,13 @@ describe("getTask", () => {
         expect(foundTask?.priority).toBe("high");
     });
     test("should return null when task does not exist", async () => {
-        // Act: try to find non-existent task
         const result = await getTask(session, squadId, "task-nonexistent");
-        // Assert: should be null, not throw
         expect(result).toBeNull();
     });
     test("should throw StorageError when squad does not exist", async () => {
-        // Act & Assert: should throw for missing squad
         await expect(getTask(session, "squad-nonexistent", "task-12345678")).rejects.toThrow("Squad not found: squad-nonexistent");
     });
     test("should find correct task among multiple tasks", async () => {
-        // Arrange: create multiple tasks
         const task1 = await assignTask(session, squadId, {
             assignee: "worker-1",
             description: "First task",
@@ -276,24 +248,19 @@ describe("getTask", () => {
             assignee: "worker-3",
             description: "Third task",
         });
-        // Act: find the middle task
         const foundTask = await getTask(session, squadId, task2.taskId);
-        // Assert: should find correct task
         expect(foundTask).not.toBeNull();
         expect(foundTask?.taskId).toBe(task2.taskId);
         expect(foundTask?.description).toBe("Second task");
     });
     test("should return task with all fields intact", async () => {
-        // Arrange: create task with all optional fields
         const createdTask = await assignTask(session, squadId, {
             assignee: "worker-alpha",
             description: "Complete task with all fields",
             priority: "critical",
             dependencies: ["dep-1", "dep-2"],
         });
-        // Act: retrieve the task
         const foundTask = await getTask(session, squadId, createdTask.taskId);
-        // Assert: all fields should be preserved
         expect(foundTask).not.toBeNull();
         expect(foundTask?.status).toBe("pending");
         expect(foundTask?.priority).toBe("critical");
@@ -301,9 +268,6 @@ describe("getTask", () => {
         expect(foundTask?.createdAt).toBe(createdTask.createdAt);
     });
 });
-// ============================================================================
-// completeTask Tests - Convenience Wrapper for Task Completion
-// ============================================================================
 describe("completeTask", () => {
     test("should mark task as completed on success", async () => {
         const task = await assignTask(session, squadId, {
@@ -354,13 +318,8 @@ describe("completeTask", () => {
         expect(found?.result).toEqual(result);
     });
 });
-// ============================================================================
-// Task Lifecycle Integration Tests
-// ============================================================================
 describe("Task Lifecycle Integration", () => {
     test("full task lifecycle: assign → start → complete", async () => {
-        // 1. 세션과 squad는 beforeEach에서 이미 생성됨
-        // 2. assignTask()로 task 할당
         const task = await assignTask(session, squadId, {
             assignee: "worker-alpha",
             description: "Integration test task",
@@ -369,7 +328,6 @@ describe("Task Lifecycle Integration", () => {
         expect(task.status).toBe("pending");
         expect(task.startedAt).toBeUndefined();
         expect(task.completedAt).toBeUndefined();
-        // 3. updateTask()로 status: "active", startedAt 설정
         const startedAt = new Date().toISOString();
         const activeTask = await updateTask(session, squadId, task.taskId, {
             status: "active",
@@ -377,7 +335,6 @@ describe("Task Lifecycle Integration", () => {
         });
         expect(activeTask.status).toBe("active");
         expect(activeTask.startedAt).toBe(startedAt);
-        // 4. completeTask()로 성공 결과와 함께 완료
         const result = {
             success: true,
             output: { filesCreated: ["src/auth.ts", "src/auth.test.ts"] },
@@ -387,7 +344,6 @@ describe("Task Lifecycle Integration", () => {
         expect(completedTask.status).toBe("completed");
         expect(completedTask.completedAt).toBeDefined();
         expect(completedTask.result).toEqual(result);
-        // 5. getTask()로 최종 상태 확인
         const finalTask = await getTask(session, squadId, task.taskId);
         expect(finalTask).not.toBeNull();
         expect(finalTask?.status).toBe("completed");
@@ -398,20 +354,17 @@ describe("Task Lifecycle Integration", () => {
         expect(finalTask?.priority).toBe("high");
     });
     test("failed task lifecycle: assign → start → fail", async () => {
-        // 1. assignTask()로 task 할당
         const task = await assignTask(session, squadId, {
             assignee: "worker-beta",
             description: "This task will fail",
             priority: "critical",
         });
         expect(task.status).toBe("pending");
-        // 2. updateTask()로 시작
         const startedAt = new Date().toISOString();
         await updateTask(session, squadId, task.taskId, {
             status: "active",
             startedAt,
         });
-        // 3. completeTask()로 실패 결과와 함께 완료
         const result = {
             success: false,
             error: {
@@ -424,13 +377,11 @@ describe("Task Lifecycle Integration", () => {
         expect(failedTask.status).toBe("failed");
         expect(failedTask.completedAt).toBeDefined();
         expect(failedTask.result).toEqual(result);
-        // 4. getTask()로 최종 상태 확인
         const finalTask = await getTask(session, squadId, task.taskId);
         expect(finalTask?.status).toBe("failed");
         expect(finalTask?.startedAt).toBe(startedAt);
     });
     test("multiple tasks in squad lifecycle", async () => {
-        // 여러 태스크가 독립적으로 실행되는 시나리오
         const task1 = await assignTask(session, squadId, {
             assignee: "worker-1",
             description: "Task 1",
@@ -439,27 +390,22 @@ describe("Task Lifecycle Integration", () => {
             assignee: "worker-2",
             description: "Task 2",
         });
-        // task1 시작
         await updateTask(session, squadId, task1.taskId, {
             status: "active",
             startedAt: new Date().toISOString(),
         });
-        // task2 시작
         await updateTask(session, squadId, task2.taskId, {
             status: "active",
             startedAt: new Date().toISOString(),
         });
-        // task1 완료
         await completeTask(session, squadId, task1.taskId, {
             success: true,
             output: "Task 1 done",
         });
-        // task2 실패
         await completeTask(session, squadId, task2.taskId, {
             success: false,
             error: { code: "ERROR", message: "Task 2 failed" },
         });
-        // 최종 상태 확인
         const squad = await getSquad(session, squadId);
         expect(squad?.state.tasks).toHaveLength(2);
         const t1 = squad?.state.tasks.find((t) => t.taskId === task1.taskId);

package/dist/shared-context/test/watchdog.test.d.ts

@@ -1,8 +1 @@
-/**
- * Watchdog Tests - Squad Timeout Monitoring
- *
- * "If you can't measure it, you can't improve it." - Brendan Gregg
- *
- * @author Kent Beck's TDD Approach
- */
 export {};

package/dist/shared-context/test/watchdog.test.js

@@ -1,10 +1,3 @@
-/**
- * Watchdog Tests - Squad Timeout Monitoring
- *
- * "If you can't measure it, you can't improve it." - Brendan Gregg
- *
- * @author Kent Beck's TDD Approach
- */
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { mkdtemp, rm } from "fs/promises";
 import { tmpdir } from "os";
@@ -16,9 +9,6 @@ import { createSquad, getSquad, updateSquadState } from "../squad.js";
 import { assignTask, updateTask } from "../task.js";
 import { checkSquadTimeout, checkTaskTimeout, markSquadExpired, runWatchdog } from "../watchdog.js";
 import { LIMITS } from "../types.js";
-// ============================================================================
-// Test Fixtures
-// ============================================================================
 let tempDir;
 let storage;
 let session;
@@ -41,9 +31,6 @@ afterEach(async () => {
         await rm(tempDir, { recursive: true, force: true });
     }
 });
-// ============================================================================
-// Helper Functions
-// ============================================================================
 function createMockSquadState(updatedAt) {
     return {
         squadId: "squad-mock",
@@ -65,9 +52,6 @@ function createMockTaskState(options) {
         startedAt: options.startedAt,
     };
 }
-// ============================================================================
-// checkSquadTimeout Tests
-// ============================================================================
 describe("checkSquadTimeout", () => {
     test("should return isExpired: false before timeout", () => {
         const now = new Date();
@@ -101,7 +85,7 @@ describe("checkSquadTimeout", () => {
         const now = new Date();
         const twoMinutesAgo = new Date(now.getTime() - 2 * 60 * 1000);
         const squadState = createMockSquadState(twoMinutesAgo.toISOString());
-        const customTimeoutMs = 60 * 1000; // 1분
+        const customTimeoutMs = 60 * 1000;
         const status = checkSquadTimeout(squadState, customTimeoutMs);
         expect(status.isExpired).toBe(true);
         expect(status.elapsedMs).toBeGreaterThanOrEqual(2 * 60 * 1000);
@@ -110,7 +94,7 @@ describe("checkSquadTimeout", () => {
         const now = new Date();
         const tenMinutesAgo = new Date(now.getTime() - 10 * 60 * 1000);
         const squadState = createMockSquadState(tenMinutesAgo.toISOString());
-        const customTimeoutMs = 30 * 60 * 1000; // 30분
+        const customTimeoutMs = 30 * 60 * 1000;
         const status = checkSquadTimeout(squadState, customTimeoutMs);
         expect(status.isExpired).toBe(false);
         expect(status.remainingMs).toBeGreaterThan(0);
@@ -131,9 +115,6 @@ describe("checkSquadTimeout", () => {
         expect(status.lastActivityAt).toBe(timestamp);
     });
 });
-// ============================================================================
-// markSquadExpired Tests
-// ============================================================================
 describe("markSquadExpired", () => {
     test("should change status to 'failed'", async () => {
         const squad = await getSquad(session, squadId);
@@ -178,29 +159,20 @@ describe("markSquadExpired", () => {
         expect(expiredState.sharedContext).toEqual({ key: "value" });
     });
 });
-// ============================================================================
-// checkTaskTimeout Tests - Fine-grained task observability
-// ============================================================================
 describe("checkTaskTimeout", () => {
     test("should return null for task that hasn't started", () => {
-        // Arrange: task without startedAt (pending task)
         const task = createMockTaskState({ status: "pending" });
-        // Act
         const status = checkTaskTimeout(task);
-        // Assert: null means no timeout check needed
         expect(status).toBeNull();
     });
     test("should return isExpired: false for recently started task", () => {
-        // Arrange: task started 1 minute ago
         const now = new Date();
         const oneMinuteAgo = new Date(now.getTime() - 60 * 1000);
         const task = createMockTaskState({
             startedAt: oneMinuteAgo.toISOString(),
             status: "active",
         });
-        // Act
         const status = checkTaskTimeout(task);
-        // Assert
         expect(status).not.toBeNull();
         expect(status.isExpired).toBe(false);
         expect(status.elapsedMs).toBeGreaterThanOrEqual(60 * 1000);
@@ -208,59 +180,45 @@ describe("checkTaskTimeout", () => {
         expect(status.lastActivityAt).toBe(oneMinuteAgo.toISOString());
     });
     test("should return isExpired: true for expired task", () => {
-        // Arrange: task started 10 minutes ago (beyond 5 min default)
         const now = new Date();
         const tenMinutesAgo = new Date(now.getTime() - 10 * 60 * 1000);
         const task = createMockTaskState({
             startedAt: tenMinutesAgo.toISOString(),
             status: "active",
         });
-        // Act
         const status = checkTaskTimeout(task);
-        // Assert
         expect(status).not.toBeNull();
         expect(status.isExpired).toBe(true);
         expect(status.elapsedMs).toBeGreaterThanOrEqual(10 * 60 * 1000);
         expect(status.remainingMs).toBeLessThan(0);
     });
     test("should respect custom timeout parameter", () => {
-        // Arrange: task started 2 minutes ago
         const now = new Date();
         const twoMinutesAgo = new Date(now.getTime() - 2 * 60 * 1000);
         const task = createMockTaskState({
             startedAt: twoMinutesAgo.toISOString(),
             status: "active",
         });
-        const customTimeoutMs = 60 * 1000; // 1 minute
-        // Act
+        const customTimeoutMs = 60 * 1000;
         const status = checkTaskTimeout(task, customTimeoutMs);
-        // Assert: 2 minutes > 1 minute, should be expired
         expect(status).not.toBeNull();
         expect(status.isExpired).toBe(true);
     });
     test("should use default LIMITS.watchdogTimeoutMs when no timeout specified", () => {
-        // Arrange: task started 3 minutes ago (within default 5 min)
         const now = new Date();
         const threeMinutesAgo = new Date(now.getTime() - 3 * 60 * 1000);
         const task = createMockTaskState({
             startedAt: threeMinutesAgo.toISOString(),
             status: "active",
         });
-        // Act
         const status = checkTaskTimeout(task);
-        // Assert: 3 minutes < 5 minutes, should not be expired
         expect(status).not.toBeNull();
         expect(status.isExpired).toBe(false);
         expect(status.remainingMs).toBeGreaterThan(0);
     });
 });
-// ============================================================================
-// runWatchdog Tests - Periodic Health Check
-// "If you can't measure it, you can't improve it." - Brendan Gregg
-// ============================================================================
 describe("runWatchdog", () => {
     test("should return empty results for fresh squads", async () => {
-        // Squad was just created, not expired yet
         const summary = await runWatchdog(session);
         expect(summary.checkedSquads).toBe(1);
         expect(summary.checkedTasks).toBe(0);
@@ -268,9 +226,7 @@ describe("runWatchdog", () => {
         expect(summary.expiredTasks).toHaveLength(0);
     });
     test("should detect expired squad", async () => {
-        // Simulate squad that was updated 10 minutes ago
         const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
-        // Manually update the squad's updatedAt via storage (simulate old state)
         const squadPath = `${session.sessionPath}/squads/${squadId}/state.json`;
         const currentState = await session.storage.read(squadPath);
         await session.storage.write(squadPath, {
@@ -283,7 +239,6 @@ describe("runWatchdog", () => {
         expect(summary.expiredSquads).toHaveLength(1);
     });
     test("should mark expired squad as failed when not in dryRun mode", async () => {
-        // Simulate old squad
         const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
         const squadPath = `${session.sessionPath}/squads/${squadId}/state.json`;
         const currentState = await session.storage.read(squadPath);
@@ -297,7 +252,6 @@ describe("runWatchdog", () => {
         expect(squad?.state.status).toBe("failed");
     });
     test("should NOT mark expired squad as failed in dryRun mode", async () => {
-        // Simulate old squad
         const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
         const squadPath = `${session.sessionPath}/squads/${squadId}/state.json`;
         const currentState = await session.storage.read(squadPath);
@@ -308,17 +262,14 @@ describe("runWatchdog", () => {
         });
         const summary = await runWatchdog(session, { dryRun: true });
         expect(summary.expiredSquads).toContain(squadId);
-        // Squad should still be active (not mutated)
         const squad = await getSquad(session, squadId);
         expect(squad?.state.status).toBe("active");
     });
     test("should detect expired tasks", async () => {
-        // Create and start a task
         const task = await assignTask(session, squadId, {
             assignee: "worker-1",
             description: "Long running task",
         });
-        // Start the task with old startedAt (10 minutes ago)
         const tenMinutesAgo = new Date(Date.now() - 10 * 60 * 1000).toISOString();
         await updateTask(session, squadId, task.taskId, {
             status: "active",
@@ -348,7 +299,6 @@ describe("runWatchdog", () => {
         expect(updatedTask?.result).toBeDefined();
     });
     test("should use custom timeouts", async () => {
-        // Create a task that started 2 minutes ago
         const task = await assignTask(session, squadId, {
             assignee: "worker-1",
             description: "Quick task",
@@ -358,10 +308,8 @@ describe("runWatchdog", () => {
             status: "active",
             startedAt: twoMinutesAgo,
         });
-        // With default timeout (5 min), should NOT be expired
         const defaultSummary = await runWatchdog(session, { dryRun: true });
         expect(defaultSummary.expiredTasks).toHaveLength(0);
-        // With short timeout (1 min), SHOULD be expired
         const shortSummary = await runWatchdog(session, {
             taskTimeoutMs: 60 * 1000,
             dryRun: true,
@@ -372,7 +320,6 @@ describe("runWatchdog", () => {
         await updateSquadState(session, squadId, {
             status: "completed",
         });
-        // Even with old updatedAt, completed squads are skipped
         const squadPath = `${session.sessionPath}/squads/${squadId}/state.json`;
         const currentState = await session.storage.read(squadPath);
         await session.storage.write(squadPath, {
@@ -384,12 +331,10 @@ describe("runWatchdog", () => {
         expect(summary.expiredSquads).toHaveLength(0);
     });
     test("should only check active tasks with startedAt", async () => {
-        // Task 1: pending (no startedAt) - should not be checked
         await assignTask(session, squadId, {
             assignee: "worker-1",
             description: "Pending task",
         });
-        // Task 2: active with startedAt - should be checked
         const activeTask = await assignTask(session, squadId, {
             assignee: "worker-2",
             description: "Active task",