From 92d854c1cbc02798eed48f63c5eb286ec7fe46e0 Mon Sep 17 00:00:00 2001
From: Dawid Zbinski <dawid@zbinski.dev>
Date: Sun, 15 Mar 2026 23:01:55 +0100
Subject: [PATCH 1/2] refactor: move log, edit, remove under log group command

Convert top-level `log`, `edit`, and `remove` commands into subcommands
`log add`, `log edit`, and `log remove` under a new `log` group command.
This groups all time entry operations under a single namespace, improving
CLI discoverability and consistency with the existing project/defaults
group pattern.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 README.md                                     |  44 +-
 internal/cli/log.go                           | 448 +-----------------
 internal/cli/log_add.go                       | 443 +++++++++++++++++
 internal/cli/{log_test.go => log_add_test.go} | 245 +++++-----
 internal/cli/{edit.go => log_edit.go}         |   6 +-
 .../cli/{edit_test.go => log_edit_test.go}    | 201 ++++----
 internal/cli/{remove.go => log_remove.go}     |   6 +-
 .../{remove_test.go => log_remove_test.go}    |  57 +--
 internal/cli/root.go                          |   2 -
 web/docs/commands/time-tracking.md            |  36 +-
 10 files changed, 754 insertions(+), 734 deletions(-)
 create mode 100644 internal/cli/log_add.go
 rename internal/cli/{log_test.go => log_add_test.go} (66%)
 rename internal/cli/{edit.go => log_edit.go} (99%)
 rename internal/cli/{edit_test.go => log_edit_test.go} (66%)
 rename internal/cli/{remove.go => log_remove.go} (93%)
 rename internal/cli/{remove_test.go => log_remove_test.go} (63%)

diff --git a/README.md b/README.md
index 53e53f1..58ed375 100644
--- a/README.md
+++ b/README.md
@@ -90,8 +90,8 @@ hourgit version
 
 3. **Log non-git work** manually:
    ```bash
-   hourgit log --duration 1h30m "standup"
-   hourgit log --from 9am --to 10:30am "standup"
+   hourgit log add --duration 1h30m "standup"
+   hourgit log add --from 9am --to 10:30am "standup"
    ```
 
 4. **View the interactive report:**
@@ -111,7 +111,7 @@ hourgit version
 
 Core commands for recording, viewing, and managing your time entries.
 
-Commands: `init` · `log` · `edit` · `remove` · `sync` · `report` · `history` · `status`
+Commands: `init` · `log add` · `log edit` · `log remove` · `sync` · `report` · `history` · `status`
 
 #### `hourgit init`
 
@@ -129,12 +129,12 @@ hourgit init [--project <name>] [--mode <mode>] [--force] [--append] [--yes]
 | `-a`, `--append` | `false` | Append to existing post-checkout hook |
 | `-y`, `--yes` | `false` | Skip confirmation prompt |
 
-#### `hourgit log`
+#### `hourgit log add`
 
 Manually log time for a project. Uses a hybrid mode: provide any combination of flags and you'll be prompted only for the missing pieces.
 
 ```bash
-hourgit log [MESSAGE] [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [--project <name>]
+hourgit log add [MESSAGE] [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [--project <name>]
 ```
 
 | Flag | Default | Description |
@@ -152,25 +152,25 @@ hourgit log [MESSAGE] [--duration <dur>] [--from <time>] [--to <time>] [--date <
 
 ```bash
 # Fully specified — no prompts
-hourgit log --duration 3h "did some work"
-hourgit log --from 9am --to 12pm "morning work"
-hourgit log --duration 3h --date 2025-01-10 "forgot to log"
+hourgit log add --duration 3h "did some work"
+hourgit log add --from 9am --to 12pm "morning work"
+hourgit log add --duration 3h --date 2025-01-10 "forgot to log"
 
 # Partial flags — prompted for the rest
-hourgit log --duration 3h          # prompted for message
-hourgit log --from 9am             # prompted for --to and message
-hourgit log "meeting notes"        # prompted for time mode and inputs
+hourgit log add --duration 3h          # prompted for message
+hourgit log add --from 9am             # prompted for --to and message
+hourgit log add "meeting notes"        # prompted for time mode and inputs
 
 # Fully interactive
-hourgit log
+hourgit log add
 ```
 
-#### `hourgit edit`
+#### `hourgit log edit`
 
 Edit an existing log entry by its hash. When edit flags are provided, only those changes are applied directly. Without flags, an interactive editor opens with current values pre-filled.
 
 ```bash
-hourgit edit <hash> [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [-m <msg>] [--project <name>]
+hourgit log edit <hash> [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [-m <msg>] [--project <name>]
 ```
 
 | Flag | Default | Description |
@@ -189,19 +189,19 @@ hourgit edit <hash> [--duration <dur>] [--from <time>] [--to <time>] [--date <da
 **Examples**
 
 ```bash
-hourgit edit abc1234 --duration 3h
-hourgit edit abc1234 --from 9am --to 12pm
-hourgit edit abc1234 --task "reviews"
-hourgit edit abc1234 -m "updated message"
-hourgit edit abc1234              # interactive mode
+hourgit log edit abc1234 --duration 3h
+hourgit log edit abc1234 --from 9am --to 12pm
+hourgit log edit abc1234 --task "reviews"
+hourgit log edit abc1234 -m "updated message"
+hourgit log edit abc1234              # interactive mode
 ```
 
-#### `hourgit remove`
+#### `hourgit log remove`
 
 Remove a log or checkout entry by its hash.
 
 ```bash
-hourgit remove <hash> [--project <name>] [--yes]
+hourgit log remove <hash> [--project <name>] [--yes]
 ```
 
 | Flag | Default | Description |
@@ -209,7 +209,7 @@ hourgit remove <hash> [--project <name>] [--yes]
 | `-p`, `--project` | auto-detect | Project name or ID |
 | `-y`, `--yes` | `false` | Skip confirmation prompt |
 
-> Works with both log and checkout entries (unlike `edit`, which only supports log entries). Shows entry details and asks for confirmation before deleting. If the entry is not found in the current repo's project, all projects are searched.
+> Works with both log and checkout entries (unlike `log edit`, which only supports log entries). Shows entry details and asks for confirmation before deleting. If the entry is not found in the current repo's project, all projects are searched.
 
 #### `hourgit sync`
 
diff --git a/internal/cli/log.go b/internal/cli/log.go
index 368d980..6d1a150 100644
--- a/internal/cli/log.go
+++ b/internal/cli/log.go
@@ -1,443 +1,13 @@
 package cli
 
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/Flyrell/hourgit/internal/entry"
-	"github.com/Flyrell/hourgit/internal/hashutil"
-	"github.com/Flyrell/hourgit/internal/project"
-	"github.com/Flyrell/hourgit/internal/schedule"
-	"github.com/Flyrell/hourgit/internal/timetrack"
-	"github.com/spf13/cobra"
-)
-
-var logCmd = LeafCommand{
-	Use:   "log [message]",
-	Short: "Log time manually for a project",
-	Args:  cobra.MaximumNArgs(1),
-	BoolFlags: []BoolFlag{
-		{Name: "yes", Shorthand: "y", Usage: "skip confirmation prompts"},
-	},
-	StrFlags: []StringFlag{
-		{Name: "project", Shorthand: "p", Usage: "project name or ID (auto-detected from repo if omitted)"},
-		{Name: "duration", Shorthand: "d", Usage: "duration to log (e.g. 30m, 3h, 3h30m)"},
-		{Name: "from", Shorthand: "F", Usage: "start time (e.g. 9am, 14:00)"},
-		{Name: "to", Shorthand: "T", Usage: "end time (e.g. 5pm, 17:00)"},
-		{Name: "date", Shorthand: "D", Usage: "date to log for (YYYY-MM-DD, default: today)"},
-		{Name: "task", Shorthand: "t", Usage: "task label for this entry"},
-	},
-	RunE: func(cmd *cobra.Command, args []string) error {
-		homeDir, repoDir, err := getContextPaths()
-		if err != nil {
-			return err
-		}
-
-		projectFlag, _ := cmd.Flags().GetString("project")
-		durationFlag, _ := cmd.Flags().GetString("duration")
-		fromFlag, _ := cmd.Flags().GetString("from")
-		toFlag, _ := cmd.Flags().GetString("to")
-		dateFlag, _ := cmd.Flags().GetString("date")
-		taskFlag, _ := cmd.Flags().GetString("task")
-		yesFlag, _ := cmd.Flags().GetBool("yes")
-
-		var message string
-		if len(args) > 0 {
-			message = args[0]
-		}
-
-		pk := NewPromptKit()
-		if yesFlag {
-			pk.Confirm = AlwaysYes()
-		}
-		return runLog(cmd, homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message, pk, time.Now)
+import "github.com/spf13/cobra"
+
+var logCmd = GroupCommand{
+	Use:   "log",
+	Short: "Log and manage time entries",
+	Subcommands: []*cobra.Command{
+		logAddCmd,
+		logEditCmd,
+		logRemoveCmd,
 	},
 }.Build()
-
-func runLog(
-	cmd *cobra.Command,
-	homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message string,
-	pk PromptKit,
-	nowFn func() time.Time,
-) error {
-	proj, err := ResolveProjectContext(homeDir, repoDir, projectFlag)
-	if err != nil {
-		return err
-	}
-
-	hasDuration := durationFlag != ""
-	hasFrom := fromFlag != ""
-	hasTo := toFlag != ""
-
-	// 1. Validate mutual exclusivity
-	if hasDuration && (hasFrom || hasTo) {
-		return fmt.Errorf("--duration and --from/--to are mutually exclusive")
-	}
-
-	now := nowFn()
-
-	// 2. Resolve date: use flag if provided, otherwise prompt
-	if dateFlag == "" && !hasDuration && !hasFrom && !hasTo && message == "" {
-		dateFlag, err = pk.Prompt("Date (YYYY-MM-DD, default: today)")
-		if err != nil {
-			return err
-		}
-	}
-
-	baseDate, err := resolveBaseDate(dateFlag, now)
-	if err != nil {
-		return err
-	}
-
-	// 3. Resolve time mode
-	if !hasDuration && !hasFrom && !hasTo {
-		modeIdx, err := pk.Select("How do you want to log time?", []string{"Duration (e.g. 3h30m)", "Time range (e.g. 9am to 5pm)"})
-		if err != nil {
-			return err
-		}
-		if modeIdx == 0 {
-			hasDuration = true
-		}
-	}
-
-	var minutes int
-	var start time.Time
-
-	if hasDuration {
-		if durationFlag == "" {
-			durationFlag, err = pk.Prompt("Duration (e.g. 30m, 3h, 3h30m)")
-			if err != nil {
-				return err
-			}
-		}
-		minutes, err = entry.ParseDuration(durationFlag)
-		if err != nil {
-			return err
-		}
-		start, err = findDurationSlot(homeDir, proj, baseDate, minutes, now)
-		if err != nil {
-			// No schedule or no room — place at beginning of day;
-			// the schedule warning system will inform the user
-			y, m, d := baseDate.Date()
-			start = time.Date(y, m, d, defaultStartHour, 0, 0, 0, now.Location())
-		}
-	} else {
-		if fromFlag == "" {
-			fromFlag, err = pk.Prompt("From (e.g. 9am, 14:00)")
-			if err != nil {
-				return err
-			}
-		}
-		if toFlag == "" {
-			toFlag, err = pk.Prompt("To (e.g. 5pm, 17:00)")
-			if err != nil {
-				return err
-			}
-		}
-		start, minutes, err = parseFromTo(fromFlag, toFlag, baseDate)
-		if err != nil {
-			return err
-		}
-	}
-
-	// 4. Validate 24h cap
-	if minutes > 24*60 {
-		return fmt.Errorf("cannot log more than 24h in a single entry")
-	}
-
-	// 5. Check schedule warnings
-	proceed, err := checkScheduleWarnings(cmd, homeDir, proj, start, minutes, "", pk.Confirm)
-	if err != nil {
-		return err
-	}
-	if !proceed {
-		return nil
-	}
-
-	// 6. Resolve message
-	if message == "" {
-		message, err = pk.Prompt("Message")
-		if err != nil {
-			return err
-		}
-	}
-	if message == "" {
-		return fmt.Errorf("message is required")
-	}
-
-	return writeAndPrintEntry(cmd, homeDir, proj, start, minutes, message, taskFlag, now)
-}
-
-// resolveBaseDate parses the --date flag value into a date.
-// If dateFlag is empty, returns now (today).
-func resolveBaseDate(dateFlag string, now time.Time) (time.Time, error) {
-	if dateFlag == "" {
-		return now, nil
-	}
-	d, err := time.Parse("2006-01-02", dateFlag)
-	if err != nil {
-		return time.Time{}, fmt.Errorf("invalid --date format, expected YYYY-MM-DD: %w", err)
-	}
-	return d, nil
-}
-
-func parseFromTo(fromStr, toStr string, baseDate time.Time) (time.Time, int, error) {
-	fromTOD, err := schedule.ParseTimeOfDay(fromStr)
-	if err != nil {
-		return time.Time{}, 0, fmt.Errorf("invalid --from time: %w", err)
-	}
-	toTOD, err := schedule.ParseTimeOfDay(toStr)
-	if err != nil {
-		return time.Time{}, 0, fmt.Errorf("invalid --to time: %w", err)
-	}
-
-	if !fromTOD.Before(toTOD) {
-		return time.Time{}, 0, fmt.Errorf("--from (%s) must be before --to (%s)", fromTOD, toTOD)
-	}
-
-	y, m, d := baseDate.Date()
-	loc := baseDate.Location()
-	start := time.Date(y, m, d, fromTOD.Hour, fromTOD.Minute, 0, 0, loc)
-	end := time.Date(y, m, d, toTOD.Hour, toTOD.Minute, 0, 0, loc)
-	minutes := int(end.Sub(start).Minutes())
-
-	return start, minutes, nil
-}
-
-// checkScheduleWarnings warns the user about schedule-related issues:
-// 1. No scheduled hours for the day
-// 2. Entry falls outside (or partially outside) schedule windows
-// 3. Entry exceeds remaining scheduled budget
-// Returns (true, nil) to proceed, (false, nil) to cancel.
-func checkScheduleWarnings(
-	cmd *cobra.Command,
-	homeDir string,
-	proj *project.ProjectEntry,
-	entryStart time.Time,
-	minutes int,
-	excludeID string,
-	confirm ConfirmFunc,
-) (bool, error) {
-	if confirm == nil {
-		return true, nil
-	}
-
-	windows, scheduledMinutes, daySchedules, err := getDayScheduleWindows(homeDir, proj, entryStart)
-	if err != nil {
-		return false, err
-	}
-
-	// 1. No scheduled hours for this day
-	if scheduledMinutes == 0 {
-		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s this day has no scheduled working hours.\n",
-			Warning("Warning:"),
-		)
-		ok, err := confirm("Continue anyway?")
-		if err != nil {
-			return false, err
-		}
-		return ok, nil
-	}
-
-	// 2. Check if entry falls outside schedule windows
-	proceed, err := checkBoundsWarning(cmd, confirm, windows, entryStart, minutes)
-	if err != nil {
-		return false, err
-	}
-	if !proceed {
-		return false, nil
-	}
-
-	// 3. Check budget overrun
-	return checkBudgetWarning(cmd, confirm, homeDir, proj, entryStart, minutes, daySchedules, excludeID)
-}
-
-// getDayScheduleWindows returns the schedule windows, total scheduled minutes,
-// and expanded day schedules for the day containing entryStart.
-func getDayScheduleWindows(homeDir string, proj *project.ProjectEntry, entryStart time.Time) ([]schedule.TimeWindow, int, []schedule.DaySchedule, error) {
-	cfg, err := project.ReadConfig(homeDir)
-	if err != nil {
-		return nil, 0, nil, err
-	}
-
-	schedules := project.GetSchedules(cfg, proj.ID)
-
-	y, m, d := entryStart.Date()
-	dayStart := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)
-	dayEnd := time.Date(y, m, d, 23, 59, 59, 0, time.UTC)
-
-	daySchedules, err := schedule.ExpandSchedules(schedules, dayStart, dayEnd)
-	if err != nil {
-		return nil, 0, nil, err
-	}
-
-	var dayWindows []schedule.TimeWindow
-	dateKey := dayStart.Format("2006-01-02")
-	for _, ds := range daySchedules {
-		if ds.Date.Format("2006-01-02") == dateKey {
-			dayWindows = ds.Windows
-			break
-		}
-	}
-
-	scheduledMinutes := 0
-	for _, w := range dayWindows {
-		fromMins := w.From.Hour*60 + w.From.Minute
-		toMins := w.To.Hour*60 + w.To.Minute
-		scheduledMinutes += toMins - fromMins
-	}
-
-	return dayWindows, scheduledMinutes, daySchedules, nil
-}
-
-// checkBoundsWarning warns if the entry falls fully or partially outside
-// schedule windows. Returns (true, nil) to proceed, (false, nil) to cancel.
-func checkBoundsWarning(
-	cmd *cobra.Command,
-	confirm ConfirmFunc,
-	windows []schedule.TimeWindow,
-	entryStart time.Time,
-	minutes int,
-) (bool, error) {
-	entryFromMins := entryStart.Hour()*60 + entryStart.Minute()
-	entryToMins := entryFromMins + minutes
-
-	overlapMins := 0
-	for _, w := range windows {
-		wFrom := w.From.Hour*60 + w.From.Minute
-		wTo := w.To.Hour*60 + w.To.Minute
-		overlap := min(entryToMins, wTo) - max(entryFromMins, wFrom)
-		if overlap > 0 {
-			overlapMins += overlap
-		}
-	}
-
-	windowsSummary := formatWindowsSummary(windows)
-
-	if overlapMins == 0 {
-		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s this entry falls outside your scheduled hours (%s).\n",
-			Warning("Warning:"),
-			Primary(windowsSummary),
-		)
-	} else if overlapMins < minutes {
-		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s this entry partially falls outside your scheduled hours (%s).\n",
-			Warning("Warning:"),
-			Primary(windowsSummary),
-		)
-	} else {
-		return true, nil
-	}
-
-	ok, err := confirm("Continue anyway?")
-	if err != nil {
-		return false, err
-	}
-	return ok, nil
-}
-
-// checkBudgetWarning warns if the entry exceeds the remaining scheduled budget
-// for the day. Returns (true, nil) to proceed, (false, nil) to cancel.
-func checkBudgetWarning(
-	cmd *cobra.Command,
-	confirm ConfirmFunc,
-	homeDir string,
-	proj *project.ProjectEntry,
-	entryStart time.Time,
-	minutes int,
-	daySchedules []schedule.DaySchedule,
-	excludeID string,
-) (bool, error) {
-	logs, err := entry.ReadAllEntries(homeDir, proj.Slug)
-	if err != nil {
-		return false, err
-	}
-
-	budget := timetrack.ComputeManualLogBudget(logs, daySchedules, entryStart, excludeID)
-
-	if minutes > budget.RemainingMinutes {
-		if budget.RemainingMinutes <= 0 {
-			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s you have already logged your full schedule for this day (%s scheduled, %s logged).\n",
-				Warning("Warning:"),
-				Primary(entry.FormatMinutes(budget.ScheduledMinutes)),
-				Primary(entry.FormatMinutes(budget.LoggedMinutes)),
-			)
-		} else {
-			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s you are about to log %s, but only %s remains in today's schedule (%s scheduled, %s already logged).\n",
-				Warning("Warning:"),
-				Primary(entry.FormatMinutes(minutes)),
-				Primary(entry.FormatMinutes(budget.RemainingMinutes)),
-				Primary(entry.FormatMinutes(budget.ScheduledMinutes)),
-				Primary(entry.FormatMinutes(budget.LoggedMinutes)),
-			)
-		}
-
-		ok, err := confirm("Continue anyway?")
-		if err != nil {
-			return false, err
-		}
-		return ok, nil
-	}
-
-	return true, nil
-}
-
-// findDurationSlot attempts to find the first available schedule slot for a
-// duration-only log entry. Returns an error if no schedule is configured or
-// no slot is available.
-func findDurationSlot(homeDir string, proj *project.ProjectEntry, baseDate time.Time, minutes int, now time.Time) (time.Time, error) {
-	windows, _, _, err := getDayScheduleWindows(homeDir, proj, baseDate)
-	if err != nil {
-		return time.Time{}, err
-	}
-	if len(windows) == 0 {
-		return time.Time{}, fmt.Errorf("no schedule windows")
-	}
-
-	logs, err := entry.ReadAllEntries(homeDir, proj.Slug)
-	if err != nil {
-		return time.Time{}, err
-	}
-
-	return timetrack.FindAvailableSlot(logs, windows, baseDate, minutes, now.Location())
-}
-
-// formatWindowsSummary formats schedule windows as a comma-separated summary.
-func formatWindowsSummary(windows []schedule.TimeWindow) string {
-	parts := make([]string, len(windows))
-	for i, w := range windows {
-		parts[i] = schedule.FormatTimeRange(w.From.String(), w.To.String())
-	}
-	return strings.Join(parts, ", ")
-}
-
-func writeAndPrintEntry(
-	cmd *cobra.Command,
-	homeDir string,
-	proj *project.ProjectEntry,
-	start time.Time,
-	minutes int,
-	message, task string,
-	now time.Time,
-) error {
-	e := entry.Entry{
-		ID:        hashutil.GenerateID("log"),
-		Start:     start.UTC(),
-		Minutes:   minutes,
-		Message:   message,
-		Task:      task,
-		CreatedAt: now.UTC(),
-	}
-
-	if err := entry.WriteEntry(homeDir, proj.Slug, e); err != nil {
-		return err
-	}
-
-	_, _ = fmt.Fprintf(cmd.OutOrStdout(), "logged %s for project '%s' (%s)\n",
-		Primary(entry.FormatMinutes(e.Minutes)),
-		Primary(proj.Name),
-		Silent(e.ID),
-	)
-
-	return nil
-}
diff --git a/internal/cli/log_add.go b/internal/cli/log_add.go
new file mode 100644
index 0000000..7d38426
--- /dev/null
+++ b/internal/cli/log_add.go
@@ -0,0 +1,443 @@
+package cli
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/Flyrell/hourgit/internal/entry"
+	"github.com/Flyrell/hourgit/internal/hashutil"
+	"github.com/Flyrell/hourgit/internal/project"
+	"github.com/Flyrell/hourgit/internal/schedule"
+	"github.com/Flyrell/hourgit/internal/timetrack"
+	"github.com/spf13/cobra"
+)
+
+var logAddCmd = LeafCommand{
+	Use:   "add [message]",
+	Short: "Log time manually for a project",
+	Args:  cobra.MaximumNArgs(1),
+	BoolFlags: []BoolFlag{
+		{Name: "yes", Shorthand: "y", Usage: "skip confirmation prompts"},
+	},
+	StrFlags: []StringFlag{
+		{Name: "project", Shorthand: "p", Usage: "project name or ID (auto-detected from repo if omitted)"},
+		{Name: "duration", Shorthand: "d", Usage: "duration to log (e.g. 30m, 3h, 3h30m)"},
+		{Name: "from", Shorthand: "F", Usage: "start time (e.g. 9am, 14:00)"},
+		{Name: "to", Shorthand: "T", Usage: "end time (e.g. 5pm, 17:00)"},
+		{Name: "date", Shorthand: "D", Usage: "date to log for (YYYY-MM-DD, default: today)"},
+		{Name: "task", Shorthand: "t", Usage: "task label for this entry"},
+	},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		homeDir, repoDir, err := getContextPaths()
+		if err != nil {
+			return err
+		}
+
+		projectFlag, _ := cmd.Flags().GetString("project")
+		durationFlag, _ := cmd.Flags().GetString("duration")
+		fromFlag, _ := cmd.Flags().GetString("from")
+		toFlag, _ := cmd.Flags().GetString("to")
+		dateFlag, _ := cmd.Flags().GetString("date")
+		taskFlag, _ := cmd.Flags().GetString("task")
+		yesFlag, _ := cmd.Flags().GetBool("yes")
+
+		var message string
+		if len(args) > 0 {
+			message = args[0]
+		}
+
+		pk := NewPromptKit()
+		if yesFlag {
+			pk.Confirm = AlwaysYes()
+		}
+		return runLogAdd(cmd, homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message, pk, time.Now)
+	},
+}.Build()
+
+func runLogAdd(
+	cmd *cobra.Command,
+	homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message string,
+	pk PromptKit,
+	nowFn func() time.Time,
+) error {
+	proj, err := ResolveProjectContext(homeDir, repoDir, projectFlag)
+	if err != nil {
+		return err
+	}
+
+	hasDuration := durationFlag != ""
+	hasFrom := fromFlag != ""
+	hasTo := toFlag != ""
+
+	// 1. Validate mutual exclusivity
+	if hasDuration && (hasFrom || hasTo) {
+		return fmt.Errorf("--duration and --from/--to are mutually exclusive")
+	}
+
+	now := nowFn()
+
+	// 2. Resolve date: use flag if provided, otherwise prompt
+	if dateFlag == "" && !hasDuration && !hasFrom && !hasTo && message == "" {
+		dateFlag, err = pk.Prompt("Date (YYYY-MM-DD, default: today)")
+		if err != nil {
+			return err
+		}
+	}
+
+	baseDate, err := resolveBaseDate(dateFlag, now)
+	if err != nil {
+		return err
+	}
+
+	// 3. Resolve time mode
+	if !hasDuration && !hasFrom && !hasTo {
+		modeIdx, err := pk.Select("How do you want to log time?", []string{"Duration (e.g. 3h30m)", "Time range (e.g. 9am to 5pm)"})
+		if err != nil {
+			return err
+		}
+		if modeIdx == 0 {
+			hasDuration = true
+		}
+	}
+
+	var minutes int
+	var start time.Time
+
+	if hasDuration {
+		if durationFlag == "" {
+			durationFlag, err = pk.Prompt("Duration (e.g. 30m, 3h, 3h30m)")
+			if err != nil {
+				return err
+			}
+		}
+		minutes, err = entry.ParseDuration(durationFlag)
+		if err != nil {
+			return err
+		}
+		start, err = findDurationSlot(homeDir, proj, baseDate, minutes, now)
+		if err != nil {
+			// No schedule or no room — place at beginning of day;
+			// the schedule warning system will inform the user
+			y, m, d := baseDate.Date()
+			start = time.Date(y, m, d, defaultStartHour, 0, 0, 0, now.Location())
+		}
+	} else {
+		if fromFlag == "" {
+			fromFlag, err = pk.Prompt("From (e.g. 9am, 14:00)")
+			if err != nil {
+				return err
+			}
+		}
+		if toFlag == "" {
+			toFlag, err = pk.Prompt("To (e.g. 5pm, 17:00)")
+			if err != nil {
+				return err
+			}
+		}
+		start, minutes, err = parseFromTo(fromFlag, toFlag, baseDate)
+		if err != nil {
+			return err
+		}
+	}
+
+	// 4. Validate 24h cap
+	if minutes > 24*60 {
+		return fmt.Errorf("cannot log more than 24h in a single entry")
+	}
+
+	// 5. Check schedule warnings
+	proceed, err := checkScheduleWarnings(cmd, homeDir, proj, start, minutes, "", pk.Confirm)
+	if err != nil {
+		return err
+	}
+	if !proceed {
+		return nil
+	}
+
+	// 6. Resolve message
+	if message == "" {
+		message, err = pk.Prompt("Message")
+		if err != nil {
+			return err
+		}
+	}
+	if message == "" {
+		return fmt.Errorf("message is required")
+	}
+
+	return writeAndPrintEntry(cmd, homeDir, proj, start, minutes, message, taskFlag, now)
+}
+
+// resolveBaseDate parses the --date flag value into a date.
+// If dateFlag is empty, returns now (today).
+func resolveBaseDate(dateFlag string, now time.Time) (time.Time, error) {
+	if dateFlag == "" {
+		return now, nil
+	}
+	d, err := time.Parse("2006-01-02", dateFlag)
+	if err != nil {
+		return time.Time{}, fmt.Errorf("invalid --date format, expected YYYY-MM-DD: %w", err)
+	}
+	return d, nil
+}
+
+func parseFromTo(fromStr, toStr string, baseDate time.Time) (time.Time, int, error) {
+	fromTOD, err := schedule.ParseTimeOfDay(fromStr)
+	if err != nil {
+		return time.Time{}, 0, fmt.Errorf("invalid --from time: %w", err)
+	}
+	toTOD, err := schedule.ParseTimeOfDay(toStr)
+	if err != nil {
+		return time.Time{}, 0, fmt.Errorf("invalid --to time: %w", err)
+	}
+
+	if !fromTOD.Before(toTOD) {
+		return time.Time{}, 0, fmt.Errorf("--from (%s) must be before --to (%s)", fromTOD, toTOD)
+	}
+
+	y, m, d := baseDate.Date()
+	loc := baseDate.Location()
+	start := time.Date(y, m, d, fromTOD.Hour, fromTOD.Minute, 0, 0, loc)
+	end := time.Date(y, m, d, toTOD.Hour, toTOD.Minute, 0, 0, loc)
+	minutes := int(end.Sub(start).Minutes())
+
+	return start, minutes, nil
+}
+
+// checkScheduleWarnings warns the user about schedule-related issues:
+// 1. No scheduled hours for the day
+// 2. Entry falls outside (or partially outside) schedule windows
+// 3. Entry exceeds remaining scheduled budget
+// Returns (true, nil) to proceed, (false, nil) to cancel.
+func checkScheduleWarnings(
+	cmd *cobra.Command,
+	homeDir string,
+	proj *project.ProjectEntry,
+	entryStart time.Time,
+	minutes int,
+	excludeID string,
+	confirm ConfirmFunc,
+) (bool, error) {
+	if confirm == nil {
+		return true, nil
+	}
+
+	windows, scheduledMinutes, daySchedules, err := getDayScheduleWindows(homeDir, proj, entryStart)
+	if err != nil {
+		return false, err
+	}
+
+	// 1. No scheduled hours for this day
+	if scheduledMinutes == 0 {
+		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s this day has no scheduled working hours.\n",
+			Warning("Warning:"),
+		)
+		ok, err := confirm("Continue anyway?")
+		if err != nil {
+			return false, err
+		}
+		return ok, nil
+	}
+
+	// 2. Check if entry falls outside schedule windows
+	proceed, err := checkBoundsWarning(cmd, confirm, windows, entryStart, minutes)
+	if err != nil {
+		return false, err
+	}
+	if !proceed {
+		return false, nil
+	}
+
+	// 3. Check budget overrun
+	return checkBudgetWarning(cmd, confirm, homeDir, proj, entryStart, minutes, daySchedules, excludeID)
+}
+
+// getDayScheduleWindows returns the schedule windows, total scheduled minutes,
+// and expanded day schedules for the day containing entryStart.
+func getDayScheduleWindows(homeDir string, proj *project.ProjectEntry, entryStart time.Time) ([]schedule.TimeWindow, int, []schedule.DaySchedule, error) {
+	cfg, err := project.ReadConfig(homeDir)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+
+	schedules := project.GetSchedules(cfg, proj.ID)
+
+	y, m, d := entryStart.Date()
+	dayStart := time.Date(y, m, d, 0, 0, 0, 0, time.UTC)
+	dayEnd := time.Date(y, m, d, 23, 59, 59, 0, time.UTC)
+
+	daySchedules, err := schedule.ExpandSchedules(schedules, dayStart, dayEnd)
+	if err != nil {
+		return nil, 0, nil, err
+	}
+
+	var dayWindows []schedule.TimeWindow
+	dateKey := dayStart.Format("2006-01-02")
+	for _, ds := range daySchedules {
+		if ds.Date.Format("2006-01-02") == dateKey {
+			dayWindows = ds.Windows
+			break
+		}
+	}
+
+	scheduledMinutes := 0
+	for _, w := range dayWindows {
+		fromMins := w.From.Hour*60 + w.From.Minute
+		toMins := w.To.Hour*60 + w.To.Minute
+		scheduledMinutes += toMins - fromMins
+	}
+
+	return dayWindows, scheduledMinutes, daySchedules, nil
+}
+
+// checkBoundsWarning warns if the entry falls fully or partially outside
+// schedule windows. Returns (true, nil) to proceed, (false, nil) to cancel.
+func checkBoundsWarning(
+	cmd *cobra.Command,
+	confirm ConfirmFunc,
+	windows []schedule.TimeWindow,
+	entryStart time.Time,
+	minutes int,
+) (bool, error) {
+	entryFromMins := entryStart.Hour()*60 + entryStart.Minute()
+	entryToMins := entryFromMins + minutes
+
+	overlapMins := 0
+	for _, w := range windows {
+		wFrom := w.From.Hour*60 + w.From.Minute
+		wTo := w.To.Hour*60 + w.To.Minute
+		overlap := min(entryToMins, wTo) - max(entryFromMins, wFrom)
+		if overlap > 0 {
+			overlapMins += overlap
+		}
+	}
+
+	windowsSummary := formatWindowsSummary(windows)
+
+	if overlapMins == 0 {
+		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s this entry falls outside your scheduled hours (%s).\n",
+			Warning("Warning:"),
+			Primary(windowsSummary),
+		)
+	} else if overlapMins < minutes {
+		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s this entry partially falls outside your scheduled hours (%s).\n",
+			Warning("Warning:"),
+			Primary(windowsSummary),
+		)
+	} else {
+		return true, nil
+	}
+
+	ok, err := confirm("Continue anyway?")
+	if err != nil {
+		return false, err
+	}
+	return ok, nil
+}
+
+// checkBudgetWarning warns if the entry exceeds the remaining scheduled budget
+// for the day. Returns (true, nil) to proceed, (false, nil) to cancel.
+func checkBudgetWarning(
+	cmd *cobra.Command,
+	confirm ConfirmFunc,
+	homeDir string,
+	proj *project.ProjectEntry,
+	entryStart time.Time,
+	minutes int,
+	daySchedules []schedule.DaySchedule,
+	excludeID string,
+) (bool, error) {
+	logs, err := entry.ReadAllEntries(homeDir, proj.Slug)
+	if err != nil {
+		return false, err
+	}
+
+	budget := timetrack.ComputeManualLogBudget(logs, daySchedules, entryStart, excludeID)
+
+	if minutes > budget.RemainingMinutes {
+		if budget.RemainingMinutes <= 0 {
+			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s you have already logged your full schedule for this day (%s scheduled, %s logged).\n",
+				Warning("Warning:"),
+				Primary(entry.FormatMinutes(budget.ScheduledMinutes)),
+				Primary(entry.FormatMinutes(budget.LoggedMinutes)),
+			)
+		} else {
+			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s you are about to log %s, but only %s remains in today's schedule (%s scheduled, %s already logged).\n",
+				Warning("Warning:"),
+				Primary(entry.FormatMinutes(minutes)),
+				Primary(entry.FormatMinutes(budget.RemainingMinutes)),
+				Primary(entry.FormatMinutes(budget.ScheduledMinutes)),
+				Primary(entry.FormatMinutes(budget.LoggedMinutes)),
+			)
+		}
+
+		ok, err := confirm("Continue anyway?")
+		if err != nil {
+			return false, err
+		}
+		return ok, nil
+	}
+
+	return true, nil
+}
+
+// findDurationSlot attempts to find the first available schedule slot for a
+// duration-only log entry. Returns an error if no schedule is configured or
+// no slot is available.
+func findDurationSlot(homeDir string, proj *project.ProjectEntry, baseDate time.Time, minutes int, now time.Time) (time.Time, error) {
+	windows, _, _, err := getDayScheduleWindows(homeDir, proj, baseDate)
+	if err != nil {
+		return time.Time{}, err
+	}
+	if len(windows) == 0 {
+		return time.Time{}, fmt.Errorf("no schedule windows")
+	}
+
+	logs, err := entry.ReadAllEntries(homeDir, proj.Slug)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	return timetrack.FindAvailableSlot(logs, windows, baseDate, minutes, now.Location())
+}
+
+// formatWindowsSummary formats schedule windows as a comma-separated summary.
+func formatWindowsSummary(windows []schedule.TimeWindow) string {
+	parts := make([]string, len(windows))
+	for i, w := range windows {
+		parts[i] = schedule.FormatTimeRange(w.From.String(), w.To.String())
+	}
+	return strings.Join(parts, ", ")
+}
+
+func writeAndPrintEntry(
+	cmd *cobra.Command,
+	homeDir string,
+	proj *project.ProjectEntry,
+	start time.Time,
+	minutes int,
+	message, task string,
+	now time.Time,
+) error {
+	e := entry.Entry{
+		ID:        hashutil.GenerateID("log"),
+		Start:     start.UTC(),
+		Minutes:   minutes,
+		Message:   message,
+		Task:      task,
+		CreatedAt: now.UTC(),
+	}
+
+	if err := entry.WriteEntry(homeDir, proj.Slug, e); err != nil {
+		return err
+	}
+
+	_, _ = fmt.Fprintf(cmd.OutOrStdout(), "logged %s for project '%s' (%s)\n",
+		Primary(entry.FormatMinutes(e.Minutes)),
+		Primary(proj.Name),
+		Silent(e.ID),
+	)
+
+	return nil
+}
diff --git a/internal/cli/log_test.go b/internal/cli/log_add_test.go
similarity index 66%
rename from internal/cli/log_test.go
rename to internal/cli/log_add_test.go
index ca3891f..30effcf 100644
--- a/internal/cli/log_test.go
+++ b/internal/cli/log_add_test.go
@@ -9,11 +9,12 @@ import (
 
 	"github.com/Flyrell/hourgit/internal/entry"
 	"github.com/Flyrell/hourgit/internal/project"
+	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func setupLogTest(t *testing.T) (homeDir string, repoDir string, proj *project.ProjectEntry) {
+func setupLogAddTest(t *testing.T) (homeDir string, repoDir string, proj *project.ProjectEntry) {
 	t.Helper()
 	homeDir = t.TempDir()
 	repoDir = t.TempDir()
@@ -35,25 +36,25 @@ func fixedNow() time.Time {
 	return time.Date(2025, 6, 15, 14, 0, 0, 0, time.UTC)
 }
 
-func execLog(homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message string) (string, error) {
-	return execLogWithPrompts(homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message, PromptKit{
+func execLogAdd(homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message string) (string, error) {
+	return execLogAddWithPrompts(homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message, PromptKit{
 		Confirm: AlwaysYes(),
 	})
 }
 
-func execLogWithPrompts(homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message string, pk PromptKit) (string, error) {
+func execLogAddWithPrompts(homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message string, pk PromptKit) (string, error) {
 	stdout := new(bytes.Buffer)
-	cmd := logCmd
+	cmd := logAddCmd
 	cmd.SetOut(stdout)
 
-	err := runLog(cmd, homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message, pk, fixedNow)
+	err := runLogAdd(cmd, homeDir, repoDir, projectFlag, durationFlag, fromFlag, toFlag, dateFlag, taskFlag, message, pk, fixedNow)
 	return stdout.String(), err
 }
 
-func TestLogDurationMode(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDurationMode(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
-	stdout, err := execLog(homeDir, repoDir, "", "3h", "", "", "", "", "did some work")
+	stdout, err := execLogAdd(homeDir, repoDir, "", "3h", "", "", "", "", "did some work")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "logged")
@@ -68,10 +69,10 @@ func TestLogDurationMode(t *testing.T) {
 	assert.Equal(t, 9, entries[0].Start.Hour())
 }
 
-func TestLogFromToMode(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddFromToMode(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
-	stdout, err := execLog(homeDir, repoDir, "", "", "9am", "12pm", "", "", "morning work")
+	stdout, err := execLogAdd(homeDir, repoDir, "", "", "9am", "12pm", "", "", "morning work")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "logged")
@@ -85,10 +86,10 @@ func TestLogFromToMode(t *testing.T) {
 	assert.Equal(t, 9, entries[0].Start.Hour())
 }
 
-func TestLogByProjectFlag(t *testing.T) {
-	homeDir, _, proj := setupLogTest(t)
+func TestLogAddByProjectFlag(t *testing.T) {
+	homeDir, _, proj := setupLogAddTest(t)
 
-	stdout, err := execLog(homeDir, "", proj.Name, "1h", "", "", "", "", "flagged project")
+	stdout, err := execLogAdd(homeDir, "", proj.Name, "1h", "", "", "", "", "flagged project")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "Log Test")
@@ -98,17 +99,17 @@ func TestLogByProjectFlag(t *testing.T) {
 	assert.Len(t, entries, 1)
 }
 
-func TestLogDurationAndFromToMutuallyExclusive(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddDurationAndFromToMutuallyExclusive(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
-	_, err := execLog(homeDir, repoDir, "", "3h", "9am", "12pm", "", "", "conflict")
+	_, err := execLogAdd(homeDir, repoDir, "", "3h", "9am", "12pm", "", "", "conflict")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "mutually exclusive")
 }
 
-func TestLogFromWithoutTo(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddFromWithoutTo(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -123,7 +124,7 @@ func TestLogFromWithoutTo(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "9am", "", "", "", "", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "9am", "", "", "", "", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "3h")
@@ -135,8 +136,8 @@ func TestLogFromWithoutTo(t *testing.T) {
 	assert.Equal(t, "prompted to", entries[0].Message)
 }
 
-func TestLogToWithoutFrom(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddToWithoutFrom(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -151,7 +152,7 @@ func TestLogToWithoutFrom(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "", "12pm", "", "", "", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "", "12pm", "", "", "", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "3h")
@@ -163,26 +164,26 @@ func TestLogToWithoutFrom(t *testing.T) {
 	assert.Equal(t, "prompted from", entries[0].Message)
 }
 
-func TestLogFromAfterTo(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddFromAfterTo(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
-	_, err := execLog(homeDir, repoDir, "", "", "5pm", "9am", "", "", "backwards")
+	_, err := execLogAdd(homeDir, repoDir, "", "", "5pm", "9am", "", "", "backwards")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "must be before")
 }
 
-func TestLogInvalidDuration(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddInvalidDuration(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
-	_, err := execLog(homeDir, repoDir, "", "abc", "", "", "", "", "bad duration")
+	_, err := execLogAdd(homeDir, repoDir, "", "abc", "", "", "", "", "bad duration")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "invalid duration")
 }
 
-func TestLogDurationNoMessage(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDurationNoMessage(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -194,7 +195,7 @@ func TestLogDurationNoMessage(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "3h", "", "", "", "", "", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "3h", "", "", "", "", "", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "3h")
@@ -205,8 +206,8 @@ func TestLogDurationNoMessage(t *testing.T) {
 	assert.Equal(t, "prompted msg", entries[0].Message)
 }
 
-func TestLogFromToNoMessage(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddFromToNoMessage(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -218,7 +219,7 @@ func TestLogFromToNoMessage(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "9am", "5pm", "", "", "", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "9am", "5pm", "", "", "", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "8h")
@@ -229,8 +230,8 @@ func TestLogFromToNoMessage(t *testing.T) {
 	assert.Equal(t, "prompted msg", entries[0].Message)
 }
 
-func TestLogMessageOnly(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddMessageOnly(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -246,7 +247,7 @@ func TestLogMessageOnly(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "", "", "", "", "pre-filled msg", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "", "", "", "", "pre-filled msg", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "2h")
@@ -257,8 +258,8 @@ func TestLogMessageOnly(t *testing.T) {
 	assert.Equal(t, "pre-filled msg", entries[0].Message)
 }
 
-func TestLogDateOnly(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDateOnly(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -274,7 +275,7 @@ func TestLogDateOnly(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "", "", "2025-01-10", "", "", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "", "", "2025-01-10", "", "", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "1h")
@@ -288,8 +289,8 @@ func TestLogDateOnly(t *testing.T) {
 	assert.Equal(t, "date only work", entries[0].Message)
 }
 
-func TestLogDurationWithDateNoMessage(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDurationWithDateNoMessage(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -301,7 +302,7 @@ func TestLogDurationWithDateNoMessage(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "3h", "", "", "2025-01-10", "", "", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "3h", "", "", "2025-01-10", "", "", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "3h")
@@ -314,8 +315,8 @@ func TestLogDurationWithDateNoMessage(t *testing.T) {
 	assert.Equal(t, "date+dur msg", entries[0].Message)
 }
 
-func TestLogEmptyMessagePromptedStillRequired(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddEmptyMessagePromptedStillRequired(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
 	pk := PromptKit{
 		Confirm: AlwaysYes(),
@@ -324,26 +325,26 @@ func TestLogEmptyMessagePromptedStillRequired(t *testing.T) {
 		},
 	}
 
-	_, err := execLogWithPrompts(homeDir, repoDir, "", "1h", "", "", "", "", "", pk)
+	_, err := execLogAddWithPrompts(homeDir, repoDir, "", "1h", "", "", "", "", "", pk)
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "message is required")
 }
 
-func TestLogNoProject(t *testing.T) {
+func TestLogAddNoProject(t *testing.T) {
 	homeDir := t.TempDir()
 
-	_, err := execLog(homeDir, "", "", "1h", "", "", "", "", "no project")
+	_, err := execLogAdd(homeDir, "", "", "1h", "", "", "", "", "no project")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "no project found")
 }
 
-func TestLogInteractiveModeDuration(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddInteractiveModeDuration(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	stdout := new(bytes.Buffer)
-	cmd := logCmd
+	cmd := logAddCmd
 	cmd.SetOut(stdout)
 
 	pk := PromptKit{
@@ -360,7 +361,7 @@ func TestLogInteractiveModeDuration(t *testing.T) {
 		},
 	}
 
-	err := runLog(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
+	err := runLogAdd(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout.String(), "logged")
@@ -372,11 +373,11 @@ func TestLogInteractiveModeDuration(t *testing.T) {
 	assert.Equal(t, 120, entries[0].Minutes)
 }
 
-func TestLogInteractiveModeFromTo(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddInteractiveModeFromTo(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	stdout := new(bytes.Buffer)
-	cmd := logCmd
+	cmd := logAddCmd
 	cmd.SetOut(stdout)
 
 	pk := PromptKit{
@@ -395,7 +396,7 @@ func TestLogInteractiveModeFromTo(t *testing.T) {
 		},
 	}
 
-	err := runLog(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
+	err := runLogAdd(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
 
 	require.NoError(t, err)
 
@@ -405,11 +406,11 @@ func TestLogInteractiveModeFromTo(t *testing.T) {
 	assert.Equal(t, 180, entries[0].Minutes)
 }
 
-func TestLogInteractiveEmptyMessage(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddInteractiveEmptyMessage(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
 	stdout := new(bytes.Buffer)
-	cmd := logCmd
+	cmd := logAddCmd
 	cmd.SetOut(stdout)
 
 	pk := PromptKit{
@@ -426,16 +427,16 @@ func TestLogInteractiveEmptyMessage(t *testing.T) {
 		},
 	}
 
-	err := runLog(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
+	err := runLogAdd(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "message is required")
 }
 
-func TestLogDurationModeWithDate(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDurationModeWithDate(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
-	stdout, err := execLog(homeDir, repoDir, "", "3h", "", "", "2025-01-10", "", "past work")
+	stdout, err := execLogAdd(homeDir, repoDir, "", "3h", "", "", "2025-01-10", "", "past work")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "logged")
@@ -452,8 +453,8 @@ func TestLogDurationModeWithDate(t *testing.T) {
 	assert.Equal(t, 9, entries[0].Start.Hour())
 }
 
-func TestLogDurationModeUnscheduledDayFallback(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDurationModeUnscheduledDayFallback(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// 2025-01-11 is a Saturday — no schedule, so findDurationSlot fails
 	// and falls back to 9:00 default; the schedule warning system will warn the user
@@ -465,7 +466,7 @@ func TestLogDurationModeUnscheduledDayFallback(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "3h", "", "", "2025-01-11", "", "weekend work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "3h", "", "", "2025-01-11", "", "weekend work", pk)
 
 	require.NoError(t, err)
 	assert.True(t, confirmed, "should have warned about unscheduled day")
@@ -482,8 +483,8 @@ func TestLogDurationModeUnscheduledDayFallback(t *testing.T) {
 	assert.Equal(t, 9, entries[0].Start.Hour())
 }
 
-func TestLogDurationModeNoSlotAvailable(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddDurationModeNoSlotAvailable(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// Fill up Monday (2025-06-16, 9am-5pm = 8h) with an existing 8h entry
 	e := entry.Entry{
@@ -504,7 +505,7 @@ func TestLogDurationModeNoSlotAvailable(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "1h", "", "", "2025-06-16", "", "extra work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "1h", "", "", "2025-06-16", "", "extra work", pk)
 
 	require.NoError(t, err)
 	assert.True(t, confirmed, "should have warned about budget overrun")
@@ -515,10 +516,10 @@ func TestLogDurationModeNoSlotAvailable(t *testing.T) {
 	assert.Len(t, entries, 2)
 }
 
-func TestLogFromToModeWithDate(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddFromToModeWithDate(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
-	stdout, err := execLog(homeDir, repoDir, "", "", "9am", "12pm", "2025-01-10", "", "past morning")
+	stdout, err := execLogAdd(homeDir, repoDir, "", "", "9am", "12pm", "2025-01-10", "", "past morning")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "logged")
@@ -533,20 +534,20 @@ func TestLogFromToModeWithDate(t *testing.T) {
 	assert.Equal(t, 9, entries[0].Start.Hour())
 }
 
-func TestLogInvalidDate(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddInvalidDate(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
-	_, err := execLog(homeDir, repoDir, "", "1h", "", "", "not-a-date", "", "work")
+	_, err := execLogAdd(homeDir, repoDir, "", "1h", "", "", "not-a-date", "", "work")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "invalid --date format")
 }
 
-func TestLogInteractiveModeWithDate(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddInteractiveModeWithDate(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	stdout := new(bytes.Buffer)
-	cmd := logCmd
+	cmd := logAddCmd
 	cmd.SetOut(stdout)
 
 	pk := PromptKit{
@@ -565,7 +566,7 @@ func TestLogInteractiveModeWithDate(t *testing.T) {
 		},
 	}
 
-	err := runLog(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
+	err := runLogAdd(cmd, homeDir, repoDir, "", "", "", "", "", "", "", pk, fixedNow)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout.String(), "logged")
@@ -578,26 +579,40 @@ func TestLogInteractiveModeWithDate(t *testing.T) {
 	assert.Equal(t, 1, entries[0].Start.Day())
 }
 
-func TestLogRegisteredAsSubcommand(t *testing.T) {
+func TestLogAddRegisteredAsSubcommand(t *testing.T) {
 	root := newRootCmd()
-	names := make([]string, len(root.Commands()))
-	for i, cmd := range root.Commands() {
+	logGroup := findSubcommand(root, "log")
+	require.NotNil(t, logGroup, "log group command should exist")
+
+	names := make([]string, len(logGroup.Commands()))
+	for i, cmd := range logGroup.Commands() {
 		names[i] = cmd.Name()
 	}
-	assert.Contains(t, names, "log")
+	assert.Contains(t, names, "add")
+	assert.Contains(t, names, "edit")
+	assert.Contains(t, names, "remove")
+}
+
+func findSubcommand(parent *cobra.Command, name string) *cobra.Command {
+	for _, cmd := range parent.Commands() {
+		if cmd.Name() == name {
+			return cmd
+		}
+	}
+	return nil
 }
 
-func TestLogExceeds24Hours(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddExceeds24Hours(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
-	_, err := execLog(homeDir, repoDir, "", "25h", "", "", "", "", "too much")
+	_, err := execLogAdd(homeDir, repoDir, "", "25h", "", "", "", "", "too much")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "cannot log more than 24h in a single entry")
 }
 
-func TestLogScheduleOverrunWarning(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddScheduleOverrunWarning(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// fixedNow is 2025-06-15 (Sunday), use 2025-06-16 (Monday) for schedule to apply
 	// Default schedule: Mon-Fri 9am-5pm = 8h
@@ -618,7 +633,7 @@ func TestLogScheduleOverrunWarning(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "6h", "", "", "2025-06-16", "", "overrun work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "6h", "", "", "2025-06-16", "", "overrun work", pk)
 
 	require.NoError(t, err)
 	assert.True(t, confirmed, "should have prompted for confirmation")
@@ -630,8 +645,8 @@ func TestLogScheduleOverrunWarning(t *testing.T) {
 	assert.Len(t, entries, 2)
 }
 
-func TestLogScheduleOverrunDeclined(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddScheduleOverrunDeclined(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// Pre-log 4h on Monday
 	e := entry.Entry{
@@ -648,7 +663,7 @@ func TestLogScheduleOverrunDeclined(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "6h", "", "", "2025-06-16", "", "overrun work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "6h", "", "", "2025-06-16", "", "overrun work", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "Warning:")
@@ -659,8 +674,8 @@ func TestLogScheduleOverrunDeclined(t *testing.T) {
 	assert.Len(t, entries, 1) // only the pre-logged entry
 }
 
-func TestLogScheduleOverrunNoSchedule(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddScheduleOverrunNoSchedule(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
 	// 2025-06-15 is a Sunday — no schedule → 0h scheduled
 	confirmed := false
@@ -671,7 +686,7 @@ func TestLogScheduleOverrunNoSchedule(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "1h", "", "", "2025-06-15", "", "weekend work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "1h", "", "", "2025-06-15", "", "weekend work", pk)
 
 	require.NoError(t, err)
 	assert.True(t, confirmed, "should have prompted for confirmation on unscheduled day")
@@ -680,8 +695,8 @@ func TestLogScheduleOverrunNoSchedule(t *testing.T) {
 	assert.Contains(t, stdout, "logged")
 }
 
-func TestLogScheduleOverrunWithinBudget(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddScheduleOverrunWithinBudget(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// Monday with 8h schedule, log only 2h — no warning
 	confirmed := false
@@ -692,7 +707,7 @@ func TestLogScheduleOverrunWithinBudget(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "2h", "", "", "2025-06-16", "", "normal work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "2h", "", "", "2025-06-16", "", "normal work", pk)
 
 	require.NoError(t, err)
 	assert.False(t, confirmed, "should not have prompted for confirmation within budget")
@@ -703,8 +718,8 @@ func TestLogScheduleOverrunWithinBudget(t *testing.T) {
 	assert.Len(t, entries, 1)
 }
 
-func TestLogOutsideScheduleWindows(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddOutsideScheduleWindows(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// Monday 7pm-9pm, schedule is 9am-5pm → fully outside
 	confirmed := false
@@ -715,7 +730,7 @@ func TestLogOutsideScheduleWindows(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "7pm", "9pm", "2025-06-16", "", "evening work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "7pm", "9pm", "2025-06-16", "", "evening work", pk)
 
 	require.NoError(t, err)
 	assert.True(t, confirmed, "should have prompted for confirmation")
@@ -728,8 +743,8 @@ func TestLogOutsideScheduleWindows(t *testing.T) {
 	assert.Len(t, entries, 1)
 }
 
-func TestLogOutsideScheduleWindowsDeclined(t *testing.T) {
-	homeDir, repoDir, _ := setupLogTest(t)
+func TestLogAddOutsideScheduleWindowsDeclined(t *testing.T) {
+	homeDir, repoDir, _ := setupLogAddTest(t)
 
 	// Monday 7pm-9pm, schedule is 9am-5pm → fully outside, declined
 	pk := PromptKit{
@@ -738,15 +753,15 @@ func TestLogOutsideScheduleWindowsDeclined(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "7pm", "9pm", "2025-06-16", "", "evening work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "7pm", "9pm", "2025-06-16", "", "evening work", pk)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "Warning:")
 	assert.NotContains(t, stdout, "logged")
 }
 
-func TestLogPartiallyOutsideScheduleWindows(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddPartiallyOutsideScheduleWindows(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// Monday 4pm-7pm, schedule is 9am-5pm → partially outside
 	confirmed := false
@@ -757,7 +772,7 @@ func TestLogPartiallyOutsideScheduleWindows(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "4pm", "7pm", "2025-06-16", "", "late work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "4pm", "7pm", "2025-06-16", "", "late work", pk)
 
 	require.NoError(t, err)
 	assert.True(t, confirmed, "should have prompted for confirmation")
@@ -770,8 +785,8 @@ func TestLogPartiallyOutsideScheduleWindows(t *testing.T) {
 	assert.Len(t, entries, 1)
 }
 
-func TestLogWithinScheduleWindows(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddWithinScheduleWindows(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
 	// Monday 10am-12pm, schedule is 9am-5pm → fully within
 	confirmed := false
@@ -782,7 +797,7 @@ func TestLogWithinScheduleWindows(t *testing.T) {
 		},
 	}
 
-	stdout, err := execLogWithPrompts(homeDir, repoDir, "", "", "10am", "12pm", "2025-06-16", "", "morning work", pk)
+	stdout, err := execLogAddWithPrompts(homeDir, repoDir, "", "", "10am", "12pm", "2025-06-16", "", "morning work", pk)
 
 	require.NoError(t, err)
 	assert.False(t, confirmed, "should not have prompted for confirmation within schedule")
@@ -794,10 +809,10 @@ func TestLogWithinScheduleWindows(t *testing.T) {
 	assert.Len(t, entries, 1)
 }
 
-func TestLogWithTask(t *testing.T) {
-	homeDir, repoDir, proj := setupLogTest(t)
+func TestLogAddWithTask(t *testing.T) {
+	homeDir, repoDir, proj := setupLogAddTest(t)
 
-	stdout, err := execLog(homeDir, repoDir, "", "2h", "", "", "", "research", "read documentation")
+	stdout, err := execLogAdd(homeDir, repoDir, "", "2h", "", "", "", "research", "read documentation")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "logged")
diff --git a/internal/cli/edit.go b/internal/cli/log_edit.go
similarity index 99%
rename from internal/cli/edit.go
rename to internal/cli/log_edit.go
index c7b1c6c..142da4a 100644
--- a/internal/cli/edit.go
+++ b/internal/cli/log_edit.go
@@ -10,7 +10,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var editCmd = LeafCommand{
+var logEditCmd = LeafCommand{
 	Use:   "edit <hash>",
 	Short: "Edit an existing log entry",
 	Args:  cobra.ExactArgs(1),
@@ -57,13 +57,13 @@ var editCmd = LeafCommand{
 		} else {
 			confirm = pk.Confirm
 		}
-		return runEdit(cmd, homeDir, repoDir, projectFlag, args[0],
+		return runLogEdit(cmd, homeDir, repoDir, projectFlag, args[0],
 			durationFlag, fromFlag, toFlag, dateFlag, taskFlag, messageFlag,
 			flagsChanged, pk, confirm, time.Now)
 	},
 }.Build()
 
-func runEdit(
+func runLogEdit(
 	cmd *cobra.Command,
 	homeDir, repoDir, projectFlag, hash string,
 	durationFlag, fromFlag, toFlag, dateFlag, taskFlag, messageFlag string,
diff --git a/internal/cli/edit_test.go b/internal/cli/log_edit_test.go
similarity index 66%
rename from internal/cli/edit_test.go
rename to internal/cli/log_edit_test.go
index b0e4dec..53c1c32 100644
--- a/internal/cli/edit_test.go
+++ b/internal/cli/log_edit_test.go
@@ -13,7 +13,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func setupEditTest(t *testing.T) (homeDir string, repoDir string, proj *project.ProjectEntry, e entry.Entry) {
+func setupLogEditTest(t *testing.T) (homeDir string, repoDir string, proj *project.ProjectEntry, e entry.Entry) {
 	t.Helper()
 	homeDir = t.TempDir()
 	repoDir = t.TempDir()
@@ -41,36 +41,36 @@ func setupEditTest(t *testing.T) (homeDir string, repoDir string, proj *project.
 	return homeDir, repoDir, p, e
 }
 
-func execEdit(homeDir, repoDir, projectFlag, hash string, flags map[string]bool,
+func execLogEdit(homeDir, repoDir, projectFlag, hash string, flags map[string]bool,
 	durationFlag, fromFlag, toFlag, dateFlag, taskFlag, messageFlag string,
 ) (string, error) {
-	return execEditWithConfirm(homeDir, repoDir, projectFlag, hash, flags,
+	return execLogEditWithConfirm(homeDir, repoDir, projectFlag, hash, flags,
 		durationFlag, fromFlag, toFlag, dateFlag, taskFlag, messageFlag, nil)
 }
 
-func execEditWithConfirm(homeDir, repoDir, projectFlag, hash string, flags map[string]bool,
+func execLogEditWithConfirm(homeDir, repoDir, projectFlag, hash string, flags map[string]bool,
 	durationFlag, fromFlag, toFlag, dateFlag, taskFlag, messageFlag string,
 	confirm ConfirmFunc,
 ) (string, error) {
 	stdout := new(bytes.Buffer)
-	cmd := editCmd
+	cmd := logEditCmd
 	cmd.SetOut(stdout)
 
 	if flags == nil {
 		flags = map[string]bool{}
 	}
 
-	err := runEdit(cmd, homeDir, repoDir, projectFlag, hash,
+	err := runLogEdit(cmd, homeDir, repoDir, projectFlag, hash,
 		durationFlag, fromFlag, toFlag, dateFlag, taskFlag, messageFlag,
 		flags, PromptKit{}, confirm, fixedNow)
 	return stdout.String(), err
 }
 
-func TestEditDurationOnly(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditDurationOnly(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"duration": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "", "", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "", "", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "duration:")
@@ -88,11 +88,11 @@ func TestEditDurationOnly(t *testing.T) {
 	assert.Equal(t, "coding", e.Task)
 }
 
-func TestEditFromToMode(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditFromToMode(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"from": true, "to": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "10am", "1pm", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "10am", "1pm", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -103,12 +103,12 @@ func TestEditFromToMode(t *testing.T) {
 	assert.Equal(t, 180, e.Minutes)
 }
 
-func TestEditFromOnly(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditFromOnly(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// Original: 9:00 - 12:00 (180 min). Change from to 10:00, keep duration (3h) → to shifts to 13:00.
 	flags := map[string]bool{"from": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "10am", "", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "10am", "", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -119,12 +119,12 @@ func TestEditFromOnly(t *testing.T) {
 	assert.Equal(t, 180, e.Minutes) // duration preserved: 3h
 }
 
-func TestEditToOnly(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditToOnly(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// Original: 9:00 - 12:00 (180 min). Change end to 2pm, keep start at 9:00.
 	flags := map[string]bool{"to": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "2pm", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "2pm", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -135,11 +135,11 @@ func TestEditToOnly(t *testing.T) {
 	assert.Equal(t, 300, e.Minutes) // 9:00 - 14:00 = 5h
 }
 
-func TestEditDateOnly(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditDateOnly(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"date": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "2025-07-01", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "2025-07-01", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -156,11 +156,11 @@ func TestEditDateOnly(t *testing.T) {
 	assert.Equal(t, 180, e.Minutes)
 }
 
-func TestEditTask(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditTask(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"task": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "reviews", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "reviews", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "task:")
@@ -171,11 +171,11 @@ func TestEditTask(t *testing.T) {
 	assert.Equal(t, "reviews", e.Task)
 }
 
-func TestEditClearTask(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditClearTask(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"task": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "task:")
@@ -186,11 +186,11 @@ func TestEditClearTask(t *testing.T) {
 	assert.Equal(t, "", e.Task)
 }
 
-func TestEditMessage(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditMessage(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"message": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "", "updated work")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "", "updated work")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "message:")
@@ -201,22 +201,22 @@ func TestEditMessage(t *testing.T) {
 	assert.Equal(t, "updated work", e.Message)
 }
 
-func TestEditEmptyMessageError(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditEmptyMessageError(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"message": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "message is required")
 }
 
-func TestEditDurationAndFrom(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditDurationAndFrom(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// Original: 9:00-12:00 (180 min). --duration 2h --from 10am → 10:00-12:00
 	flags := map[string]bool{"duration": true, "from": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "10am", "", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "10am", "", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -227,12 +227,12 @@ func TestEditDurationAndFrom(t *testing.T) {
 	assert.Equal(t, 120, e.Minutes)
 }
 
-func TestEditDurationAndTo(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditDurationAndTo(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// Original: 9:00-12:00 (180 min). --duration 2h --to 2pm → from = 12:00, 2h
 	flags := map[string]bool{"duration": true, "to": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "", "2pm", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "", "2pm", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -243,12 +243,12 @@ func TestEditDurationAndTo(t *testing.T) {
 	assert.Equal(t, 120, e.Minutes)
 }
 
-func TestEditAllThreeConsistent(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditAllThreeConsistent(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// --from 10am --to 12pm --duration 2h → consistent, should succeed
 	flags := map[string]bool{"duration": true, "from": true, "to": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "10am", "12pm", "", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "2h", "10am", "12pm", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -259,85 +259,85 @@ func TestEditAllThreeConsistent(t *testing.T) {
 	assert.Equal(t, 120, e.Minutes)
 }
 
-func TestEditAllThreeInconsistent(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditAllThreeInconsistent(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// --from 10am --to 12pm --duration 3h → inconsistent (2h ≠ 3h)
 	flags := map[string]bool{"duration": true, "from": true, "to": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "3h", "10am", "12pm", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "3h", "10am", "12pm", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "does not match")
 }
 
-func TestEditToBeforeStart(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditToBeforeStart(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// Original: 9:00-12:00. Set --to to 8am → error (before 9:00 start)
 	flags := map[string]bool{"to": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "8am", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "8am", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "must be after")
 }
 
-func TestEditInvalidFromFlag(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditInvalidFromFlag(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"from": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "invalid", "", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "invalid", "", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "invalid --from time")
 }
 
-func TestEditInvalidToFlag(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditInvalidToFlag(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"to": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "invalid", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "invalid", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "invalid --to time")
 }
 
-func TestEditExceeds24Hours(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditExceeds24Hours(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"duration": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "25h", "", "", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "25h", "", "", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "cannot log more than 24h")
 }
 
-func TestEditNotFound(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditNotFound(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"duration": true}
-	_, err := execEdit(homeDir, repoDir, "", "nonexistent", flags, "2h", "", "", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "nonexistent", flags, "2h", "", "", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "not found")
 }
 
-func TestEditNoChanges(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditNoChanges(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// Set task to same value
 	flags := map[string]bool{"task": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "coding", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "", "", "", "coding", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "no changes")
 	assert.NotContains(t, stdout, "updated entry")
 }
 
-func TestEditPreservesIDAndCreatedAt(t *testing.T) {
-	homeDir, repoDir, proj, original := setupEditTest(t)
+func TestLogEditPreservesIDAndCreatedAt(t *testing.T) {
+	homeDir, repoDir, proj, original := setupLogEditTest(t)
 
 	flags := map[string]bool{"duration": true}
-	_, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "5h", "", "", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "5h", "", "", "", "", "")
 
 	require.NoError(t, err)
 
@@ -347,11 +347,11 @@ func TestEditPreservesIDAndCreatedAt(t *testing.T) {
 	assert.True(t, original.CreatedAt.Equal(e.CreatedAt))
 }
 
-func TestEditByProjectFlag(t *testing.T) {
-	homeDir, _, proj, _ := setupEditTest(t)
+func TestLogEditByProjectFlag(t *testing.T) {
+	homeDir, _, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"duration": true}
-	stdout, err := execEdit(homeDir, "", proj.Name, "ed01234", flags, "1h", "", "", "", "", "")
+	stdout, err := execLogEdit(homeDir, "", proj.Name, "ed01234", flags, "1h", "", "", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -361,7 +361,7 @@ func TestEditByProjectFlag(t *testing.T) {
 	assert.Equal(t, 60, e.Minutes)
 }
 
-func TestEditCrossProjectScan(t *testing.T) {
+func TestLogEditCrossProjectScan(t *testing.T) {
 	homeDir := t.TempDir()
 
 	// Create a project without repo assignment
@@ -383,7 +383,7 @@ func TestEditCrossProjectScan(t *testing.T) {
 
 	// No repo, no project flag — should scan and find it
 	flags := map[string]bool{"duration": true}
-	stdout, err := execEdit(homeDir, "", "", "5c01234", flags, "2h", "", "", "", "", "")
+	stdout, err := execLogEdit(homeDir, "", "", "5c01234", flags, "2h", "", "", "", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -393,11 +393,11 @@ func TestEditCrossProjectScan(t *testing.T) {
 	assert.Equal(t, 120, updated.Minutes)
 }
 
-func TestEditInteractiveMode(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditInteractiveMode(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	stdout := new(bytes.Buffer)
-	cmd := editCmd
+	cmd := logEditCmd
 	cmd.SetOut(stdout)
 
 	pk := PromptKit{
@@ -419,7 +419,7 @@ func TestEditInteractiveMode(t *testing.T) {
 	}
 
 	flags := map[string]bool{} // no flags = interactive mode
-	err := runEdit(cmd, homeDir, repoDir, "", "ed01234",
+	err := runLogEdit(cmd, homeDir, repoDir, "", "ed01234",
 		"", "", "", "", "", "",
 		flags, pk, nil, fixedNow)
 
@@ -432,20 +432,11 @@ func TestEditInteractiveMode(t *testing.T) {
 	assert.Equal(t, 120, e.Minutes) // from 10:00, duration 2h
 }
 
-func TestEditRegisteredAsSubcommand(t *testing.T) {
-	root := newRootCmd()
-	names := make([]string, len(root.Commands()))
-	for i, cmd := range root.Commands() {
-		names[i] = cmd.Name()
-	}
-	assert.Contains(t, names, "edit")
-}
-
-func TestEditDateAndFrom(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditDateAndFrom(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	flags := map[string]bool{"date": true, "from": true}
-	stdout, err := execEdit(homeDir, repoDir, "", "ed01234", flags, "", "10am", "", "2025-08-01", "", "")
+	stdout, err := execLogEdit(homeDir, repoDir, "", "ed01234", flags, "", "10am", "", "2025-08-01", "", "")
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
@@ -460,8 +451,8 @@ func TestEditDateAndFrom(t *testing.T) {
 	assert.Equal(t, 180, e.Minutes)
 }
 
-func TestEditScheduleWarningOutsideHours(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditScheduleWarningOutsideHours(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// Original entry: 2025-06-16 (Monday) 9:00–12:00, within default 9–17 schedule.
 	// Move it to 22:00–01:00 — completely outside schedule.
@@ -472,7 +463,7 @@ func TestEditScheduleWarningOutsideHours(t *testing.T) {
 	}
 
 	flags := map[string]bool{"from": true, "to": true}
-	stdout, err := execEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
+	stdout, err := execLogEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
 		"", "22:00", "23:00", "", "", "", confirm)
 
 	require.NoError(t, err)
@@ -481,8 +472,8 @@ func TestEditScheduleWarningOutsideHours(t *testing.T) {
 	assert.Contains(t, stdout, "updated entry")
 }
 
-func TestEditScheduleWarningDeclined(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditScheduleWarningDeclined(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// Move to outside schedule, but decline the warning
 	confirm := func(prompt string) (bool, error) {
@@ -490,15 +481,15 @@ func TestEditScheduleWarningDeclined(t *testing.T) {
 	}
 
 	flags := map[string]bool{"from": true, "to": true}
-	stdout, err := execEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
+	stdout, err := execLogEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
 		"", "22:00", "23:00", "", "", "", confirm)
 
 	require.NoError(t, err)
 	assert.NotContains(t, stdout, "updated entry")
 }
 
-func TestEditMessageOnlyNoWarning(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditMessageOnlyNoWarning(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// Only change message — no schedule warning should trigger
 	confirmed := false
@@ -508,7 +499,7 @@ func TestEditMessageOnlyNoWarning(t *testing.T) {
 	}
 
 	flags := map[string]bool{"message": true}
-	stdout, err := execEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
+	stdout, err := execLogEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
 		"", "", "", "", "", "new message", confirm)
 
 	require.NoError(t, err)
@@ -516,20 +507,20 @@ func TestEditMessageOnlyNoWarning(t *testing.T) {
 	assert.Contains(t, stdout, "updated entry")
 }
 
-func TestEditYesFlagSkipsWarning(t *testing.T) {
-	homeDir, repoDir, _, _ := setupEditTest(t)
+func TestLogEditYesFlagSkipsWarning(t *testing.T) {
+	homeDir, repoDir, _, _ := setupLogEditTest(t)
 
 	// Move to outside schedule with --yes (AlwaysYes)
 	flags := map[string]bool{"from": true, "to": true}
-	stdout, err := execEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
+	stdout, err := execLogEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
 		"", "22:00", "23:00", "", "", "", AlwaysYes())
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "updated entry")
 }
 
-func TestEditBudgetExcludesCurrentEntry(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditBudgetExcludesCurrentEntry(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// Original entry: edt1234, 9:00–12:00 (180 min) on Monday.
 	// Add another 5h entry to fill up most of the 8h budget.
@@ -551,7 +542,7 @@ func TestEditBudgetExcludesCurrentEntry(t *testing.T) {
 	}
 
 	flags := map[string]bool{"duration": true}
-	stdout, err := execEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
+	stdout, err := execLogEditWithConfirm(homeDir, repoDir, "", "ed01234", flags,
 		"2h", "", "", "", "", "", confirm)
 
 	require.NoError(t, err)
@@ -559,8 +550,8 @@ func TestEditBudgetExcludesCurrentEntry(t *testing.T) {
 	assert.Contains(t, stdout, "updated entry")
 }
 
-func TestEditCheckoutEntryRejected(t *testing.T) {
-	homeDir, repoDir, proj, _ := setupEditTest(t)
+func TestLogEditCheckoutEntryRejected(t *testing.T) {
+	homeDir, repoDir, proj, _ := setupLogEditTest(t)
 
 	// Write a checkout entry
 	ce := entry.CheckoutEntry{
@@ -573,7 +564,7 @@ func TestEditCheckoutEntryRejected(t *testing.T) {
 	require.NoError(t, entry.WriteCheckoutEntry(homeDir, proj.Slug, ce))
 
 	flags := map[string]bool{"duration": true}
-	_, err := execEdit(homeDir, repoDir, "", "c009999", flags, "2h", "", "", "", "", "")
+	_, err := execLogEdit(homeDir, repoDir, "", "c009999", flags, "2h", "", "", "", "", "")
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "cannot be edited")
diff --git a/internal/cli/remove.go b/internal/cli/log_remove.go
similarity index 93%
rename from internal/cli/remove.go
rename to internal/cli/log_remove.go
index d03421b..2d19fca 100644
--- a/internal/cli/remove.go
+++ b/internal/cli/log_remove.go
@@ -8,7 +8,7 @@ import (
 	"github.com/spf13/cobra"
 )
 
-var removeCmd = LeafCommand{
+var logRemoveCmd = LeafCommand{
 	Use:   "remove <hash>",
 	Short: "Remove a log or checkout entry",
 	Args:  cobra.ExactArgs(1),
@@ -34,11 +34,11 @@ var removeCmd = LeafCommand{
 			confirm = NewConfirmFunc()
 		}
 
-		return runRemove(cmd, homeDir, repoDir, projectFlag, args[0], confirm)
+		return runLogRemove(cmd, homeDir, repoDir, projectFlag, args[0], confirm)
 	},
 }.Build()
 
-func runRemove(cmd *cobra.Command, homeDir, repoDir, projectFlag, hash string, confirm ConfirmFunc) error {
+func runLogRemove(cmd *cobra.Command, homeDir, repoDir, projectFlag, hash string, confirm ConfirmFunc) error {
 	slug, entryType, detail, err := locateAnyEntry(homeDir, repoDir, projectFlag, hash)
 	if err != nil {
 		return err
diff --git a/internal/cli/remove_test.go b/internal/cli/log_remove_test.go
similarity index 63%
rename from internal/cli/remove_test.go
rename to internal/cli/log_remove_test.go
index 1c7adc4..8e2b8ce 100644
--- a/internal/cli/remove_test.go
+++ b/internal/cli/log_remove_test.go
@@ -13,7 +13,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func setupRemoveTest(t *testing.T) (homeDir string, repoDir string, proj *project.ProjectEntry, logEntry entry.Entry, checkoutEntry entry.CheckoutEntry) {
+func setupLogRemoveTest(t *testing.T) (homeDir string, repoDir string, proj *project.ProjectEntry, logEntry entry.Entry, checkoutEntry entry.CheckoutEntry) {
 	t.Helper()
 	homeDir = t.TempDir()
 	repoDir = t.TempDir()
@@ -50,19 +50,19 @@ func setupRemoveTest(t *testing.T) (homeDir string, repoDir string, proj *projec
 	return homeDir, repoDir, p, le, ce
 }
 
-func execRemove(homeDir, repoDir, projectFlag, hash string, confirm ConfirmFunc) (string, error) {
+func execLogRemove(homeDir, repoDir, projectFlag, hash string, confirm ConfirmFunc) (string, error) {
 	stdout := new(bytes.Buffer)
-	cmd := removeCmd
+	cmd := logRemoveCmd
 	cmd.SetOut(stdout)
 
-	err := runRemove(cmd, homeDir, repoDir, projectFlag, hash, confirm)
+	err := runLogRemove(cmd, homeDir, repoDir, projectFlag, hash, confirm)
 	return stdout.String(), err
 }
 
-func TestRemoveLogEntry(t *testing.T) {
-	homeDir, repoDir, proj, _, _ := setupRemoveTest(t)
+func TestLogRemoveLogEntry(t *testing.T) {
+	homeDir, repoDir, proj, _, _ := setupLogRemoveTest(t)
 
-	stdout, err := execRemove(homeDir, repoDir, "", "0010012", AlwaysYes())
+	stdout, err := execLogRemove(homeDir, repoDir, "", "0010012", AlwaysYes())
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "log")
@@ -72,10 +72,10 @@ func TestRemoveLogEntry(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestRemoveCheckoutEntry(t *testing.T) {
-	homeDir, repoDir, proj, _, _ := setupRemoveTest(t)
+func TestLogRemoveCheckoutEntry(t *testing.T) {
+	homeDir, repoDir, proj, _, _ := setupLogRemoveTest(t)
 
-	stdout, err := execRemove(homeDir, repoDir, "", "00c0012", AlwaysYes())
+	stdout, err := execLogRemove(homeDir, repoDir, "", "00c0012", AlwaysYes())
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "checkout")
@@ -85,23 +85,23 @@ func TestRemoveCheckoutEntry(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestRemoveNotFound(t *testing.T) {
-	homeDir, repoDir, _, _, _ := setupRemoveTest(t)
+func TestLogRemoveNotFound(t *testing.T) {
+	homeDir, repoDir, _, _, _ := setupLogRemoveTest(t)
 
-	_, err := execRemove(homeDir, repoDir, "", "nonexist", AlwaysYes())
+	_, err := execLogRemove(homeDir, repoDir, "", "nonexist", AlwaysYes())
 
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "not found")
 }
 
-func TestRemoveConfirmDeclined(t *testing.T) {
-	homeDir, repoDir, proj, _, _ := setupRemoveTest(t)
+func TestLogRemoveConfirmDeclined(t *testing.T) {
+	homeDir, repoDir, proj, _, _ := setupLogRemoveTest(t)
 
 	confirm := func(_ string) (bool, error) {
 		return false, nil
 	}
 
-	stdout, err := execRemove(homeDir, repoDir, "", "0010012", confirm)
+	stdout, err := execLogRemove(homeDir, repoDir, "", "0010012", confirm)
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "cancelled")
@@ -112,19 +112,19 @@ func TestRemoveConfirmDeclined(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-func TestRemoveYesSkipsConfirmation(t *testing.T) {
-	homeDir, repoDir, _, _, _ := setupRemoveTest(t)
+func TestLogRemoveYesSkipsConfirmation(t *testing.T) {
+	homeDir, repoDir, _, _, _ := setupLogRemoveTest(t)
 
-	stdout, err := execRemove(homeDir, repoDir, "", "0010012", AlwaysYes())
+	stdout, err := execLogRemove(homeDir, repoDir, "", "0010012", AlwaysYes())
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "removed entry")
 }
 
-func TestRemoveWithProjectFlag(t *testing.T) {
-	homeDir, _, proj, _, _ := setupRemoveTest(t)
+func TestLogRemoveWithProjectFlag(t *testing.T) {
+	homeDir, _, proj, _, _ := setupLogRemoveTest(t)
 
-	stdout, err := execRemove(homeDir, "", proj.Name, "0010012", AlwaysYes())
+	stdout, err := execLogRemove(homeDir, "", proj.Name, "0010012", AlwaysYes())
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "removed entry")
@@ -133,7 +133,7 @@ func TestRemoveWithProjectFlag(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestRemoveCrossProjectScan(t *testing.T) {
+func TestLogRemoveCrossProjectScan(t *testing.T) {
 	homeDir := t.TempDir()
 
 	p, err := project.CreateProject(homeDir, "Scannable Remove")
@@ -153,7 +153,7 @@ func TestRemoveCrossProjectScan(t *testing.T) {
 	require.NoError(t, entry.WriteEntry(homeDir, p.Slug, e))
 
 	// No repo, no project flag — should scan and find it
-	stdout, err := execRemove(homeDir, "", "", "5c00012", AlwaysYes())
+	stdout, err := execLogRemove(homeDir, "", "", "5c00012", AlwaysYes())
 
 	require.NoError(t, err)
 	assert.Contains(t, stdout, "removed entry")
@@ -162,10 +162,13 @@ func TestRemoveCrossProjectScan(t *testing.T) {
 	assert.Error(t, err)
 }
 
-func TestRemoveRegisteredAsSubcommand(t *testing.T) {
+func TestLogRemoveRegisteredAsSubcommand(t *testing.T) {
 	root := newRootCmd()
-	names := make([]string, len(root.Commands()))
-	for i, cmd := range root.Commands() {
+	logGroup := findSubcommand(root, "log")
+	require.NotNil(t, logGroup, "log group command should exist")
+
+	names := make([]string, len(logGroup.Commands()))
+	for i, cmd := range logGroup.Commands() {
 		names[i] = cmd.Name()
 	}
 	assert.Contains(t, names, "remove")
diff --git a/internal/cli/root.go b/internal/cli/root.go
index a9ed2a1..a355921 100644
--- a/internal/cli/root.go
+++ b/internal/cli/root.go
@@ -15,8 +15,6 @@ func newRootCmd() *cobra.Command {
 		Subcommands: []*cobra.Command{
 			initCmd,
 			logCmd,
-			editCmd,
-			removeCmd,
 			syncCmd,
 			reportCmd,
 			historyCmd,
diff --git a/web/docs/commands/time-tracking.md b/web/docs/commands/time-tracking.md
index ecf4140..8333acf 100644
--- a/web/docs/commands/time-tracking.md
+++ b/web/docs/commands/time-tracking.md
@@ -18,12 +18,12 @@ hourgit init [--project <name>] [--mode <mode>] [--force] [--append] [--yes]
 | `-a`, `--append` | `false` | Append to existing post-checkout hook |
 | `-y`, `--yes` | `false` | Skip confirmation prompt |
 
-## `hourgit log`
+## `hourgit log add`
 
 Manually log time for a project. Uses a hybrid mode: provide any combination of flags and you'll be prompted only for the missing pieces.
 
 ```bash
-hourgit log [MESSAGE] [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [--project <name>]
+hourgit log add [MESSAGE] [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [--project <name>]
 ```
 
 | Flag | Default | Description |
@@ -41,25 +41,25 @@ hourgit log [MESSAGE] [--duration <dur>] [--from <time>] [--to <time>] [--date <
 
 ```bash
 # Fully specified — no prompts
-hourgit log --duration 3h "did some work"
-hourgit log --from 9am --to 12pm "morning work"
-hourgit log --duration 3h --date 2025-01-10 "forgot to log"
+hourgit log add --duration 3h "did some work"
+hourgit log add --from 9am --to 12pm "morning work"
+hourgit log add --duration 3h --date 2025-01-10 "forgot to log"
 
 # Partial flags — prompted for the rest
-hourgit log --duration 3h          # prompted for message
-hourgit log --from 9am             # prompted for --to and message
-hourgit log "meeting notes"        # prompted for time mode and inputs
+hourgit log add --duration 3h          # prompted for message
+hourgit log add --from 9am             # prompted for --to and message
+hourgit log add "meeting notes"        # prompted for time mode and inputs
 
 # Fully interactive
-hourgit log
+hourgit log add
 ```
 
-## `hourgit edit`
+## `hourgit log edit`
 
 Edit an existing log entry by its hash. When edit flags are provided, only those changes are applied directly. Without flags, an interactive editor opens with current values pre-filled.
 
 ```bash
-hourgit edit <hash> [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [-m <msg>] [--project <name>]
+hourgit log edit <hash> [--duration <dur>] [--from <time>] [--to <time>] [--date <date>] [--task <label>] [-m <msg>] [--project <name>]
 ```
 
 | Flag | Default | Description |
@@ -78,19 +78,19 @@ hourgit edit <hash> [--duration <dur>] [--from <time>] [--to <time>] [--date <da
 **Examples:**
 
 ```bash
-hourgit edit abc1234 --duration 3h
-hourgit edit abc1234 --from 9am --to 12pm
-hourgit edit abc1234 --task "reviews"
-hourgit edit abc1234 -m "updated message"
-hourgit edit abc1234              # interactive mode
+hourgit log edit abc1234 --duration 3h
+hourgit log edit abc1234 --from 9am --to 12pm
+hourgit log edit abc1234 --task "reviews"
+hourgit log edit abc1234 -m "updated message"
+hourgit log edit abc1234              # interactive mode
 ```
 
-## `hourgit remove`
+## `hourgit log remove`
 
 Remove a log or checkout entry by its hash.
 
 ```bash
-hourgit remove <hash> [--project <name>] [--yes]
+hourgit log remove <hash> [--project <name>] [--yes]
 ```
 
 | Flag | Default | Description |

From 446c43094db7f3094f52e841f408284ea3e87fca Mon Sep 17 00:00:00 2001
From: Dawid Zbinski <dawid@zbinski.dev>
Date: Sun, 15 Mar 2026 23:10:18 +0100
Subject: [PATCH 2/2] docs: update stale `hourgit log` references to `hourgit
 log add`

The landing page and quick-start guide still used the old `hourgit log`
syntax after the command was moved under the `log` group. This aligns
them with the refactored CLI structure.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 web/docs/quick-start.md | 4 ++--
 web/index.html          | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/web/docs/quick-start.md b/web/docs/quick-start.md
index 19499b0..ee9cf00 100644
--- a/web/docs/quick-start.md
+++ b/web/docs/quick-start.md
@@ -32,8 +32,8 @@ git checkout fix/login-bug
 For meetings, reviews, research, or anything that isn't a branch switch:
 
 ```bash
-hourgit log --duration 1h30m "standup"
-hourgit log --from 9am --to 10:30am "code review"
+hourgit log add --duration 1h30m "standup"
+hourgit log add --from 9am --to 10:30am "code review"
 ```
 
 ## 4. View the interactive report
diff --git a/web/index.html b/web/index.html
index 918c12e..af56d1e 100644
--- a/web/index.html
+++ b/web/index.html
@@ -228,10 +228,10 @@ <h3>Log non-code work</h3>
                 <span class="terminal-dot"></span>
                 <span class="terminal-dot"></span>
               </div>
-              <pre><code><span class="t-prompt">$</span> hourgit log --duration 1h30m <span class="t-string">"code review"</span>
+              <pre><code><span class="t-prompt">$</span> hourgit log add --duration 1h30m <span class="t-string">"code review"</span>
 <span class="t-output">Logged <span class="t-accent">1h 30m</span> — code review</span>
 
-<span class="t-prompt">$</span> hourgit log --from 9am --to 10:30am <span class="t-string">"standup"</span>
+<span class="t-prompt">$</span> hourgit log add --from 9am --to 10:30am <span class="t-string">"standup"</span>
 <span class="t-output">Logged <span class="t-accent">1h 30m</span> — standup</span></code></pre>
             </div>
           </div>