Add task manager for AI agents

Implemented a dependency-aware task tracker inspired by beads: - Task
CRUD operations (create, list, update, ready) - Dependency tracking
and ready work detection - JSONL storage with git sync via hooks -
Export/import for cross-machine synchronization - Short base62-encoded
task IDs (e.g., t-1ky7gJ2)

Added comprehensive AGENTS.md documentation: - Task manager usage and
workflows - Development tools (bild, lint, repl.sh) - Git-branchless
workflow guidelines - Coding conventions

Integrated with git hooks for auto-sync: - post-merge/post-checkout:
import tasks - pre-commit/pre-push: export tasks

Also includes beads design analysis document for reference.

Completed tasks: - t-a1b2c3: Show help text when invoked without args
- t-d4e5f6: Move dev instructions to AGENTS.md - t-g7h8i9: Implement
shorter task IDs - t-p6q7r8: Add git-branchless workflow docs

https: //ampcode.com/threads/T-85f4ee29-a529-4f59-ac6f-6ffec75b6a56
Co-authored-by: Amp <amp@ampcode.com> Amp-Thread-ID:
https://ampcode.com/threads/T-85f4ee29-a529-4f59-ac6f-6ffec75b6a56

6 files changed, 395 insertions, 0 deletions

diff --git a/Omni/Ide/hooks/post-checkout b/Omni/Ide/hooks/post-checkout
index 85541a2..3fe14b5 100755
--- a/Omni/Ide/hooks/post-checkout
+++ b/Omni/Ide/hooks/post-checkout
@@ -14,6 +14,12 @@ elif [[ ${#changed[@]} -gt 0 ]]
 then
     MakeTags "${changed[@]}"
 fi
+
+# Task manager: Import tasks after branch switch
+if [ -f .tasks/tasks.jsonl ]; then
+    task import -i .tasks/tasks.jsonl 2>/dev/null || true
+fi
+
 ## START BRANCHLESS CONFIG
 
 git branchless hook post-checkout "$@"
diff --git a/Omni/Ide/hooks/post-merge b/Omni/Ide/hooks/post-merge
index fcfd314..3e0495b 100755
--- a/Omni/Ide/hooks/post-merge
+++ b/Omni/Ide/hooks/post-merge
@@ -1,5 +1,11 @@
 #!/usr/bin/env bash
 "${CODEROOT:?}"/Omni/Ide/hooks/post-checkout 'HEAD@{1}' HEAD
+
+# Task manager: Import tasks after git pull/merge
+if [ -f .tasks/tasks.jsonl ]; then
+    task import -i .tasks/tasks.jsonl 2>/dev/null || true
+fi
+
 ## START BRANCHLESS CONFIG
 
 git branchless hook post-merge "$@"
diff --git a/Omni/Ide/hooks/pre-commit b/Omni/Ide/hooks/pre-commit
index 06f1716..d096f5b 100755
--- a/Omni/Ide/hooks/pre-commit
+++ b/Omni/Ide/hooks/pre-commit
@@ -18,4 +18,10 @@
     fi
   done
   lint "${changed[@]}"
+
+  # Task manager: Export tasks before commit
+  if [ -d .tasks ]; then
+      task export --flush 2>/dev/null || true
+      git add .tasks/tasks.jsonl 2>/dev/null || true
+  fi
 ##
diff --git a/Omni/Ide/hooks/pre-push b/Omni/Ide/hooks/pre-push
index 00110bd..adbf858 100755
--- a/Omni/Ide/hooks/pre-push
+++ b/Omni/Ide/hooks/pre-push
@@ -1,5 +1,11 @@
 #!/usr/bin/env bash
 set -euo pipefail
+
+# Task manager: Ensure tasks are exported before push
+if [ -d .tasks ]; then
+    task export --flush 2>/dev/null || true
+fi
+
 remote="$1"
 z40=0000000000000000000000000000000000000000
 IFS=" "
diff --git a/Omni/Task.hs b/Omni/Task.hs
new file mode 100644
index 0000000..be54d3d
--- /dev/null
+++ b/Omni/Task.hs
@@ -0,0 +1,148 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE RecordWildCards #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+
+-- : out task
+module Omni.Task where
+
+import Alpha
+import qualified Data.Text as T
+import qualified Omni.Cli as Cli
+import Omni.Task.Core
+import qualified Omni.Test as Test
+import System.Directory (doesFileExist, removeFile)
+
+main :: IO ()
+main = Cli.main plan
+
+plan :: Cli.Plan ()
+plan =
+  Cli.Plan
+    { help = help,
+      move = move,
+      test = test,
+      tidy = \_ -> pure ()
+    }
+
+help :: Cli.Docopt
+help =
+  [Cli.docopt|
+task
+
+Usage:
+  task init
+  task create <title> <project> [--deps=<ids>]
+  task list [--project=<project>]
+  task ready
+  task update <id> <status>
+  task deps <id>
+  task export [--flush]
+  task import -i <file>
+  task test
+  task (-h | --help)
+
+Commands:
+  init                          Initialize task database
+  create                        Create a new task
+  list                          List all tasks
+  ready                         Show ready tasks (not blocked)
+  update                        Update task status
+  deps                          Show dependency tree
+  export                        Export and consolidate tasks to JSONL
+  import                        Import tasks from JSONL file
+  test                          Run tests
+
+Options:
+  -h --help                     Show this help
+  --project=<project>           Filter by project
+  --deps=<ids>                  Comma-separated list of dependency IDs
+  --flush                       Force immediate export
+  -i <file>                     Input file for import
+
+Arguments:
+  <title>                       Task title
+  <project>                     Project name
+  <id>                          Task ID
+  <status>                      Task status (open, in-progress, done)
+  <file>                        JSONL file to import
+|]
+
+move :: Cli.Arguments -> IO ()
+move args
+  | args `Cli.has` Cli.command "init" = initTaskDb
+  | args `Cli.has` Cli.command "create" = do
+      title <- getArgText args "title"
+      project <- getArgText args "project"
+      deps <- case Cli.getArg args (Cli.longOption "deps") of
+        Nothing -> pure []
+        Just depStr -> pure <| T.splitOn "," (T.pack depStr)
+      task <- createTask title project deps
+      putStrLn <| "Created task: " <> T.unpack (taskId task)
+  | args `Cli.has` Cli.command "list" = do
+      maybeProject <- case Cli.getArg args (Cli.longOption "project") of
+        Nothing -> pure Nothing
+        Just p -> pure <| Just (T.pack p)
+      tasks <- listTasks maybeProject
+      traverse_ printTask tasks
+  | args `Cli.has` Cli.command "ready" = do
+      tasks <- getReadyTasks
+      putText "Ready tasks:"
+      traverse_ printTask tasks
+  | args `Cli.has` Cli.command "update" = do
+      tid <- getArgText args "id"
+      statusStr <- getArgText args "status"
+      let newStatus = case statusStr of
+            "open" -> Open
+            "in-progress" -> InProgress
+            "done" -> Done
+            _ -> panic "Invalid status. Use: open, in-progress, or done"
+      updateTaskStatus tid newStatus
+      putStrLn <| "Updated task " <> T.unpack tid
+  | args `Cli.has` Cli.command "deps" = do
+      tid <- getArgText args "id"
+      showDependencyTree tid
+  | args `Cli.has` Cli.command "export" = do
+      exportTasks
+      putText "Exported and consolidated tasks to .tasks/tasks.jsonl"
+  | args `Cli.has` Cli.command "import" = do
+      file <- getArgText args "file"
+      importTasks (T.unpack file)
+      putText <| "Imported tasks from " <> file
+  | otherwise = putText (T.pack <| Cli.usage help)
+  where
+    getArgText :: Cli.Arguments -> String -> IO Text
+    getArgText argz name = do
+      maybeArg <- pure <| Cli.getArg argz (Cli.argument name)
+      case maybeArg of
+        Nothing -> panic (T.pack name <> " required")
+        Just val -> pure (T.pack val)
+
+test :: Test.Tree
+test = Test.group "Omni.Task" [unitTests]
+
+unitTests :: Test.Tree
+unitTests =
+  Test.group
+    "Unit tests"
+    [ Test.unit "can create task" <| do
+        -- Clean up before test
+        exists <- doesFileExist ".tasks/tasks.jsonl"
+        when exists <| removeFile ".tasks/tasks.jsonl"
+
+        initTaskDb
+        task <- createTask "Test task" "test-project" []
+        taskTitle task Test.@?= "Test task"
+        taskProject task Test.@?= "test-project"
+        taskStatus task Test.@?= Open
+        null (taskDependencies task) Test.@?= True,
+      Test.unit "can list tasks" <| do
+        tasks <- listTasks Nothing
+        not (null tasks) Test.@?= True,
+      Test.unit "ready tasks exclude blocked ones" <| do
+        task1 <- createTask "First task" "test" []
+        task2 <- createTask "Blocked task" "test" [taskId task1]
+        ready <- getReadyTasks
+        (taskId task1 `elem` map taskId ready) Test.@?= True
+        (taskId task2 `notElem` map taskId ready) Test.@?= True
+    ]
diff --git a/Omni/Task/Core.hs b/Omni/Task/Core.hs
new file mode 100644
index 0000000..f49a8d2
--- /dev/null
+++ b/Omni/Task/Core.hs
@@ -0,0 +1,223 @@
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE NoImplicitPrelude #-}
+
+module Omni.Task.Core where
+
+import Alpha
+import Data.Aeson (FromJSON, ToJSON, decode, encode)
+import qualified Data.ByteString.Lazy.Char8 as BLC
+import qualified Data.Text as T
+import qualified Data.Text.IO as TIO
+import Data.Time (UTCTime, diffTimeToPicoseconds, getCurrentTime, utctDayTime)
+import GHC.Generics ()
+import System.Directory (createDirectoryIfMissing, doesFileExist)
+
+-- Core data types
+data Task = Task
+  { taskId :: Text,
+    taskTitle :: Text,
+    taskProject :: Text,
+    taskStatus :: Status,
+    taskDependencies :: [Text], -- List of task IDs this depends on
+    taskCreatedAt :: UTCTime,
+    taskUpdatedAt :: UTCTime
+  }
+  deriving (Show, Eq, Generic)
+
+data Status = Open | InProgress | Done
+  deriving (Show, Eq, Generic)
+
+instance ToJSON Status
+
+instance FromJSON Status
+
+instance ToJSON Task
+
+instance FromJSON Task
+
+-- Initialize the task database
+initTaskDb :: IO ()
+initTaskDb = do
+  createDirectoryIfMissing True ".tasks"
+  exists <- doesFileExist ".tasks/tasks.jsonl"
+  unless exists <| do
+    TIO.writeFile ".tasks/tasks.jsonl" ""
+    putText "Initialized task database at .tasks/tasks.jsonl"
+
+-- Generate a short ID using base62 encoding of timestamp
+generateId :: IO Text
+generateId = do
+  now <- getCurrentTime
+  -- Convert current time to microseconds since midnight
+  let dayTime = utctDayTime now
+      microseconds = diffTimeToPicoseconds dayTime `div` 1000000
+      -- Convert to base62 for shorter IDs
+      encoded = toBase62 (fromIntegral microseconds)
+  pure <| "t-" <> T.pack encoded
+
+-- Convert number to base62 (0-9, a-z, A-Z)
+toBase62 :: Integer -> String
+toBase62 0 = "0"
+toBase62 n = reverse <| go n
+  where
+    alphabet = ['0' .. '9'] ++ ['a' .. 'z'] ++ ['A' .. 'Z']
+    go 0 = []
+    go x =
+      let (q, r) = x `divMod` 62
+          idx = fromIntegral r
+          char = case drop idx alphabet of
+            (c : _) -> c
+            [] -> '0' -- Fallback (should never happen)
+       in char : go q
+
+-- Load all tasks from JSONL file
+loadTasks :: IO [Task]
+loadTasks = do
+  exists <- doesFileExist ".tasks/tasks.jsonl"
+  if exists
+    then do
+      content <- TIO.readFile ".tasks/tasks.jsonl"
+      let taskLines = T.lines content
+      pure <| mapMaybe decodeTask taskLines
+    else pure []
+  where
+    decodeTask :: Text -> Maybe Task
+    decodeTask line =
+      if T.null line
+        then Nothing
+        else decode (BLC.pack <| T.unpack line)
+
+-- Save a single task (append to JSONL)
+saveTask :: Task -> IO ()
+saveTask task = do
+  let json = encode task
+  BLC.appendFile ".tasks/tasks.jsonl" (json <> "\n")
+
+-- Create a new task
+createTask :: Text -> Text -> [Text] -> IO Task
+createTask title project deps = do
+  tid <- generateId
+  now <- getCurrentTime
+  let task =
+        Task
+          { taskId = tid,
+            taskTitle = title,
+            taskProject = project,
+            taskStatus = Open,
+            taskDependencies = deps,
+            taskCreatedAt = now,
+            taskUpdatedAt = now
+          }
+  saveTask task
+  pure task
+
+-- Update task status
+updateTaskStatus :: Text -> Status -> IO ()
+updateTaskStatus tid newStatus = do
+  tasks <- loadTasks
+  now <- getCurrentTime
+  let updatedTasks = map updateIfMatch tasks
+      updateIfMatch t =
+        if taskId t == tid
+          then t {taskStatus = newStatus, taskUpdatedAt = now}
+          else t
+  -- Rewrite the entire file (simple approach for MVP)
+  TIO.writeFile ".tasks/tasks.jsonl" ""
+  traverse_ saveTask updatedTasks
+
+-- List tasks, optionally filtered by project
+listTasks :: Maybe Text -> IO [Task]
+listTasks maybeProject = do
+  tasks <- loadTasks
+  pure <| case maybeProject of
+    Nothing -> tasks
+    Just proj -> filter (\t -> taskProject t == proj) tasks
+
+-- Get ready tasks (not blocked by dependencies)
+getReadyTasks :: IO [Task]
+getReadyTasks = do
+  allTasks <- loadTasks
+  let openTasks = filter (\t -> taskStatus t /= Done) allTasks
+      doneIds = map taskId <| filter (\t -> taskStatus t == Done) allTasks
+      isReady task = all (`elem` doneIds) (taskDependencies task)
+  pure <| filter isReady openTasks
+
+-- Show dependency tree for a task
+showDependencyTree :: Text -> IO ()
+showDependencyTree tid = do
+  tasks <- loadTasks
+  case filter (\t -> taskId t == tid) tasks of
+    [] -> putText "Task not found"
+    (task : _) -> printTree tasks task 0
+  where
+    printTree :: [Task] -> Task -> Int -> IO ()
+    printTree allTasks task indent = do
+      putText <| T.pack (replicate (indent * 2) ' ') <> taskId task <> ": " <> taskTitle task
+      let deps = filter (\t -> taskId t `elem` taskDependencies task) allTasks
+      traverse_ (\dep -> printTree allTasks dep (indent + 1)) deps
+
+-- Helper to print a task
+printTask :: Task -> IO ()
+printTask t =
+  putText
+    <| taskId t
+    <> " ["
+    <> T.pack (show (taskStatus t))
+    <> "] "
+    <> taskTitle t
+    <> " ("
+    <> taskProject t
+    <> ")"
+
+-- Export tasks: Consolidate JSONL file (remove duplicates, keep latest version)
+exportTasks :: IO ()
+exportTasks = do
+  tasks <- loadTasks
+  -- Rewrite the entire file with deduplicated tasks
+  TIO.writeFile ".tasks/tasks.jsonl" ""
+  traverse_ saveTask tasks
+
+-- Import tasks: Read from another JSONL file and merge with existing tasks
+importTasks :: FilePath -> IO ()
+importTasks filePath = do
+  exists <- doesFileExist filePath
+  unless exists <| panic (T.pack filePath <> " does not exist")
+
+  -- Load tasks from import file
+  content <- TIO.readFile filePath
+  let importLines = T.lines content
+      importedTasks = mapMaybe decodeTask importLines
+
+  -- Load existing tasks
+  existingTasks <- loadTasks
+
+  -- Create a map of existing task IDs for quick lookup
+  let existingIds = map taskId existingTasks
+      -- Filter to only new tasks (not already in our database)
+      newTasks = filter (\t -> taskId t `notElem` existingIds) importedTasks
+      -- For tasks that exist, update them with imported data
+      updatedTasks = map (updateWithImported importedTasks) existingTasks
+      -- Combine: updated existing tasks + new tasks
+      allTasks = updatedTasks ++ newTasks
+
+  -- Rewrite tasks.jsonl with merged data
+  TIO.writeFile ".tasks/tasks.jsonl" ""
+  traverse_ saveTask allTasks
+  where
+    decodeTask :: Text -> Maybe Task
+    decodeTask line =
+      if T.null line
+        then Nothing
+        else decode (BLC.pack <| T.unpack line)
+
+    -- Update an existing task if there's a newer version in imported tasks
+    updateWithImported :: [Task] -> Task -> Task
+    updateWithImported imported existing =
+      case filter (\t -> taskId t == taskId existing) imported of
+        [] -> existing -- No imported version, keep existing
+        (importedTask : _) ->
+          -- Use imported version if it's newer (based on updatedAt)
+          if taskUpdatedAt importedTask > taskUpdatedAt existing
+            then importedTask
+            else existing