1 files changed, 62 insertions, 14 deletions

diff --git a/Omni/Task/Core.hs b/Omni/Task/Core.hs
index a2e76b6..3de42b2 100644
--- a/Omni/Task/Core.hs
+++ b/Omni/Task/Core.hs
@@ -96,12 +96,28 @@ instance FromJSON Task
 
 -- | Case-insensitive ID comparison
 matchesId :: Text -> Text -> Bool
-matchesId id1 id2 = T.toLower id1 == T.toLower id2
+matchesId id1 id2 = normalizeId id1 == normalizeId id2
+
+-- | Normalize ID to lowercase
+normalizeId :: Text -> Text
+normalizeId = T.toLower
 
 -- | Find a task by ID (case-insensitive)
 findTask :: Text -> [Task] -> Maybe Task
 findTask tid = List.find (\t -> matchesId (taskId t) tid)
 
+-- | Normalize task IDs (self, parent, dependencies) to lowercase
+normalizeTask :: Task -> Task
+normalizeTask t =
+  t
+    { taskId = normalizeId (taskId t),
+      taskParent = fmap normalizeId (taskParent t),
+      taskDependencies = map normalizeDependency (taskDependencies t)
+    }
+
+normalizeDependency :: Dependency -> Dependency
+normalizeDependency d = d {depId = normalizeId (depId d)}
+
 instance ToJSON TaskProgress
 
 instance FromJSON TaskProgress
@@ -197,7 +213,7 @@ generateChildId :: Text -> IO Text
 generateChildId parentId =
   withTaskReadLock <| do
     tasks <- loadTasksInternal
-    pure <| computeNextChildId tasks parentId
+    pure <| computeNextChildId tasks (normalizeId parentId)
 
 computeNextChildId :: [Task] -> Text -> Text
 computeNextChildId tasks parentId =
@@ -319,7 +335,10 @@ saveTaskInternal task = do
 createTask :: Text -> TaskType -> Maybe Text -> Maybe Text -> Priority -> [Dependency] -> Maybe Text -> IO Task
 createTask title taskType parent namespace priority deps description =
   withTaskWriteLock <| do
-    tid <- case parent of
+    let parent' = fmap normalizeId parent
+        deps' = map normalizeDependency deps
+
+    tid <- case parent' of
       Nothing -> generateUniqueId
       Just pid -> do
         tasks <- loadTasksInternal
@@ -327,14 +346,14 @@ createTask title taskType parent namespace priority deps description =
     now <- getCurrentTime
     let task =
           Task
-            { taskId = tid,
+            { taskId = normalizeId tid,
               taskTitle = title,
               taskType = taskType,
-              taskParent = parent,
+              taskParent = parent',
               taskNamespace = namespace,
               taskStatus = Open,
               taskPriority = priority,
-              taskDependencies = deps,
+              taskDependencies = deps',
               taskDescription = description,
               taskCreatedAt = now,
               taskUpdatedAt = now
@@ -355,21 +374,49 @@ generateUniqueId = do
         Just _ -> go tasks -- Retry if collision (case-insensitive)
 
 -- Update task status
-updateTaskStatus :: Text -> Status -> IO ()
-updateTaskStatus tid newStatus =
+updateTaskStatus :: Text -> Status -> [Dependency] -> IO ()
+updateTaskStatus tid newStatus newDeps =
   withTaskWriteLock <| do
     tasks <- loadTasksInternal
     now <- getCurrentTime
     let updatedTasks = map updateIfMatch tasks
         updateIfMatch t =
           if matchesId (taskId t) tid
-            then t {taskStatus = newStatus, taskUpdatedAt = now}
+            then t {taskStatus = newStatus, taskUpdatedAt = now, taskDependencies = if null newDeps then taskDependencies t else newDeps}
             else t
     -- Rewrite the entire file (simple approach for MVP)
     tasksFile <- getTasksFilePath
     TIO.writeFile tasksFile ""
     traverse_ saveTaskInternal updatedTasks
 
+-- Edit a task by applying a modification function
+editTask :: Text -> (Task -> Task) -> IO Task
+editTask tid modifyFn =
+  withTaskWriteLock <| do
+    tasks <- loadTasksInternal
+    now <- getCurrentTime
+
+    -- Find the task first to ensure it exists
+    case findTask tid tasks of
+      Nothing -> panic "Task not found"
+      Just original -> do
+        let modified = modifyFn original
+            -- Only update timestamp if something actually changed
+            -- But for simplicity, we always update it if the user explicitly ran 'edit'
+            finalTask = modified {taskUpdatedAt = now}
+
+            updateIfMatch t =
+              if matchesId (taskId t) tid
+                then finalTask
+                else t
+            updatedTasks = map updateIfMatch tasks
+
+        -- Rewrite the entire file
+        tasksFile <- getTasksFilePath
+        TIO.writeFile tasksFile ""
+        traverse_ saveTaskInternal updatedTasks
+        pure finalTask
+
 -- List tasks, optionally filtered by type, parent, status, or namespace
 listTasks :: Maybe TaskType -> Maybe Text -> Maybe Status -> Maybe Text -> IO [Task]
 listTasks maybeType maybeParent maybeStatus maybeNamespace = do
@@ -427,12 +474,13 @@ getDependencyTree tid = do
 
 -- Get task progress
 getTaskProgress :: Text -> IO TaskProgress
-getTaskProgress tid = do
+getTaskProgress tidRaw = do
+  let tid = normalizeId tidRaw
   tasks <- loadTasks
   -- Verify task exists (optional, but good for error handling)
-  case filter (\t -> taskId t == tid) tasks of
-    [] -> panic "Task not found"
-    _ -> do
+  case findTask tid tasks of
+    Nothing -> panic "Task not found"
+    Just _ -> do
       let children = filter (\child -> taskParent child == Just tid) tasks
           total = length children
           completed = length <| filter (\child -> taskStatus child == Done) children
@@ -827,7 +875,7 @@ importTasks filePath =
     -- Load tasks from import file
     content <- TIO.readFile filePath
     let importLines = T.lines content
-        importedTasks = mapMaybe decodeTask importLines
+        importedTasks = map normalizeTask (mapMaybe decodeTask importLines)
 
     -- Load existing tasks
     existingTasks <- loadTasksInternal