Tidy comments across the project: professional and concise

Remove scaffolding and phase markers, step-by-step narration, and comments that
restate the code; keep and tighten the ones that explain a real reason, invariant,
or gotcha. Comments only, no code changes. Agent-facing @appfunction / DTO KDocs
(the descriptions the model reads) are left intact.

Author: tonytonycoder11

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/AtmApplication.kt

@@ -14,9 +14,8 @@ import javax.inject.Inject
 /**
  * Application entry point and Hilt root.
  *
- * It also implements [AppFunctionConfiguration.Provider]: because the @AppFunction classes have
- * constructor dependencies (the domain use cases), the system can't instantiate them itself, so we
- * provide a factory that hands it the Hilt-built instances. This is the Hilt <-> AppFunctions bridge.
+ * Bridges Hilt and AppFunctions: since the @AppFunction classes take constructor dependencies, the
+ * system can't instantiate them, so [appFunctionConfiguration] hands it the Hilt-built instances.
  */
 @HiltAndroidApp
 class AtmApplication : Application(), AppFunctionConfiguration.Provider {
@@ -28,7 +27,6 @@ class AtmApplication : Application(), AppFunctionConfiguration.Provider {
     @ApplicationScope
     lateinit var applicationScope: CoroutineScope
 
-    // Built by Hilt with all their use-case dependencies; the factory below hands them to the system.
     @Inject
     lateinit var taskQueryFunctions: TaskQueryFunctions
 

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/agent/TaskActionFunctions.kt

@@ -27,10 +27,9 @@ import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 /**
- * Write AppFunctions (create / complete / delete). Thin adapters over the domain use cases: they
- * parse agent input, call the use case, and map the result back — no domain logic lives here.
- * Errors are surfaced as the AppFunctions exceptions the agent understands
- * ([AppFunctionInvalidArgumentException], [AppFunctionElementNotFoundException]) rather than crashes.
+ * Write AppFunctions (create, complete, delete). Thin adapters over the domain use cases: parse agent
+ * input, call the use case, map the result back. Failures surface as AppFunctions exceptions the agent
+ * understands ([AppFunctionInvalidArgumentException], [AppFunctionElementNotFoundException]).
  */
 class TaskActionFunctions @Inject constructor(
     private val addTaskUseCase: AddTaskUseCase,
@@ -66,7 +65,7 @@ class TaskActionFunctions @Inject constructor(
             recurrence = params.recurrence.toRecurrenceOrDefault(),
         )
         val result = addTaskUseCase(command)
-        // Report the new task with its real, graph-derived actionability.
+        // Report the new task with its graph-derived actionability.
         val createdDto = getTaskInsightUseCase(result.createdTask.id)?.toDto()
             ?: result.createdTask.toDto(isActionable = false)
         AddTaskResultDto(

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/agent/TaskQueryFunctions.kt

@@ -12,12 +12,10 @@ import kotlinx.coroutines.withContext
 import javax.inject.Inject
 
 /**
- * Read-only AppFunctions that traverse the dependency graph. These are thin adapters: each one just
- * calls the matching domain use case and maps the result to a DTO — there is no domain logic here.
- * Hilt builds this class (constructor injection); the Application's AppFunctionConfiguration hands
- * the instance to the system (see AtmApplication).
- *
- * AppFunctions run on the UI thread by default, so each one moves to [Dispatchers.IO] for the work.
+ * Read-only AppFunctions over the dependency graph. Thin adapters: each calls a domain use case and
+ * maps the result to a DTO. Hilt constructs the class; the Application's AppFunctionConfiguration
+ * hands the instance to the system. Work runs on [Dispatchers.IO], since AppFunctions dispatch on the
+ * main thread by default.
  */
 class TaskQueryFunctions @Inject constructor(
     private val getActionableTasksUseCase: GetActionableTasksUseCase,

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/agent/mapper/AgentMappers.kt

@@ -12,13 +12,12 @@ import java.time.LocalDate
 import java.time.ZoneOffset
 
 /**
- * Translation between the agent DTOs and domain types, plus tolerant parsing of agent-supplied
- * strings. Agents pass imperfect input, so parsing is forgiving where it safely can be (enums are
- * case-insensitive and fall back to a default) and explicit where it cannot (an unparseable date or
- * a blank id is reported as an [AppFunctionInvalidArgumentException] rather than silently mishandled).
+ * Translation between agent DTOs and domain types, plus tolerant parsing of agent-supplied strings.
+ * Parsing is forgiving where it safely can be (enums fall back to a default) and explicit where it
+ * cannot (a bad date or blank id raises [AppFunctionInvalidArgumentException] rather than mishandling).
  */
 
-/** Rich mapping from a graph insight (the normal path for query results). */
+/** Rich mapping from a graph insight; the normal path for query results. */
 fun TaskInsight.toDto(): TaskDto = TaskDto(
     id = task.id.value,
     title = task.title,
@@ -31,10 +30,7 @@ fun TaskInsight.toDto(): TaskDto = TaskDto(
     blocksTaskIds = blocks.map { it.value },
 )
 
-/**
- * Mapping from a bare [Task] when the actionability is already known by the caller (e.g. a just
- * completed task is not actionable; a freshly unblocked task is).
- */
+/** Mapping from a bare [Task] when the caller already knows its actionability. */
 fun Task.toDto(
     isActionable: Boolean,
     blockedBy: List<TaskId> = emptyList(),
@@ -66,9 +62,8 @@ fun String?.toRecurrenceOrDefault(): Recurrence =
     this?.trim()?.uppercase()?.let { runCatching { Recurrence.valueOf(it) }.getOrNull() } ?: Recurrence.NONE
 
 /**
- * Parses an optional due date. Accepts a full ISO-8601 instant ("2026-07-01T09:00:00Z") or a plain
- * ISO date ("2026-07-01", interpreted as start of day UTC). Null stays null; anything else is an
- * invalid argument the agent should correct.
+ * Parses an optional due date: an ISO-8601 instant, or a plain ISO date taken as start of day UTC.
+ * Null stays null; anything else is an invalid argument.
  */
 fun parseDueDate(value: String?): Instant? {
     val raw = value?.trim()?.takeIf { it.isNotEmpty() } ?: return null

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/data/AtmDatabase.kt

@@ -7,10 +7,7 @@ import io.github.tonytonycoder11.agentictaskmanager.data.dao.TaskDao
 import io.github.tonytonycoder11.agentictaskmanager.data.entity.DependencyEntity
 import io.github.tonytonycoder11.agentictaskmanager.data.entity.TaskEntity
 
-/**
- * The Room database. Two tables — tasks and their dependency edges — which together persist the
- * dependency graph. Schema export is disabled for Phase 1 (no migrations yet, version 1).
- */
+/** Room database persisting tasks and their dependency edges. */
 @Database(
     entities = [TaskEntity::class, DependencyEntity::class],
     version = 1,

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/data/DatabaseSeeder.kt

@@ -11,16 +11,10 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Seeds a small, fully SYNTHETIC scenario the first time the app runs (security rule #5: no real
- * personal data). The data is intentionally shaped to exercise every domain feature so the app —
- * and later the agent — has something interesting to reason about:
- *
- *  - "Prepare slides" and "Book venue" both block "Present at the GDG meetup" (so it is blocked);
- *  - "Book venue" is already overdue and blocking, so it surfaces in getBlockingOverdue();
- *  - "Buy milk" is free (actionable); "Water the plants" is a weekly recurring task.
- *
- * Seeding goes through the real [AddTaskUseCase] (not raw inserts), so the dependency links are
- * created and validated exactly as they would be at runtime.
+ * Seeds a small synthetic scenario on first run; the data is intentionally shaped to exercise
+ * every domain feature (dependencies, overdue, recurrence). Uses only synthetic data — no real
+ * personal data. Goes through the real [AddTaskUseCase] so dependency links are validated exactly
+ * as at runtime.
  */
 @Singleton
 class DatabaseSeeder @Inject constructor(
@@ -46,10 +40,10 @@ class DatabaseSeeder @Inject constructor(
                 title = "Book venue",
                 description = "Reserve the room for the meetup.",
                 priority = Priority.URGENT,
-                dueAt = now.minus(1, ChronoUnit.DAYS), // already overdue
+                dueAt = now.minus(1, ChronoUnit.DAYS),
             ),
         )
-        // Depends on both of the above by title -> starts blocked.
+        // Depends on both of the above, so it starts blocked.
         addTask(
             AddTaskCommand(
                 title = "Present at the GDG meetup",

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/data/TaskRepositoryImpl.kt

@@ -14,11 +14,8 @@ import javax.inject.Inject
 import javax.inject.Singleton
 
 /**
- * Room-backed implementation of the domain [TaskRepository].
- *
- * It is the only place that knows about Room. Every method maps between entities and domain
- * models so the domain stays Android-free. Deleting a task relies on the ON DELETE CASCADE
- * foreign keys to drop its dependency edges, honouring the repository contract.
+ * Room-backed [TaskRepository]; maps between entities and domain models so the domain stays
+ * Android-free. Deleting a task relies on ON DELETE CASCADE to drop its dependency edges.
  */
 @Singleton
 class TaskRepositoryImpl @Inject constructor(

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/data/dao/TaskDao.kt

@@ -11,7 +11,6 @@ import kotlinx.coroutines.flow.Flow
 @Dao
 interface TaskDao {
 
-    /** Reactive stream of all tasks; re-emits whenever the table changes. */
     @Query("SELECT * FROM tasks")
     fun observeAll(): Flow<List<TaskEntity>>
 

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/data/entity/DependencyEntity.kt

@@ -7,10 +7,8 @@ import androidx.room.Index
 /**
  * Room row for one dependency edge: [dependentId] depends on [prerequisiteId].
  *
- * Both columns are foreign keys onto `tasks.id` with ON DELETE CASCADE. That is what implements
- * the repository contract: deleting a task automatically removes every edge that referenced it,
- * so the persisted graph can never hold a dangling edge. (Room enables SQLite foreign-key
- * enforcement automatically when foreign keys are declared.)
+ * Both columns are foreign keys onto `tasks.id` with ON DELETE CASCADE, so deleting a task removes
+ * every edge referencing it and the persisted graph can never hold a dangling edge.
  */
 @Entity(
     tableName = "dependencies",

app/src/main/kotlin/io/github/tonytonycoder11/agentictaskmanager/data/entity/TaskEntity.kt

@@ -5,14 +5,11 @@ import androidx.room.Index
 import androidx.room.PrimaryKey
 
 /**
- * Room row for a task.
+ * Room row for a task. Enums and the due instant are stored as primitives (String / nullable Long
+ * epoch millis) to avoid TypeConverters; conversion lives in the mappers.
  *
- * Enums and the due instant are stored as primitives (String / nullable Long epoch millis) to
- * keep the schema simple and avoid TypeConverters in Phase 1. Conversion to/from the domain
- * [Task][io.github.tonytonycoder11.agentictaskmanager.domain.model.Task] lives in the mappers.
- *
- * [parentId] is indexed (sub-task lookups walk it) but intentionally has no foreign key: the
- * sub-task subtree deletion is owned by the domain use case, not by a DB cascade.
+ * [parentId] is indexed but intentionally has no foreign key: sub-task subtree deletion is owned
+ * by the domain use case, not by a DB cascade.
  */
 @Entity(
     tableName = "tasks",