@@ -52,6 +52,7 @@ pub struct StatusOutput {
     pub in_progress: Vec<TaskSummary>,
     pub blocked: Vec<TaskSummary>,
     pub recently_completed: Vec<TaskSummary>,
+    pub recently_created: Vec<TaskSummary>,
     pub summary: StatusSummary,
 }
 
@@ -108,6 +109,7 @@ impl From<StatusCounts> for StatusSummary {
 /// # Returns
 ///
 /// Exit code: 0 (success), 3 (DB error)
+#[allow(clippy::too_many_lines)]
 pub fn execute(args: &StatusArgs) -> Result<i32> {
     // Determine project root
     let project_root = if let Some(ref root) = args.project_root {
@@ -185,9 +187,9 @@ pub fn execute(args: &StatusArgs) -> Result<i32> {
         .get_status_counts()
         .context("Failed to query status counts")?;
 
-    // Get in-progress tasks
+    // Get in-progress tasks (explicitly marked as in-progress)
     let in_progress = task_repo
-        .find_by_status(TaskStatus::Open)
+        .find_by_status(TaskStatus::InProgress)
         .context("Failed to query in-progress tasks")?;
     let in_progress: Vec<TaskRecord> = in_progress.into_iter().take(args.limit).collect();
 
@@ -203,16 +205,34 @@ pub fn execute(args: &StatusArgs) -> Result<i32> {
         .find_recently_completed(since_timestamp, args.limit)
         .context("Failed to query recently completed tasks")?;
 
+    // Get recently created tasks
+    let recently_created = task_repo
+        .find_recently_created(since_timestamp, args.limit)
+        .context("Failed to query recently created tasks")?;
+
     // Output results
     if args.json {
-        output_json(&in_progress, &blocked, &recently_completed, &counts)?;
+        output_json(
+            &in_progress,
+            &blocked,
+            &recently_completed,
+            &recently_created,
+            &counts,
+        )?;
     } else if args.compact {
-        output_compact(&in_progress, &blocked, &recently_completed, &counts);
+        output_compact(
+            &in_progress,
+            &blocked,
+            &recently_completed,
+            &recently_created,
+            &counts,
+        );
     } else {
         output_text(
             &in_progress,
             &blocked,
             &recently_completed,
+            &recently_created,
             &counts,
             &args.since,
             theme.as_ref(),
@@ -275,6 +295,7 @@ fn output_json(
     in_progress: &[TaskRecord],
     blocked: &[TaskRecord],
     recently_completed: &[TaskRecord],
+    recently_created: &[TaskRecord],
     counts: &StatusCounts,
 ) -> Result<()> {
     let output = StatusOutput {
@@ -284,6 +305,7 @@ fn output_json(
             .iter()
             .map(|t| t.clone().into())
             .collect(),
+        recently_created: recently_created.iter().map(|t| t.clone().into()).collect(),
         summary: counts.clone().into(),
     };
 
@@ -296,11 +318,13 @@ fn output_compact(
     in_progress: &[TaskRecord],
     blocked: &[TaskRecord],
     recently_completed: &[TaskRecord],
+    recently_created: &[TaskRecord],
     counts: &StatusCounts,
 ) {
     println!("in_progress: {}", in_progress.len());
     println!("blocked: {}", blocked.len());
     println!("recent_done: {}", recently_completed.len());
+    println!("recent_created: {}", recently_created.len());
     println!(
         "total: {} open: {} done: {} waived: {} blocked: {}",
         counts.total, counts.open, counts.done, counts.waived, counts.blocked
@@ -313,6 +337,7 @@ fn output_text(
     in_progress: &[TaskRecord],
     blocked: &[TaskRecord],
     recently_completed: &[TaskRecord],
+    recently_created: &[TaskRecord],
     counts: &StatusCounts,
     since: &str,
     theme: Option<&CliTheme>,
@@ -376,6 +401,27 @@ fn output_text(
         println!();
     }
 
+    // Recently Created section
+    if !recently_created.is_empty() {
+        if let Some(t) = theme {
+            println!(
+                "{} ({} in last {since})",
+                t.style_info("Recently Created"),
+                recently_created.len()
+            );
+        } else {
+            println!(
+                "Recently Created ({} in last {since})",
+                recently_created.len()
+            );
+        }
+
+        for task in recently_created {
+            print_task_summary(task, theme);
+        }
+        println!();
+    }
+
     // Summary section
     #[allow(
         clippy::cast_precision_loss,
 
@@ -702,6 +702,46 @@ impl<'conn> TaskRepository<'conn> {
         Ok(tasks)
     }
 
+    /// Find recently created tasks
+    ///
+    /// Finds tasks with status 'open' in files modified since the given timestamp.
+    /// This serves as a proxy for recently created tasks since task creation
+    /// updates the file's modification time.
+    /// Results are ordered by file modification time (most recent first).
+    ///
+    /// # Arguments
+    ///
+    /// * `since_timestamp` - Unix timestamp (seconds since epoch)
+    /// * `limit` - Maximum number of tasks to return
+    ///
+    /// # Errors
+    ///
+    /// Returns error if query fails
+    pub fn find_recently_created(
+        &self,
+        since_timestamp: i64,
+        limit: usize,
+    ) -> DbResult<Vec<TaskRecord>> {
+        #[allow(clippy::cast_possible_wrap)]
+        let limit_i64 = limit as i64;
+
+        let mut stmt = self.conn.prepare(
+            "SELECT t.id, t.file_id, t.local_id, t.full_id, t.title, t.status, t.depth, t.parent_id, t.order_index, t.owner, t.estimate, t.body, t.metadata, t.contextual_notes
+             FROM tasks t
+             JOIN files f ON t.file_id = f.id
+             WHERE t.status = 'open'
+               AND f.mtime >= ?1
+             ORDER BY f.mtime DESC
+             LIMIT ?2",
+        )?;
+
+        let tasks = stmt
+            .query_map([since_timestamp, limit_i64], Self::row_to_task_record)?
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(tasks)
+    }
+
     /// Helper to convert a row to `TaskRecord`
     fn row_to_task_record(row: &rusqlite::Row) -> rusqlite::Result<TaskRecord> {
         let metadata_json: String = row.get(12)?;
@@ -2008,4 +2048,36 @@ mod tests {
         assert_eq!(ids[1], "test#mike");
         assert_eq!(ids[2], "test#zulu");
     }
+
+    #[test]
+    fn test_find_recently_created() {
+        let temp_db = NamedTempFile::new().unwrap();
+        let conn = init_database(temp_db.path()).unwrap();
+
+        let file = create_test_file("test.md", "test");
+        let file_repo = FileRepository::new(&conn);
+        let file_db_id = file_repo.insert(&file).unwrap();
+
+        let task_repo = TaskRepository::new(&conn);
+
+        // Create open tasks
+        let task1 = create_test_task("task1", "Open Task 1", 0, None, 0);
+        task_repo.insert(&task1, file_db_id, "test").unwrap();
+
+        let task2 = create_test_task("task2", "Open Task 2", 0, None, 1);
+        task_repo.insert(&task2, file_db_id, "test").unwrap();
+
+        // Create a done task
+        let mut task3 = create_test_task("task3", "Done Task", 0, None, 2);
+        task3.status = TaskStatus::Done;
+        task_repo.insert(&task3, file_db_id, "test").unwrap();
+
+        // Find recently created (should only return open tasks)
+        // Using timestamp 0 to get all tasks
+        let recently_created = task_repo.find_recently_created(0, 10).unwrap();
+        assert_eq!(recently_created.len(), 2);
+        assert!(recently_created
+            .iter()
+            .all(|t| t.status == TaskStatus::Open));
+    }
 }