@task-mcp/shared 1.0.21 → 1.0.23

package/README.md

@@ -0,0 +1,122 @@
+# @task-mcp/shared
+
+Core algorithms, schemas, and utilities for task-mcp. Zero MCP dependency - can be used standalone.
+
+## Installation
+
+```bash
+npm install @task-mcp/shared
+```
+
+## Modules
+
+### Algorithms
+
+Graph algorithms for task dependency management.
+
+| Module | Description |
+|--------|-------------|
+| `critical-path` | CPM (Critical Path Method) - finds longest path, parallel tasks, bottlenecks |
+| `topological-sort` | Kahn's algorithm for dependency ordering with cycle detection |
+| `dependency-integrity` | Validates dependency graph integrity (cycles, orphans, self-refs) |
+| `tech-analysis` | Analyzes tasks for technology stack patterns |
+
+```typescript
+import {
+  findCriticalPath,
+  findParallelTasks,
+  detectBottlenecks,
+  topologicalSort,
+  validateDependencies
+} from "@task-mcp/shared";
+
+// Find critical path through task graph
+const { criticalPath, totalDuration } = findCriticalPath(tasks);
+
+// Find tasks that can run in parallel
+const parallelGroups = findParallelTasks(tasks);
+
+// Topological sort with cycle detection
+const { sorted, hasCycle } = topologicalSort(tasks);
+```
+
+### Schemas
+
+Zod schemas for validation and type inference.
+
+| Schema | Description |
+|--------|-------------|
+| `Task` | Task with status, priority, dependencies, hierarchy |
+| `InboxItem` | Quick capture items pending triage |
+| `ResponseFormat` | `concise` / `standard` / `detailed` output modes |
+| `View` | Filtered task views (today, blocked, quick-wins) |
+
+```typescript
+import { TaskSchema, Task, Priority, Status } from "@task-mcp/shared";
+
+// Validate and parse
+const task = TaskSchema.parse(rawData);
+
+// Type inference
+type Task = z.infer<typeof TaskSchema>;
+```
+
+### Utilities
+
+| Utility | Description |
+|---------|-------------|
+| `natural-language` | Parse "task !high @context #tag due:tomorrow" syntax |
+| `workspace` | Auto-detect workspace from git repository name |
+| `projection` | Format tasks to concise/standard/detailed (70-88% token savings) |
+| `hierarchy` | Build parent-child tree, find descendants/ancestors |
+| `date` | Parse relative dates ("tomorrow", "next week", "in 3 days") |
+| `id` | Generate collision-resistant IDs (`task_xxxx`, `inbox_xxxx`) |
+
+```typescript
+import {
+  parseNaturalLanguage,
+  detectWorkspace,
+  formatTask,
+  buildHierarchy
+} from "@task-mcp/shared";
+
+// Parse natural language input
+const parsed = parseNaturalLanguage("Review PR !high @work #urgent due:tomorrow");
+// { title: "Review PR", priority: "high", contexts: ["work"], tags: ["urgent"], dueDate: "2024-01-02" }
+
+// Detect workspace from git
+const workspace = await detectWorkspace(); // "task-mcp"
+
+// Format for token efficiency
+const concise = formatTask(task, "concise");
+// { id, title, status, priority } - minimal fields
+```
+
+## Architecture
+
+```
+shared/
+├── algorithms/     # Graph algorithms (no external deps)
+│   ├── critical-path.ts
+│   ├── topological-sort.ts
+│   └── dependency-integrity.ts
+├── schemas/        # Zod schemas + type exports
+│   ├── task.ts
+│   ├── inbox.ts
+│   └── response-format.ts
+└── utils/          # Pure utility functions
+    ├── natural-language.ts
+    ├── workspace.ts
+    └── projection.ts
+```
+
+## Design Principles
+
+1. **Zero MCP dependency** - Can be used in any TypeScript project
+2. **Zod-first validation** - Runtime safety with static types
+3. **Algorithm efficiency** - O(n+e) graph operations
+4. **Token optimization** - Projection system reduces LLM token usage by 70-88%
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task-mcp/shared",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "description": "Shared utilities for task-mcp: types, algorithms, and natural language parsing",
   "type": "module",
   "main": "./dist/index.js",

package/src/algorithms/critical-path.ts

@@ -1,9 +1,5 @@
 import type { Task } from "../schemas/task.js";
-import {
-  topologicalSort,
-  findDependents,
-  priorityToNumber,
-} from "./topological-sort.js";
+import { topologicalSort, priorityToNumber } from "./topological-sort.js";
 
 /**
  * Task with computed CPM (Critical Path Method) values
@@ -43,9 +39,7 @@ function getTaskDuration(task: Task): number {
  * Get blocked_by dependencies for a task
  */
 function getBlockedByDeps(task: Task): string[] {
-  return (task.dependencies ?? [])
-    .filter((d) => d.type === "blocked_by")
-    .map((d) => d.taskId);
+  return (task.dependencies ?? []).filter((d) => d.type === "blocked_by").map((d) => d.taskId);
 }
 
 /**
@@ -110,7 +104,10 @@ function calculateProjectDuration(taskMap: Map<string, CPMTask>): number {
  * This is O(n * d) where d is average dependencies, done once upfront
  * Allows O(1) successor lookup instead of O(n) per task
  */
-function buildSuccessorIndex(sortedTasks: Task[], taskMap: Map<string, CPMTask>): Map<string, CPMTask[]> {
+function buildSuccessorIndex(
+  sortedTasks: Task[],
+  taskMap: Map<string, CPMTask>
+): Map<string, CPMTask[]> {
   const successorIndex = new Map<string, CPMTask[]>();
 
   // Initialize empty arrays for all tasks
@@ -244,9 +241,7 @@ function extractCriticalPath(sortedTasks: Task[], taskMap: Map<string, CPMTask>)
  * Find top bottlenecks (critical tasks blocking the most downstream work)
  */
 function findBottlenecks(criticalPath: CPMTask[], limit = 5): CPMTask[] {
-  return [...criticalPath]
-    .sort((a, b) => b.dependentCount - a.dependentCount)
-    .slice(0, limit);
+  return [...criticalPath].sort((a, b) => b.dependentCount - a.dependentCount).slice(0, limit);
 }
 
 /**
@@ -262,9 +257,7 @@ function findBottlenecks(criticalPath: CPMTask[], limit = 5): CPMTask[] {
  */
 export function criticalPathAnalysis(tasks: Task[]): CPMResult {
   // Filter to only pending/in_progress tasks
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) {
     return {
@@ -315,18 +308,15 @@ export function criticalPathAnalysis(tasks: Task[]): CPMResult {
 
 /**
  * Find tasks that can be executed in parallel (no dependencies between them)
+ * Optimized to O(n + e) where n = number of tasks, e = number of dependencies
  */
 export function findParallelTasks(tasks: Task[]): Task[][] {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) return [];
 
   // Find tasks with no uncompleted dependencies
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   const available = activeTasks.filter((task) => {
     const deps = getBlockedByDeps(task);
@@ -335,7 +325,26 @@ export function findParallelTasks(tasks: Task[]): Task[][] {
 
   if (available.length <= 1) return [available];
 
-  // Group tasks that don't depend on each other
+  // Build dependency Sets for O(1) lookup - O(n + e) total
+  const dependsOn = new Map<string, Set<string>>();
+  for (const task of available) {
+    const deps = (task.dependencies ?? []).map((d) => d.taskId);
+    dependsOn.set(task.id, new Set(deps));
+  }
+
+  // Build reverse dependency index (who depends on me) - O(e) total
+  const dependedBy = new Map<string, Set<string>>();
+  for (const task of available) {
+    dependedBy.set(task.id, new Set());
+  }
+  for (const task of available) {
+    const deps = dependsOn.get(task.id) ?? new Set();
+    for (const depId of deps) {
+      dependedBy.get(depId)?.add(task.id);
+    }
+  }
+
+  // Group tasks that don't depend on each other - O(n + e)
   const groups: Task[][] = [];
   const processed = new Set<string>();
 
@@ -345,15 +354,18 @@ export function findParallelTasks(tasks: Task[]): Task[][] {
     const group: Task[] = [task];
     processed.add(task.id);
 
+    // Get all tasks that this task depends on or that depend on this task
+    const conflicting = new Set<string>();
+    const taskDeps = dependsOn.get(task.id) ?? new Set();
+    const taskDependedBy = dependedBy.get(task.id) ?? new Set();
+    for (const id of taskDeps) conflicting.add(id);
+    for (const id of taskDependedBy) conflicting.add(id);
+
     for (const other of available) {
       if (processed.has(other.id)) continue;
 
-      // Check if these tasks are independent
-      const taskDeps = (task.dependencies ?? []).map((d) => d.taskId);
-      const otherDeps = (other.dependencies ?? []).map((d) => d.taskId);
-
-      const independent =
-        !taskDeps.includes(other.id) && !otherDeps.includes(task.id);
+      // O(1) check: tasks are independent if neither depends on the other
+      const independent = !conflicting.has(other.id) && !dependsOn.get(other.id)?.has(task.id);
 
       if (independent) {
         group.push(other);
@@ -377,9 +389,7 @@ export function suggestNextTask(
     maxMinutes?: number;
   } = {}
 ): Task | null {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) return null;
 
@@ -387,9 +397,7 @@ export function suggestNextTask(
   const cpm = criticalPathAnalysis(tasks);
 
   // Filter by availability (all dependencies completed)
-  const completedIds = new Set(
-    tasks.filter((t) => t.status === "completed").map((t) => t.id)
-  );
+  const completedIds = new Set(tasks.filter((t) => t.status === "completed").map((t) => t.id));
 
   let candidates = cpm.tasks.filter((task) => {
     const deps = getBlockedByDeps(task);
@@ -409,9 +417,7 @@ export function suggestNextTask(
 
   // Filter by time if specified
   if (options.maxMinutes) {
-    const timeFiltered = candidates.filter(
-      (t) => getTaskDuration(t) <= options.maxMinutes!
-    );
+    const timeFiltered = candidates.filter((t) => getTaskDuration(t) <= options.maxMinutes!);
     if (timeFiltered.length > 0) {
       candidates = timeFiltered;
     }
@@ -434,4 +440,3 @@ export function suggestNextTask(
   scored.sort((a, b) => b.score - a.score);
   return scored[0]?.task ?? null;
 }
-

package/src/algorithms/dependency-integrity.ts

@@ -35,9 +35,7 @@ export interface ValidateDependencyOptions {
 /**
  * Validates if a dependency can be added between two tasks
  */
-export function validateDependency(
-  options: ValidateDependencyOptions
-): DependencyValidationResult {
+export function validateDependency(options: ValidateDependencyOptions): DependencyValidationResult {
   const { taskId, blockedBy, tasks, checkDuplicates = true } = options;
 
   // 1. Self-dependency check
@@ -50,8 +48,11 @@ export function validateDependency(
     };
   }
 
+  // Build taskMap once for O(1) lookups
+  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+
   // 2. Task existence check
-  const task = tasks.find((t) => t.id === taskId);
+  const task = taskMap.get(taskId);
   if (!task) {
     return {
       valid: false,
@@ -62,7 +63,7 @@ export function validateDependency(
   }
 
   // 3. Blocker task existence check
-  const blocker = tasks.find((t) => t.id === blockedBy);
+  const blocker = taskMap.get(blockedBy);
   if (!blocker) {
     return {
       valid: false,
@@ -114,9 +115,7 @@ export interface InvalidDependencyReference {
 /**
  * Find all invalid dependency references (orphaned references)
  */
-export function findInvalidDependencies(
-  tasks: Task[]
-): InvalidDependencyReference[] {
+export function findInvalidDependencies(tasks: Task[]): InvalidDependencyReference[] {
   const taskIds = new Set(tasks.map((t) => t.id));
   const invalid: InvalidDependencyReference[] = [];
 
@@ -239,17 +238,12 @@ export interface DependencyIntegrityReport {
 /**
  * Check overall dependency integrity of a project
  */
-export function checkDependencyIntegrity(
-  tasks: Task[]
-): DependencyIntegrityReport {
+export function checkDependencyIntegrity(tasks: Task[]): DependencyIntegrityReport {
   const selfDeps = findSelfDependencies(tasks);
   const invalidRefs = findInvalidDependencies(tasks);
   const cycles = detectCircularDependencies(tasks);
 
-  const totalDependencies = tasks.reduce(
-    (sum, t) => sum + (t.dependencies?.length ?? 0),
-    0
-  );
+  const totalDependencies = tasks.reduce((sum, t) => sum + (t.dependencies?.length ?? 0), 0);
 
   const issueCount = selfDeps.length + invalidRefs.length + cycles.length;
   const valid = issueCount === 0;

package/src/algorithms/tech-analysis.ts

@@ -5,14 +5,14 @@ import type { Task, TechArea, RiskLevel } from "../schemas/task.js";
  * Based on dependency flow: DB changes → Infrastructure → Backend → Frontend → Tests
  */
 const TECH_ORDER: Record<TechArea, number> = {
-  schema: 0,    // DB/schema changes first
-  infra: 0,     // Infrastructure setup
-  devops: 1,    // CI/CD pipelines
-  backend: 2,   // API/server
-  frontend: 3,  // UI
-  test: 4,      // Tests
-  docs: 4,      // Documentation
-  refactor: 5,  // Refactoring last
+  schema: 0, // DB/schema changes first
+  infra: 0, // Infrastructure setup
+  devops: 1, // CI/CD pipelines
+  backend: 2, // API/server
+  frontend: 3, // UI
+  test: 4, // Tests
+  docs: 4, // Documentation
+  refactor: 5, // Refactoring last
 };
 
 /**
@@ -143,9 +143,7 @@ function hasBreakingChange(task: Task): boolean {
  */
 export function suggestSafeOrder(tasks: Task[]): SafeOrderResult {
   // Filter to active tasks only
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   if (activeTasks.length === 0) {
     return {
@@ -175,7 +173,10 @@ export function suggestSafeOrder(tasks: Task[]): SafeOrderResult {
     if (aBreaking !== bBreaking) return aBreaking - bBreaking;
 
     // 4. Priority as tiebreaker (higher priority first)
-    return (PRIORITY_ORDER[a.priority] ?? DEFAULT_PRIORITY_ORDER) - (PRIORITY_ORDER[b.priority] ?? DEFAULT_PRIORITY_ORDER);
+    return (
+      (PRIORITY_ORDER[a.priority] ?? DEFAULT_PRIORITY_ORDER) -
+      (PRIORITY_ORDER[b.priority] ?? DEFAULT_PRIORITY_ORDER)
+    );
   });
 
   // Group into phases by tech level
@@ -258,9 +259,7 @@ function getPrimaryArea(task: Task): TechArea | "mixed" {
  */
 export function findBreakingChanges(tasks: Task[]): Task[] {
   return tasks.filter(
-    (t) =>
-      (t.status === "pending" || t.status === "in_progress") &&
-      hasBreakingChange(t)
+    (t) => (t.status === "pending" || t.status === "in_progress") && hasBreakingChange(t)
   );
 }
 
@@ -284,16 +283,21 @@ export function groupByTechArea(tasks: Task[]): Map<TechArea, Task[]> {
 
   // Initialize all groups
   const allAreas: TechArea[] = [
-    "schema", "infra", "devops", "backend", "frontend", "test", "docs", "refactor"
+    "schema",
+    "infra",
+    "devops",
+    "backend",
+    "frontend",
+    "test",
+    "docs",
+    "refactor",
   ];
   for (const area of allAreas) {
     groups.set(area, []);
   }
 
   // Group active tasks
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   for (const task of activeTasks) {
     const areas = task.techStack?.areas ?? [];
@@ -314,9 +318,9 @@ export function groupByTechArea(tasks: Task[]): Map<TechArea, Task[]> {
  * Complexity distribution by level
  */
 export interface ComplexityDistribution {
-  low: number;    // 1 to LOW_MAX
+  low: number; // 1 to LOW_MAX
   medium: number; // LOW_MAX+1 to MEDIUM_MAX
-  high: number;   // MEDIUM_MAX+1 to 10
+  high: number; // MEDIUM_MAX+1 to 10
 }
 
 /**
@@ -337,9 +341,7 @@ export interface ComplexitySummary {
  * Analyze complexity distribution across tasks
  */
 export function getComplexitySummary(tasks: Task[]): ComplexitySummary {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   const analyzed = activeTasks.filter((t) => t.complexity?.score !== undefined);
   const unanalyzed = activeTasks.filter((t) => t.complexity?.score === undefined);
@@ -394,9 +396,7 @@ export interface TechStackSummary {
  * Analyze tech stack distribution across tasks
  */
 export function getTechStackSummary(tasks: Task[]): TechStackSummary {
-  const activeTasks = tasks.filter(
-    (t) => t.status === "pending" || t.status === "in_progress"
-  );
+  const activeTasks = tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
 
   const analyzed = activeTasks.filter((t) => t.techStack?.areas !== undefined);
   const unanalyzed = activeTasks.filter((t) => t.techStack?.areas === undefined);

package/src/algorithms/topological-sort.ts

@@ -115,20 +115,13 @@ export function topologicalSort(tasks: Task[]): Task[] {
 /**
  * Detect if adding a dependency would create a cycle
  */
-export function wouldCreateCycle(
-  tasks: Task[],
-  fromId: string,
-  toId: string
-): boolean {
+export function wouldCreateCycle(tasks: Task[], fromId: string, toId: string): boolean {
   // Create a temporary task list with the new dependency
   const tempTasks = tasks.map((t) => {
     if (t.id === fromId) {
       return {
         ...t,
-        dependencies: [
-          ...(t.dependencies ?? []),
-          { taskId: toId, type: "blocked_by" as const },
-        ],
+        dependencies: [...(t.dependencies ?? []), { taskId: toId, type: "blocked_by" as const }],
       };
     }
     return t;
@@ -142,23 +135,76 @@ export function wouldCreateCycle(
   }
 }
 
+/**
+ * Build inverted indices for efficient dependency lookups
+ * Returns:
+ * - dependentsIndex: taskId -> [tasks that depend on this task]
+ * - dependenciesIndex: taskId -> [tasks this task depends on]
+ *
+ * Time complexity: O(n + e) where n = tasks, e = edges
+ */
+export function buildDependencyIndices(tasks: Task[]): {
+  taskMap: Map<string, Task>;
+  dependentsIndex: Map<string, string[]>;
+  dependenciesIndex: Map<string, string[]>;
+} {
+  const taskMap = new Map<string, Task>();
+  const dependentsIndex = new Map<string, string[]>();
+  const dependenciesIndex = new Map<string, string[]>();
+
+  // Initialize maps - O(n)
+  for (const task of tasks) {
+    taskMap.set(task.id, task);
+    dependentsIndex.set(task.id, []);
+    dependenciesIndex.set(task.id, []);
+  }
+
+  // Build indices - O(e)
+  for (const task of tasks) {
+    const deps = (task.dependencies ?? [])
+      .filter((d) => d.type === "blocked_by")
+      .map((d) => d.taskId);
+
+    // Store direct dependencies for this task
+    dependenciesIndex.set(
+      task.id,
+      deps.filter((depId) => taskMap.has(depId))
+    );
+
+    // Update dependents index (reverse lookup)
+    for (const depId of deps) {
+      if (taskMap.has(depId)) {
+        dependentsIndex.get(depId)!.push(task.id);
+      }
+    }
+  }
+
+  return { taskMap, dependentsIndex, dependenciesIndex };
+}
+
 /**
  * Find all tasks that depend on a given task (directly or transitively)
+ *
+ * Time complexity: O(n + e) with inverted index
  */
 export function findDependents(tasks: Task[], taskId: string): Task[] {
+  const { taskMap, dependentsIndex } = buildDependencyIndices(tasks);
+
   const visited = new Set<string>();
   const result: Task[] = [];
 
   function dfs(id: string) {
-    for (const task of tasks) {
-      const deps = (task.dependencies ?? [])
-        .filter((d) => d.type === "blocked_by")
-        .map((d) => d.taskId);
-
-      if (deps.includes(id) && !visited.has(task.id)) {
-        visited.add(task.id);
-        result.push(task);
-        dfs(task.id);
+    const dependentIds = dependentsIndex.get(id);
+    if (!dependentIds) return;
+
+    for (const depId of dependentIds) {
+      if (!visited.has(depId)) {
+        visited.add(depId);
+        const task = taskMap.get(depId);
+        if (task) {
+          result.push(task);
+          dfs(depId);
+        }
       }
     }
   }
@@ -169,21 +215,20 @@ export function findDependents(tasks: Task[], taskId: string): Task[] {
 
 /**
  * Find all tasks that a given task depends on (directly or transitively)
+ *
+ * Time complexity: O(n + e) with pre-built index
  */
 export function findDependencies(tasks: Task[], taskId: string): Task[] {
-  const taskMap = new Map(tasks.map((t) => [t.id, t]));
+  const { taskMap, dependenciesIndex } = buildDependencyIndices(tasks);
+
   const visited = new Set<string>();
   const result: Task[] = [];
 
   function dfs(id: string) {
-    const task = taskMap.get(id);
-    if (!task) return;
-
-    const deps = (task.dependencies ?? [])
-      .filter((d) => d.type === "blocked_by")
-      .map((d) => d.taskId);
+    const depIds = dependenciesIndex.get(id);
+    if (!depIds) return;
 
-    for (const depId of deps) {
+    for (const depId of depIds) {
       if (!visited.has(depId)) {
         visited.add(depId);
         const depTask = taskMap.get(depId);

package/src/schemas/index.ts

@@ -19,21 +19,10 @@ export {
 } from "./task.js";
 
 // View schemas
-export {
-  SmartViewFilter,
-  SortField,
-  SortOrder,
-  SmartView,
-  BuiltInView,
-} from "./view.js";
+export { SmartViewFilter, SortField, SortOrder, SmartView, BuiltInView } from "./view.js";
 
 // Inbox schemas
-export {
-  InboxStatus,
-  InboxItem,
-  InboxCreateInput,
-  InboxUpdateInput,
-} from "./inbox.js";
+export { InboxStatus, InboxItem, InboxCreateInput, InboxUpdateInput } from "./inbox.js";
 
 // Response format schemas (token optimization)
 export {

package/src/schemas/response-format.ts

@@ -129,9 +129,9 @@ export interface DashboardPriorityBreakdown {
 
 // Dependency metrics
 export interface DashboardDependencyMetrics {
-  ready: number;    // No dependencies or all satisfied
-  blocked: number;  // Has unsatisfied dependencies
-  noDeps: number;   // Tasks with no dependencies
+  ready: number; // No dependencies or all satisfied
+  blocked: number; // Has unsatisfied dependencies
+  noDeps: number; // Tasks with no dependencies
 }
 
 // Next task recommendation
@@ -139,12 +139,12 @@ export interface DashboardNextTask {
   id: string;
   title: string;
   priority: string;
-  reason: string;   // Why this task is recommended
+  reason: string; // Why this task is recommended
 }
 
 // Critical path info
 export interface DashboardCriticalPath {
-  length: number;    // Total duration in minutes
+  length: number; // Total duration in minutes
   taskCount: number; // Number of tasks on critical path
 }
 
@@ -162,7 +162,7 @@ export interface DashboardStatusBreakdown {
 export interface DashboardSubtaskProgress {
   completed: number;
   total: number;
-  pct: number;       // 0-100
+  pct: number; // 0-100
   inProgress: number;
   pending: number;
   blocked: number;