feat(ui): replay run log in session terminal, drop per-row live tail

Set the task's log path when the run is created (not at completion) so the
session terminal can replay live output when the user navigates away and back
mid-run. Remove the now-redundant inline per-row live tail (LiveTail /
HasLiveTail / TaskMessageEvent) and scroll the terminal to end after the next
layout pass so wrapping lines aren't clipped.

src/ClaudeDo.Data/ClaudeDoDbContext.cs

@@ -3,6 +3,7 @@ using ClaudeDo.Data.Seeding;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 namespace ClaudeDo.Data;
 
@@ -19,9 +20,24 @@ public class ClaudeDoDbContext : DbContext
     public DbSet<AppSettingsEntity> AppSettings => Set<AppSettingsEntity>();
     public DbSet<PrimeScheduleEntity> PrimeSchedules => Set<PrimeScheduleEntity>();
 
+    private static readonly ValueConverter<DateTime, DateTime> UtcConverter =
+        new(v => v, v => DateTime.SpecifyKind(v, DateTimeKind.Utc));
+
+    private static readonly ValueConverter<DateTime?, DateTime?> UtcNullableConverter =
+        new(v => v, v => v.HasValue ? DateTime.SpecifyKind(v.Value, DateTimeKind.Utc) : null);
+
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         modelBuilder.ApplyConfigurationsFromAssembly(typeof(ClaudeDoDbContext).Assembly);
+
+        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
+        foreach (var property in entityType.GetProperties())
+        {
+            if (property.ClrType == typeof(DateTime) && property.GetValueConverter() == null)
+                property.SetValueConverter(UtcConverter);
+            else if (property.ClrType == typeof(DateTime?) && property.GetValueConverter() == null)
+                property.SetValueConverter(UtcNullableConverter);
+        }
     }
 
     /// <summary>

src/ClaudeDo.Data/Configuration/AppSettingsEntityConfiguration.cs

@@ -22,6 +22,9 @@ public class AppSettingsEntityConfiguration : IEntityTypeConfiguration<AppSettin
         builder.Property(s => s.DefaultPermissionMode)
             .HasColumnName("default_permission_mode").IsRequired().HasDefaultValue("bypassPermissions");
 
+        builder.Property(s => s.MaxParallelExecutions)
+            .HasColumnName("max_parallel_executions").IsRequired().HasDefaultValue(1);
+
         builder.Property(s => s.WorktreeStrategy)
             .HasColumnName("worktree_strategy").IsRequired().HasDefaultValue("sibling");
         builder.Property(s => s.CentralWorktreeRoot)

src/ClaudeDo.Data/Configuration/ListEntityConfiguration.cs

@@ -16,6 +16,9 @@ public class ListEntityConfiguration : IEntityTypeConfiguration<ListEntity>
         builder.Property(l => l.CreatedAt).HasColumnName("created_at").IsRequired();
         builder.Property(l => l.WorkingDir).HasColumnName("working_dir");
         builder.Property(l => l.DefaultCommitType).HasColumnName("default_commit_type").IsRequired().HasDefaultValue("chore");
+        builder.Property(l => l.SortOrder).HasColumnName("sort_order").IsRequired().HasDefaultValue(0);
+
+        builder.HasIndex(l => l.SortOrder).HasDatabaseName("idx_lists_sort");
 
         builder.HasOne(l => l.Config)
             .WithOne(c => c.List)

src/ClaudeDo.Data/Migrations/20260601114247_AddListSortOrder.Designer.cs

@@ -0,0 +1,600 @@
+// <auto-generated />
+using System;
+using ClaudeDo.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    [DbContext(typeof(ClaudeDoDbContext))]
+    [Migration("20260601114247_AddListSortOrder")]
+    partial class AddListSortOrder
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.AppSettingsEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CentralWorktreeRoot")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("central_worktree_root");
+
+                    b.Property<string>("DefaultClaudeInstructions")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("")
+                        .HasColumnName("default_claude_instructions");
+
+                    b.Property<int>("DefaultMaxTurns")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(30)
+                        .HasColumnName("default_max_turns");
+
+                    b.Property<string>("DefaultModel")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sonnet")
+                        .HasColumnName("default_model");
+
+                    b.Property<string>("DefaultPermissionMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("bypassPermissions")
+                        .HasColumnName("default_permission_mode");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<int>("WorktreeAutoCleanupDays")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(7)
+                        .HasColumnName("worktree_auto_cleanup_days");
+
+                    b.Property<bool>("WorktreeAutoCleanupEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("worktree_auto_cleanup_enabled");
+
+                    b.Property<string>("WorktreeStrategy")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sibling")
+                        .HasColumnName("worktree_strategy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("app_settings", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 100,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            WorktreeAutoCleanupDays = 7,
+                            WorktreeAutoCleanupEnabled = false,
+                            WorktreeStrategy = "sibling"
+                        });
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.Property<string>("ListId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.HasKey("ListId");
+
+                    b.ToTable("list_config", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DefaultCommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("default_commit_type");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("WorkingDir")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("working_dir");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
+                    b.ToTable("lists", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<bool>("Enabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("enabled");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("end_date");
+
+                    b.Property<DateTimeOffset?>("LastRunAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_run_at");
+
+                    b.Property<string>("PromptOverride")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt_override");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("start_date");
+
+                    b.Property<TimeSpan>("TimeOfDay")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_of_day");
+
+                    b.Property<bool>("WorkdaysOnly")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("workdays_only");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("prime_schedules", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("Completed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("completed");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("OrderNum")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("order_num");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_subtasks_task_id");
+
+                    b.ToTable("subtasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("BlockedByTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("blocked_by_task_id");
+
+                    b.Property<string>("CommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("commit_type");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsMyDay")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_my_day");
+
+                    b.Property<bool>("IsStarred")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_starred");
+
+                    b.Property<string>("ListId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("notes");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<DateTime?>("PlanningFinalizedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_finalized_at");
+
+                    b.Property<string>("PlanningPhase")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("none")
+                        .HasColumnName("planning_phase");
+
+                    b.Property<string>("PlanningSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_id");
+
+                    b.Property<string>("PlanningSessionToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_token");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result");
+
+                    b.Property<DateTime?>("ScheduledFor")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("scheduled_for");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("status");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("ParentTaskId")
+                        .HasDatabaseName("idx_tasks_parent_task_id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("idx_tasks_status");
+
+                    b.HasIndex("ListId", "SortOrder")
+                        .HasDatabaseName("idx_tasks_list_sort");
+
+                    b.ToTable("tasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<int?>("ExitCode")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exit_code");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsRetry")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_retry");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<int>("RunNumber")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("run_number");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_id");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("StructuredOutputJson")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("structured_output");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<int?>("TokensIn")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_in");
+
+                    b.Property<int?>("TokensOut")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_out");
+
+                    b.Property<int?>("TurnCount")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("turn_count");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_runs_task_id");
+
+                    b.ToTable("task_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("BaseCommit")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("base_commit");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("branch_name");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DiffStat")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("diff_stat");
+
+                    b.Property<string>("HeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("head_commit");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("active")
+                        .HasColumnName("state");
+
+                    b.HasKey("TaskId");
+
+                    b.ToTable("worktrees", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithOne("Config")
+                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("List");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Subtasks")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("BlockedByTaskId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithMany("Tasks")
+                        .HasForeignKey("ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentTaskId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("List");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Runs")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithOne("Worktree")
+                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Navigation("Config");
+
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Subtasks");
+
+                    b.Navigation("Worktree");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260601114247_AddListSortOrder.cs

@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddListSortOrder : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "sort_order",
+                table: "lists",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            // Backfill existing rows with a dense order (0..N-1) by creation time
+            // so today's sidebar order is preserved after the migration.
+            migrationBuilder.Sql("""
+                WITH ordered AS (
+                    SELECT id, (row_number() OVER (ORDER BY created_at) - 1) AS rn
+                    FROM lists
+                )
+                UPDATE lists SET sort_order = (SELECT rn FROM ordered WHERE ordered.id = lists.id);
+                """);
+
+            migrationBuilder.CreateIndex(
+                name: "idx_lists_sort",
+                table: "lists",
+                column: "sort_order");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "idx_lists_sort",
+                table: "lists");
+
+            migrationBuilder.DropColumn(
+                name: "sort_order",
+                table: "lists");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260601133737_AddMaxParallelExecutions.Designer.cs

@@ -0,0 +1,607 @@
+// <auto-generated />
+using System;
+using ClaudeDo.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    [DbContext(typeof(ClaudeDoDbContext))]
+    [Migration("20260601133737_AddMaxParallelExecutions")]
+    partial class AddMaxParallelExecutions
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.AppSettingsEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CentralWorktreeRoot")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("central_worktree_root");
+
+                    b.Property<string>("DefaultClaudeInstructions")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("")
+                        .HasColumnName("default_claude_instructions");
+
+                    b.Property<int>("DefaultMaxTurns")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(30)
+                        .HasColumnName("default_max_turns");
+
+                    b.Property<string>("DefaultModel")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sonnet")
+                        .HasColumnName("default_model");
+
+                    b.Property<string>("DefaultPermissionMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("bypassPermissions")
+                        .HasColumnName("default_permission_mode");
+
+                    b.Property<int>("MaxParallelExecutions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("max_parallel_executions");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<int>("WorktreeAutoCleanupDays")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(7)
+                        .HasColumnName("worktree_auto_cleanup_days");
+
+                    b.Property<bool>("WorktreeAutoCleanupEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("worktree_auto_cleanup_enabled");
+
+                    b.Property<string>("WorktreeStrategy")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sibling")
+                        .HasColumnName("worktree_strategy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("app_settings", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 100,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
+                            WorktreeAutoCleanupDays = 7,
+                            WorktreeAutoCleanupEnabled = false,
+                            WorktreeStrategy = "sibling"
+                        });
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.Property<string>("ListId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.HasKey("ListId");
+
+                    b.ToTable("list_config", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DefaultCommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("default_commit_type");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("WorkingDir")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("working_dir");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
+                    b.ToTable("lists", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<bool>("Enabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("enabled");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("end_date");
+
+                    b.Property<DateTimeOffset?>("LastRunAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_run_at");
+
+                    b.Property<string>("PromptOverride")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt_override");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("start_date");
+
+                    b.Property<TimeSpan>("TimeOfDay")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_of_day");
+
+                    b.Property<bool>("WorkdaysOnly")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("workdays_only");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("prime_schedules", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("Completed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("completed");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("OrderNum")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("order_num");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_subtasks_task_id");
+
+                    b.ToTable("subtasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("BlockedByTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("blocked_by_task_id");
+
+                    b.Property<string>("CommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("commit_type");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsMyDay")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_my_day");
+
+                    b.Property<bool>("IsStarred")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_starred");
+
+                    b.Property<string>("ListId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("notes");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<DateTime?>("PlanningFinalizedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_finalized_at");
+
+                    b.Property<string>("PlanningPhase")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("none")
+                        .HasColumnName("planning_phase");
+
+                    b.Property<string>("PlanningSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_id");
+
+                    b.Property<string>("PlanningSessionToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_token");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result");
+
+                    b.Property<DateTime?>("ScheduledFor")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("scheduled_for");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("status");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("ParentTaskId")
+                        .HasDatabaseName("idx_tasks_parent_task_id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("idx_tasks_status");
+
+                    b.HasIndex("ListId", "SortOrder")
+                        .HasDatabaseName("idx_tasks_list_sort");
+
+                    b.ToTable("tasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<int?>("ExitCode")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exit_code");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsRetry")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_retry");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<int>("RunNumber")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("run_number");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_id");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("StructuredOutputJson")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("structured_output");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<int?>("TokensIn")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_in");
+
+                    b.Property<int?>("TokensOut")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_out");
+
+                    b.Property<int?>("TurnCount")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("turn_count");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_runs_task_id");
+
+                    b.ToTable("task_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("BaseCommit")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("base_commit");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("branch_name");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DiffStat")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("diff_stat");
+
+                    b.Property<string>("HeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("head_commit");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("active")
+                        .HasColumnName("state");
+
+                    b.HasKey("TaskId");
+
+                    b.ToTable("worktrees", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithOne("Config")
+                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("List");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Subtasks")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("BlockedByTaskId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithMany("Tasks")
+                        .HasForeignKey("ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentTaskId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("List");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Runs")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithOne("Worktree")
+                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Navigation("Config");
+
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Subtasks");
+
+                    b.Navigation("Worktree");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260601133737_AddMaxParallelExecutions.cs

@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMaxParallelExecutions : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "max_parallel_executions",
+                table: "app_settings",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 1);
+
+            migrationBuilder.UpdateData(
+                table: "app_settings",
+                keyColumn: "id",
+                keyValue: 1,
+                column: "max_parallel_executions",
+                value: 1);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "max_parallel_executions",
+                table: "app_settings");
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260601140000_NormalizeListIdFormat.Designer.cs

@@ -0,0 +1,607 @@
+// <auto-generated />
+using System;
+using ClaudeDo.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    [DbContext(typeof(ClaudeDoDbContext))]
+    [Migration("20260601140000_NormalizeListIdFormat")]
+    partial class NormalizeListIdFormat
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.11");
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.AppSettingsEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CentralWorktreeRoot")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("central_worktree_root");
+
+                    b.Property<string>("DefaultClaudeInstructions")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("")
+                        .HasColumnName("default_claude_instructions");
+
+                    b.Property<int>("DefaultMaxTurns")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(30)
+                        .HasColumnName("default_max_turns");
+
+                    b.Property<string>("DefaultModel")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sonnet")
+                        .HasColumnName("default_model");
+
+                    b.Property<string>("DefaultPermissionMode")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("bypassPermissions")
+                        .HasColumnName("default_permission_mode");
+
+                    b.Property<int>("MaxParallelExecutions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("max_parallel_executions");
+
+                    b.Property<string>("RepoImportFolders")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("repo_import_folders");
+
+                    b.Property<int>("WorktreeAutoCleanupDays")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(7)
+                        .HasColumnName("worktree_auto_cleanup_days");
+
+                    b.Property<bool>("WorktreeAutoCleanupEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("worktree_auto_cleanup_enabled");
+
+                    b.Property<string>("WorktreeStrategy")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("sibling")
+                        .HasColumnName("worktree_strategy");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("app_settings", (string)null);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            DefaultClaudeInstructions = "",
+                            DefaultMaxTurns = 100,
+                            DefaultModel = "sonnet",
+                            DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
+                            WorktreeAutoCleanupDays = 7,
+                            WorktreeAutoCleanupEnabled = false,
+                            WorktreeStrategy = "sibling"
+                        });
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.Property<string>("ListId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.HasKey("ListId");
+
+                    b.ToTable("list_config", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DefaultCommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("default_commit_type");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<string>("WorkingDir")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("working_dir");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
+                    b.ToTable("lists", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.PrimeScheduleEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<bool>("Enabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("enabled");
+
+                    b.Property<DateOnly>("EndDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("end_date");
+
+                    b.Property<DateTimeOffset?>("LastRunAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_run_at");
+
+                    b.Property<string>("PromptOverride")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt_override");
+
+                    b.Property<DateOnly>("StartDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("start_date");
+
+                    b.Property<TimeSpan>("TimeOfDay")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time_of_day");
+
+                    b.Property<bool>("WorkdaysOnly")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true)
+                        .HasColumnName("workdays_only");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("prime_schedules", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<bool>("Completed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("completed");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<int>("OrderNum")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("order_num");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_subtasks_task_id");
+
+                    b.ToTable("subtasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("AgentPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("agent_path");
+
+                    b.Property<string>("BlockedByTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("blocked_by_task_id");
+
+                    b.Property<string>("CommitType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("chore")
+                        .HasColumnName("commit_type");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("CreatedBy")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_by");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsMyDay")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_my_day");
+
+                    b.Property<bool>("IsStarred")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_starred");
+
+                    b.Property<string>("ListId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("list_id");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Model")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("model");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("notes");
+
+                    b.Property<string>("ParentTaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("parent_task_id");
+
+                    b.Property<DateTime?>("PlanningFinalizedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_finalized_at");
+
+                    b.Property<string>("PlanningPhase")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("none")
+                        .HasColumnName("planning_phase");
+
+                    b.Property<string>("PlanningSessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_id");
+
+                    b.Property<string>("PlanningSessionToken")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("planning_session_token");
+
+                    b.Property<string>("Result")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result");
+
+                    b.Property<DateTime?>("ScheduledFor")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("scheduled_for");
+
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("status");
+
+                    b.Property<string>("SystemPrompt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("system_prompt");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockedByTaskId")
+                        .HasDatabaseName("idx_tasks_blocked_by");
+
+                    b.HasIndex("ListId")
+                        .HasDatabaseName("idx_tasks_list_id");
+
+                    b.HasIndex("ParentTaskId")
+                        .HasDatabaseName("idx_tasks_parent_task_id");
+
+                    b.HasIndex("Status")
+                        .HasDatabaseName("idx_tasks_status");
+
+                    b.HasIndex("ListId", "SortOrder")
+                        .HasDatabaseName("idx_tasks_list_sort");
+
+                    b.ToTable("tasks", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("id");
+
+                    b.Property<string>("ErrorMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("error_markdown");
+
+                    b.Property<int?>("ExitCode")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("exit_code");
+
+                    b.Property<DateTime?>("FinishedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("finished_at");
+
+                    b.Property<bool>("IsRetry")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("is_retry");
+
+                    b.Property<string>("LogPath")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("log_path");
+
+                    b.Property<string>("Prompt")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("prompt");
+
+                    b.Property<string>("ResultMarkdown")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("result_markdown");
+
+                    b.Property<int>("RunNumber")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("run_number");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("session_id");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("started_at");
+
+                    b.Property<string>("StructuredOutputJson")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("structured_output");
+
+                    b.Property<string>("TaskId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<int?>("TokensIn")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_in");
+
+                    b.Property<int?>("TokensOut")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("tokens_out");
+
+                    b.Property<int?>("TurnCount")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("turn_count");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TaskId")
+                        .HasDatabaseName("idx_task_runs_task_id");
+
+                    b.ToTable("task_runs", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.Property<string>("TaskId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("task_id");
+
+                    b.Property<string>("BaseCommit")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("base_commit");
+
+                    b.Property<string>("BranchName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("branch_name");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("created_at");
+
+                    b.Property<string>("DiffStat")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("diff_stat");
+
+                    b.Property<string>("HeadCommit")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("head_commit");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("active")
+                        .HasColumnName("state");
+
+                    b.HasKey("TaskId");
+
+                    b.ToTable("worktrees", (string)null);
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListConfigEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithOne("Config")
+                        .HasForeignKey("ClaudeDo.Data.Models.ListConfigEntity", "ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("List");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.SubtaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Subtasks")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", null)
+                        .WithMany()
+                        .HasForeignKey("BlockedByTaskId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ClaudeDo.Data.Models.ListEntity", "List")
+                        .WithMany("Tasks")
+                        .HasForeignKey("ListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentTaskId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("List");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskRunEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithMany("Runs")
+                        .HasForeignKey("TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.WorktreeEntity", b =>
+                {
+                    b.HasOne("ClaudeDo.Data.Models.TaskEntity", "Task")
+                        .WithOne("Worktree")
+                        .HasForeignKey("ClaudeDo.Data.Models.WorktreeEntity", "TaskId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Task");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.ListEntity", b =>
+                {
+                    b.Navigation("Config");
+
+                    b.Navigation("Tasks");
+                });
+
+            modelBuilder.Entity("ClaudeDo.Data.Models.TaskEntity", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Runs");
+
+                    b.Navigation("Subtasks");
+
+                    b.Navigation("Worktree");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/20260601140000_NormalizeListIdFormat.cs

@@ -0,0 +1,52 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ClaudeDo.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class NormalizeListIdFormat : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // SQLite: PRAGMA foreign_keys must run outside a transaction.
+            migrationBuilder.Sql("PRAGMA foreign_keys = OFF;", suppressTransaction: true);
+
+            // Normalize tasks.list_id: 32-char compact hex → 36-char dashed UUID
+            migrationBuilder.Sql("""
+                UPDATE tasks
+                SET list_id = substr(list_id,1,8)||'-'||substr(list_id,9,4)||'-'||substr(list_id,13,4)||'-'||substr(list_id,17,4)||'-'||substr(list_id,21,12)
+                WHERE length(list_id) = 32;
+                """);
+
+            // Normalize list_config.list_id (also the PK of that table)
+            migrationBuilder.Sql("""
+                UPDATE list_config
+                SET list_id = substr(list_id,1,8)||'-'||substr(list_id,9,4)||'-'||substr(list_id,13,4)||'-'||substr(list_id,17,4)||'-'||substr(list_id,21,12)
+                WHERE length(list_id) = 32;
+                """);
+
+            // Normalize lists.id (PK — must come last)
+            migrationBuilder.Sql("""
+                UPDATE lists
+                SET id = substr(id,1,8)||'-'||substr(id,9,4)||'-'||substr(id,13,4)||'-'||substr(id,17,4)||'-'||substr(id,21,12)
+                WHERE length(id) = 32;
+                """);
+
+            migrationBuilder.Sql("PRAGMA foreign_keys = ON;", suppressTransaction: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("PRAGMA foreign_keys = OFF;", suppressTransaction: true);
+
+            migrationBuilder.Sql("UPDATE tasks SET list_id = replace(list_id,'-','') WHERE length(list_id) = 36;");
+            migrationBuilder.Sql("UPDATE list_config SET list_id = replace(list_id,'-','') WHERE length(list_id) = 36;");
+            migrationBuilder.Sql("UPDATE lists SET id = replace(id,'-','') WHERE length(id) = 36;");
+
+            migrationBuilder.Sql("PRAGMA foreign_keys = ON;", suppressTransaction: true);
+        }
+    }
+}

src/ClaudeDo.Data/Migrations/ClaudeDoDbContextModelSnapshot.cs

@@ -54,6 +54,12 @@ namespace ClaudeDo.Data.Migrations
                         .HasDefaultValue("bypassPermissions")
                         .HasColumnName("default_permission_mode");
 
+                    b.Property<int>("MaxParallelExecutions")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("max_parallel_executions");
+
                     b.Property<string>("RepoImportFolders")
                         .HasColumnType("TEXT")
                         .HasColumnName("repo_import_folders");
@@ -89,6 +95,7 @@ namespace ClaudeDo.Data.Migrations
                             DefaultMaxTurns = 100,
                             DefaultModel = "sonnet",
                             DefaultPermissionMode = "auto",
+                            MaxParallelExecutions = 1,
                             WorktreeAutoCleanupDays = 7,
                             WorktreeAutoCleanupEnabled = false,
                             WorktreeStrategy = "sibling"
@@ -140,12 +147,21 @@ namespace ClaudeDo.Data.Migrations
                         .HasColumnType("TEXT")
                         .HasColumnName("name");
 
+                    b.Property<int>("SortOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(0)
+                        .HasColumnName("sort_order");
+
                     b.Property<string>("WorkingDir")
                         .HasColumnType("TEXT")
                         .HasColumnName("working_dir");
 
                     b.HasKey("Id");
 
+                    b.HasIndex("SortOrder")
+                        .HasDatabaseName("idx_lists_sort");
+
                     b.ToTable("lists", (string)null);
                 });
 

src/ClaudeDo.Data/Models/AppSettingsEntity.cs

@@ -11,6 +11,8 @@ public sealed class AppSettingsEntity
     public int DefaultMaxTurns { get; set; } = 100;
     public string DefaultPermissionMode { get; set; } = "auto";
 
+    public int MaxParallelExecutions { get; set; } = 1;
+
     public string WorktreeStrategy { get; set; } = "sibling";
     public string? CentralWorktreeRoot { get; set; }
     public bool WorktreeAutoCleanupEnabled { get; set; }

src/ClaudeDo.Data/Models/ListEntity.cs

@@ -7,6 +7,7 @@ public sealed class ListEntity
     public required DateTime CreatedAt { get; init; }
     public string? WorkingDir { get; set; }
     public string DefaultCommitType { get; set; } = CommitTypeRegistry.DefaultType;
+    public int SortOrder { get; set; }
 
     // Navigation properties
     public ListConfigEntity? Config { get; set; }

src/ClaudeDo.Data/Repositories/AppSettingsRepository.cs

@@ -44,6 +44,7 @@ public sealed class AppSettingsRepository
         row.DefaultMaxTurns = updated.DefaultMaxTurns;
         row.DefaultPermissionMode = string.IsNullOrWhiteSpace(updated.DefaultPermissionMode)
             ? "auto" : updated.DefaultPermissionMode;
+        row.MaxParallelExecutions = updated.MaxParallelExecutions < 1 ? 1 : updated.MaxParallelExecutions;
         row.WorktreeStrategy = string.IsNullOrWhiteSpace(updated.WorktreeStrategy) ? "sibling" : updated.WorktreeStrategy;
         row.CentralWorktreeRoot = string.IsNullOrWhiteSpace(updated.CentralWorktreeRoot)
             ? null : updated.CentralWorktreeRoot;

src/ClaudeDo.Data/Repositories/ListRepository.cs

@@ -33,7 +33,19 @@ public sealed class ListRepository
 
     public async Task<List<ListEntity>> GetAllAsync(CancellationToken ct = default)
     {
-        return await _context.Lists.OrderBy(l => l.CreatedAt).ToListAsync(ct);
+        return await _context.Lists.OrderBy(l => l.SortOrder).ThenBy(l => l.CreatedAt).ToListAsync(ct);
+    }
+
+    public async Task ReorderAsync(IReadOnlyList<string> orderedListIds, CancellationToken ct = default)
+    {
+        var idSet = orderedListIds.ToHashSet();
+        var entities = await _context.Lists.Where(l => idSet.Contains(l.Id)).ToListAsync(ct);
+        for (int i = 0; i < orderedListIds.Count; i++)
+        {
+            var e = entities.FirstOrDefault(x => x.Id == orderedListIds[i]);
+            if (e is not null) e.SortOrder = i;
+        }
+        await _context.SaveChangesAsync(ct);
     }
 
     public async Task<ListConfigEntity?> GetConfigAsync(string listId, CancellationToken ct = default)

src/ClaudeDo.Data/Seeding/DefaultListsSeeder.cs

@@ -15,7 +15,7 @@ public static class DefaultListsSeeder
         {
             ctx.Lists.Add(new ListEntity
             {
-                Id = Guid.NewGuid().ToString("N"),
+                Id = Guid.NewGuid().ToString(),
                 Name = name,
                 CreatedAt = now,
             });

src/ClaudeDo.Installer/App.xaml.cs

@@ -209,6 +209,8 @@ public partial class App : Application
         sc.AddSingleton<IInstallStep>(sp => sp.GetRequiredService<DownloadAndExtractStep>());
         sc.AddSingleton<IInstallStep, WriteConfigStep>();
         sc.AddSingleton<IInstallStep, InitDatabaseStep>();
+        sc.AddSingleton<RegisterMcpStep>();
+        sc.AddSingleton<IInstallStep>(sp => sp.GetRequiredService<RegisterMcpStep>());
         sc.AddSingleton<RegisterAutostartStep>();
         sc.AddSingleton<IInstallStep>(sp => sp.GetRequiredService<RegisterAutostartStep>());
         sc.AddSingleton<IInstallStep, CreateShortcutsStep>();

src/ClaudeDo.Installer/Core/InstallContext.cs

@@ -32,4 +32,8 @@ public sealed class InstallContext
 
     // InstallPage
     public bool CreateDesktopShortcut { get; set; } = true;
+
+    // WelcomePage — register the external MCP endpoint with the Claude CLI.
+    public bool RegisterMcpWithClaude { get; set; } = true;
+    public int ExternalMcpPort { get; set; } = 47_822;
 }

src/ClaudeDo.Installer/Pages/InstallPage/InstallPageViewModel.cs

@@ -84,6 +84,15 @@ public partial class InstallPageViewModel : ObservableObject, IInstallerPage
     {
         if (IsInstalling) return;
 
+        // Reset per-step state so a re-run starts clean instead of appending
+        // output to the previous run's messages.
+        foreach (var s in Steps)
+        {
+            s.Messages.Clear();
+            s.Status = StepStatus.Pending;
+            s.IsExpanded = false;
+        }
+
         IsInstalling = true;
         IsComplete = false;
         HasErrors = false;
@@ -96,7 +105,11 @@ public partial class InstallPageViewModel : ObservableObject, IInstallerPage
             var step = Steps.FirstOrDefault(s => s.Name == p.StepName);
             if (step is null) return;
 
-            step.Status = p.Status;
+            // Status and output lines arrive on two separate Progress<T> channels, so a
+            // trailing "Running" line-message can be delivered after the step's terminal
+            // Done/Failed. Never let that downgrade a completed step back to Running.
+            if (!(step.Status is StepStatus.Done or StepStatus.Failed && p.Status is StepStatus.Running))
+                step.Status = p.Status;
             if (p.Message is not null)
             {
                 // Messages starting with "\r" overwrite the previous line (live progress).
@@ -135,6 +148,7 @@ public partial class InstallPageViewModel : ObservableObject, IInstallerPage
                     _serviceProvider.GetRequiredService<DownloadAndExtractStep>(),
                     // Migrates the legacy service away and (re)registers the logon task.
                     _serviceProvider.GetRequiredService<RegisterAutostartStep>(),
+                    _serviceProvider.GetRequiredService<RegisterMcpStep>(),
                     _serviceProvider.GetRequiredService<StartWorkerStep>(),
                     _serviceProvider.GetRequiredService<WriteInstallManifestStep>(),
                     // Refresh the bundled uninstaller exe + Add/Remove-Programs version so a

src/ClaudeDo.Installer/Pages/WelcomePage/WelcomePageView.xaml

@@ -32,6 +32,14 @@
             <TextBlock Text="{Binding InstallError}" Foreground="{StaticResource ErrorBrush}" FontSize="11"
                        Visibility="{Binding InstallError, Converter={StaticResource NullToCollapsedConverter}}"/>
 
+            <CheckBox Content="Register MCP server with Claude"
+                      IsChecked="{Binding RegisterMcp}"
+                      Margin="0,24,0,0"/>
+            <TextBlock Text="Runs 'claude mcp add' so Claude can view and manage your ClaudeDo tasks. You can change this later."
+                       TextWrapping="Wrap" FontSize="11"
+                       Foreground="{StaticResource TextSecondaryBrush}"
+                       Margin="0,4,0,0"/>
+
         </StackPanel>
     </ScrollViewer>
 </UserControl>

src/ClaudeDo.Installer/Pages/WelcomePage/WelcomePageViewModel.cs

@@ -24,6 +24,7 @@ public partial class WelcomePageViewModel : ObservableObject, IInstallerPage
     [ObservableProperty] private string _heading = "Install ClaudeDo";
     [ObservableProperty] private string _subheading = "Set the installation directory and continue.";
     [ObservableProperty] private bool _installDirEditable = true;
+    [ObservableProperty] private bool _registerMcp = true;
 
     public WelcomePageViewModel(InstallContext context)
     {
@@ -62,6 +63,7 @@ public partial class WelcomePageViewModel : ObservableObject, IInstallerPage
     public Task ApplyAsync()
     {
         _context.InstallDirectory = InstallDirectory;
+        _context.RegisterMcpWithClaude = RegisterMcp;
         return Task.CompletedTask;
     }
 

src/ClaudeDo.Installer/Steps/RegisterMcpStep.cs

@@ -0,0 +1,47 @@
+using ClaudeDo.Installer.Core;
+
+namespace ClaudeDo.Installer.Steps;
+
+public sealed class RegisterMcpStep : IInstallStep
+{
+    private const string ServerName = "claudedo";
+
+    public string Name => "Register MCP with Claude";
+
+    public async Task<StepResult> ExecuteAsync(InstallContext ctx, IProgress<string> progress, CancellationToken ct)
+    {
+        if (!ctx.RegisterMcpWithClaude)
+        {
+            progress.Report("Skipped (not selected)");
+            return StepResult.Ok();
+        }
+
+        var url = $"http://127.0.0.1:{ctx.ExternalMcpPort}/mcp";
+
+        // Drop any prior registration first so a re-run (e.g. update, changed port)
+        // overwrites cleanly instead of erroring on a duplicate name.
+        progress.Report($"Removing existing '{ServerName}' MCP registration (if any)...");
+        await ProcessRunner.RunAsync(ctx.ClaudeBin, $"mcp remove --scope user {ServerName}", null, progress, ct);
+
+        progress.Report($"Registering '{ServerName}' MCP server at {url}...");
+        var (exit, output) = await ProcessRunner.RunAsync(
+            ctx.ClaudeBin,
+            $"mcp add --transport http --scope user {ServerName} {url}",
+            null, progress, ct);
+
+        // Non-fatal: a missing/old Claude CLI must never block the install. Surface the
+        // manual command so the user can register it themselves later.
+        if (exit != 0)
+        {
+            progress.Report(
+                $"Could not register MCP automatically (claude exited {exit}). " +
+                $"Run manually: claude mcp add --transport http --scope user {ServerName} {url}");
+        }
+        else
+        {
+            progress.Report("MCP server registered with Claude.");
+        }
+
+        return StepResult.Ok();
+    }
+}

src/ClaudeDo.Installer/Steps/StopWorkerStep.cs

@@ -7,25 +7,32 @@ namespace ClaudeDo.Installer.Steps;
 public sealed class StopWorkerStep : IInstallStep
 {
     public const string LegacyTaskName = "ClaudeDoWorker";
-    public const string ProcessName = "ClaudeDo.Worker";
+
+    // Both must be stopped before the install dir is touched: a running app/worker
+    // exe locks its directory, so Directory.Move during extraction would otherwise
+    // fail with "Access to the path '...\app' is denied".
+    private static readonly string[] ProcessNames = { "ClaudeDo.Worker", "ClaudeDo.App" };
 
     public string Name => "Stop Worker";
 
     public async Task<StepResult> ExecuteAsync(InstallContext ctx, IProgress<string> progress, CancellationToken ct)
     {
-        progress.Report("Stopping worker process (if running)...");
+        progress.Report("Stopping ClaudeDo processes (if running)...");
         var installDir = ctx.InstallDirectory;
-        foreach (var p in Process.GetProcessesByName(ProcessName))
+        foreach (var name in ProcessNames)
         {
-            try
+            foreach (var p in Process.GetProcessesByName(name))
             {
-                var path = p.MainModule?.FileName;
+                try
-                if (path is not null && !IsUnder(path, installDir)) continue;
+                {
-                p.Kill(entireProcessTree: true);
+                    var path = p.MainModule?.FileName;
-                p.WaitForExit(10000);
+                    if (path is not null && !IsUnder(path, installDir)) continue;
+                    p.Kill(entireProcessTree: true);
+                    p.WaitForExit(10000);
+                }
+                catch { /* process may have exited or be inaccessible */ }
+                finally { p.Dispose(); }
             }
-            catch { /* process may have exited or be inaccessible */ }
-            finally { p.Dispose(); }
         }
         await Task.CompletedTask;
         return StepResult.Ok();

src/ClaudeDo.Ui/Design/IslandStyles.axaml

@@ -826,6 +826,15 @@
     <Setter Property="Opacity"         Value="0.5" />
     <Setter Property="TextDecorations" Value="Strikethrough" />
   </Style>
+  <Style Selector="TextBox.subtask-edit">
+    <Setter Property="Padding"         Value="4,2" />
+    <Setter Property="MinHeight"       Value="0" />
+    <Setter Property="Background"      Value="{StaticResource Surface2Brush}" />
+    <Setter Property="BorderBrush"     Value="{DynamicResource LineBrush}" />
+    <Setter Property="BorderThickness" Value="1" />
+    <Setter Property="CornerRadius"    Value="6" />
+    <Setter Property="Foreground"      Value="{DynamicResource TextBrush}" />
+  </Style>
 
   <!-- ============================================================ -->
   <!-- SECTION LABELS (OVERDUE / TASKS / COMPLETED)                 -->

src/ClaudeDo.Ui/Services/WorkerClient.cs

@@ -450,6 +450,7 @@ public sealed record AppSettingsDto(
     string DefaultModel,
     int DefaultMaxTurns,
     string DefaultPermissionMode,
+    int MaxParallelExecutions,
     string WorktreeStrategy,
     string? CentralWorktreeRoot,
     bool WorktreeAutoCleanupEnabled,

src/ClaudeDo.Ui/ViewModels/Islands/DetailsIslandViewModel.cs

@@ -840,6 +840,35 @@ public sealed partial class DetailsIslandViewModel : ViewModelBase
         CloseDetail?.Invoke();
     }
 
+    [RelayCommand]
+    private async System.Threading.Tasks.Task CommitSubtaskEditAsync(SubtaskRowViewModel? row)
+    {
+        if (row is null || !row.IsEditing) return;
+        row.IsEditing = false;
+
+        var title = row.Title?.Trim() ?? "";
+        await using var ctx = _dbFactory.CreateDbContext();
+        var repo = new SubtaskRepository(ctx);
+
+        // Emptying the text removes the step.
+        if (string.IsNullOrEmpty(title))
+        {
+            await repo.DeleteAsync(row.Id);
+            Subtasks.Remove(row);
+            return;
+        }
+
+        var subs = await repo.GetByTaskIdAsync(Task?.Id ?? "");
+        var entity = subs.FirstOrDefault(s => s.Id == row.Id);
+        if (entity is null) return;
+        if (entity.Title != title)
+        {
+            entity.Title = title;
+            await repo.UpdateAsync(entity);
+        }
+        row.Title = title;
+    }
+
     [RelayCommand]
     private async System.Threading.Tasks.Task AddSubtaskAsync()
     {
@@ -943,6 +972,7 @@ public sealed partial class SubtaskRowViewModel : ViewModelBase
     public required string Id { get; init; }
     [ObservableProperty] private string _title = "";
     [ObservableProperty] private bool _done;
+    [ObservableProperty] private bool _isEditing;
     [ObservableProperty] private ClaudeDo.Data.Models.TaskStatus _status;
     [ObservableProperty] private ClaudeDo.Data.Models.WorktreeState _worktreeState = ClaudeDo.Data.Models.WorktreeState.Active;
 }

src/ClaudeDo.Ui/ViewModels/Islands/ListNavItemViewModel.cs

@@ -12,6 +12,8 @@ public sealed partial class ListNavItemViewModel : ViewModelBase
     [ObservableProperty] private bool _isActive;
     [ObservableProperty] private string? _workingDir;
     [ObservableProperty] private string _defaultCommitType = CommitTypeRegistry.DefaultType;
+    [ObservableProperty] private bool _dropHintAbove;
+    [ObservableProperty] private bool _dropHintBelow;
     public string? IconKey { get; init; }
     public string? DotColorKey { get; init; }
 }

src/ClaudeDo.Ui/ViewModels/Islands/ListsIslandViewModel.cs

@@ -82,6 +82,52 @@ public sealed partial class ListsIslandViewModel : ViewModelBase
         finally { _worktreesOverviewOpen = false; }
     }
 
+    [RelayCommand]
+    private void OpenInExplorer(ListNavItemViewModel? row)
+    {
+        var dir = row?.WorkingDir;
+        if (string.IsNullOrWhiteSpace(dir) || !System.IO.Directory.Exists(dir)) return;
+        try
+        {
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = dir,
+                UseShellExecute = true,
+            });
+        }
+        catch { /* best-effort */ }
+    }
+
+    [RelayCommand]
+    private void OpenInTerminal(ListNavItemViewModel? row)
+    {
+        var dir = row?.WorkingDir;
+        if (string.IsNullOrWhiteSpace(dir) || !System.IO.Directory.Exists(dir)) return;
+        try
+        {
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+            {
+                FileName = "wt.exe",
+                Arguments = $"-d \"{dir}\"",
+                UseShellExecute = true,
+            });
+        }
+        catch
+        {
+            // Windows Terminal not installed — fall back to a plain console at the directory.
+            try
+            {
+                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = "cmd.exe",
+                    WorkingDirectory = dir,
+                    UseShellExecute = true,
+                });
+            }
+            catch { /* best-effort */ }
+        }
+    }
+
     public ObservableCollection<ListNavItemViewModel> Items { get; } = new();
     public ObservableCollection<ListNavItemViewModel> SmartLists { get; } = new();
     public ObservableCollection<ListNavItemViewModel> UserLists { get; } = new();
@@ -231,6 +277,57 @@ public sealed partial class ListsIslandViewModel : ViewModelBase
         }
     }
 
+    public void ClearDropHints()
+    {
+        foreach (var r in UserLists)
+        {
+            r.DropHintAbove = false;
+            r.DropHintBelow = false;
+        }
+    }
+
+    public void SetDropHint(ListNavItemViewModel target, bool placeBelow)
+    {
+        foreach (var r in UserLists)
+        {
+            var isTarget = ReferenceEquals(r, target);
+            r.DropHintAbove = isTarget && !placeBelow;
+            r.DropHintBelow = isTarget && placeBelow;
+        }
+    }
+
+    public async Task ReorderAsync(ListNavItemViewModel source, ListNavItemViewModel target, bool placeBelow)
+    {
+        if (source.Kind != ListKind.User || target.Kind != ListKind.User) return;
+        if (ReferenceEquals(source, target)) return;
+
+        MoveWithinCollection(UserLists, source, target, placeBelow);
+
+        var orderedIds = UserLists.Select(i => i.Id["user:".Length..]).ToList();
+        await using var ctx = await _dbFactory.CreateDbContextAsync();
+        var lists = new ListRepository(ctx);
+        await lists.ReorderAsync(orderedIds);
+    }
+
+    private static void MoveWithinCollection(
+        ObservableCollection<ListNavItemViewModel> coll,
+        ListNavItemViewModel source,
+        ListNavItemViewModel target,
+        bool placeBelow)
+    {
+        var srcIdx = coll.IndexOf(source);
+        var tgtIdx = coll.IndexOf(target);
+        if (srcIdx < 0 || tgtIdx < 0 || srcIdx == tgtIdx) return;
+
+        var finalIdx = placeBelow ? tgtIdx + 1 : tgtIdx;
+        if (srcIdx < finalIdx) finalIdx--;
+        if (finalIdx < 0) finalIdx = 0;
+        if (finalIdx >= coll.Count) finalIdx = coll.Count - 1;
+        if (finalIdx == srcIdx) return;
+
+        coll.Move(srcIdx, finalIdx);
+    }
+
     partial void OnSelectedListChanged(ListNavItemViewModel? value)
     {
         foreach (var i in Items) i.IsActive = ReferenceEquals(i, value);

src/ClaudeDo.Ui/ViewModels/Islands/TaskRowViewModel.cs

@@ -17,7 +17,6 @@ public sealed partial class TaskRowViewModel : ViewModelBase
     [ObservableProperty] private PlanningPhase _planningPhase;
     [ObservableProperty] private string? _branch;
     [ObservableProperty] private string? _diffStat;
-    [ObservableProperty] private string? _liveTail;
     [ObservableProperty] private DateTime? _scheduledFor;
     [ObservableProperty] private int _diffAdditions;
     [ObservableProperty] private int _diffDeletions;
@@ -74,7 +73,6 @@ public sealed partial class TaskRowViewModel : ViewModelBase
                                 && PlanningPhase == PlanningPhase.Finalized
                                 && !HasQueuedSubtasks;
     public bool HasSchedule => ScheduledFor.HasValue;
-    public bool HasLiveTail => IsRunning && !string.IsNullOrEmpty(LiveTail);
 
     public string DiffAdditionsText => $"+{DiffAdditions}";
     public string DiffDeletionsText => $"−{DiffDeletions}";
@@ -96,7 +94,6 @@ public sealed partial class TaskRowViewModel : ViewModelBase
         OnPropertyChanged(nameof(IsRunning));
         OnPropertyChanged(nameof(IsQueued));
         OnPropertyChanged(nameof(IsWaiting));
-        OnPropertyChanged(nameof(HasLiveTail));
         OnPropertyChanged(nameof(IsDraft));
         OnPropertyChanged(nameof(IsPlanned));
         OnPropertyChanged(nameof(CanOpenPlanningSession));
@@ -152,7 +149,6 @@ public sealed partial class TaskRowViewModel : ViewModelBase
     }
 
     partial void OnBranchChanged(string? value)    => OnPropertyChanged(nameof(HasBranch));
-    partial void OnLiveTailChanged(string? value)  => OnPropertyChanged(nameof(HasLiveTail));
     partial void OnDoneChanged(bool value)         => OnPropertyChanged(nameof(IsOverdue));
     partial void OnScheduledForChanged(DateTime? value)
     {

src/ClaudeDo.Ui/ViewModels/Islands/TasksIslandViewModel.cs

@@ -56,18 +56,11 @@ public sealed partial class TasksIslandViewModel : ViewModelBase
         {
             _worker.TaskUpdatedEvent       += OnWorkerTaskUpdated;
             _worker.WorktreeUpdatedEvent   += OnWorkerTaskUpdated;
-            _worker.TaskMessageEvent       += OnWorkerTaskMessage;
             _worker.ListUpdatedEvent       += OnWorkerListUpdated;
             _worker.ConnectionRestoredEvent += () => LoadForList(_currentList);
         }
     }
 
-    private void OnWorkerTaskMessage(string taskId, string line)
-    {
-        var row = Items.FirstOrDefault(r => r.Id == taskId);
-        if (row is not null) row.LiveTail = line;
-    }
-
     private async void OnWorkerListUpdated(string listId)
     {
         // Mirror the renamed list onto every task row that references it,
@@ -487,6 +480,38 @@ public sealed partial class TasksIslandViewModel : ViewModelBase
         TasksChanged?.Invoke(this, EventArgs.Empty);
     }
 
+    [RelayCommand]
+    private async Task ClearCompletedAsync()
+    {
+        if (CompletedItems.Count == 0) return;
+
+        // Delete children before parents so the parent-child FK (Restrict) doesn't
+        // block removing a completed planning parent together with its done children.
+        var toDelete = CompletedItems.OrderByDescending(r => r.IsChild).ToList();
+
+        if (ConfirmAsync is not null)
+        {
+            var ok = await ConfirmAsync($"Clear {toDelete.Count} completed task(s)? This cannot be undone.");
+            if (!ok) return;
+        }
+
+        await using var db = await _dbFactory.CreateDbContextAsync();
+        var repo = new TaskRepository(db);
+        foreach (var row in toDelete)
+        {
+            try
+            {
+                await repo.DeleteAsync(row.Id);
+                Items.Remove(row);
+            }
+            catch { /* still referenced by open child tasks; leave it visible */ }
+        }
+
+        Regroup();
+        UpdateSubtitle();
+        TasksChanged?.Invoke(this, EventArgs.Empty);
+    }
+
     [RelayCommand]
     private async Task ToggleStarAsync(TaskRowViewModel row)
     {

src/ClaudeDo.Ui/ViewModels/Modals/Settings/GeneralSettingsTabViewModel.cs

@@ -9,6 +9,7 @@ public sealed partial class GeneralSettingsTabViewModel : ViewModelBase
     [ObservableProperty] private string _defaultModel = ModelRegistry.DefaultAlias;
     [ObservableProperty] private int _defaultMaxTurns = 100;
     [ObservableProperty] private string _defaultPermissionMode = PermissionModeRegistry.DefaultMode;
+    [ObservableProperty] private int _maxParallelExecutions = 1;
 
     public IReadOnlyList<string> Models { get; } = ModelRegistry.Aliases;
     public IReadOnlyList<string> PermissionModes { get; } = PermissionModeRegistry.Modes;
@@ -17,6 +18,8 @@ public sealed partial class GeneralSettingsTabViewModel : ViewModelBase
     {
         if (DefaultMaxTurns < 1 || DefaultMaxTurns > 200)
             return "Max turns must be between 1 and 200.";
+        if (MaxParallelExecutions < 1 || MaxParallelExecutions > 20)
+            return "Max parallel executions must be between 1 and 20.";
         return null;
     }
 }

src/ClaudeDo.Ui/ViewModels/Modals/SettingsModalViewModel.cs

@@ -42,6 +42,7 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
                 General.DefaultModel = dto.DefaultModel ?? "sonnet";
                 General.DefaultMaxTurns = dto.DefaultMaxTurns;
                 General.DefaultPermissionMode = dto.DefaultPermissionMode ?? "auto";
+                General.MaxParallelExecutions = dto.MaxParallelExecutions;
                 Worktrees.WorktreeStrategy = dto.WorktreeStrategy ?? "sibling";
                 Worktrees.CentralWorktreeRoot = dto.CentralWorktreeRoot;
                 Worktrees.WorktreeAutoCleanupEnabled = dto.WorktreeAutoCleanupEnabled;
@@ -69,6 +70,7 @@ public sealed partial class SettingsModalViewModel : ViewModelBase
                 General.DefaultModel ?? "sonnet",
                 General.DefaultMaxTurns,
                 General.DefaultPermissionMode ?? "auto",
+                General.MaxParallelExecutions,
                 Worktrees.WorktreeStrategy ?? "sibling",
                 string.IsNullOrWhiteSpace(Worktrees.CentralWorktreeRoot) ? null : Worktrees.CentralWorktreeRoot,
                 Worktrees.WorktreeAutoCleanupEnabled,

src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml

@@ -50,7 +50,10 @@
         <StackPanel Grid.Column="1" Spacing="0">
           <TextBlock Classes="meta"
                      Text="{Binding TaskIdBadge}"
-                     Margin="0,0,0,4"/>
+                     Margin="0,0,0,4"
+                     Cursor="Hand"
+                     ToolTip.Tip="Copy task ID"
+                     Tapped="OnTaskIdTapped"/>
           <TextBox Text="{Binding EditableTitle, Mode=TwoWay}"
                    FontSize="{StaticResource FontSizeTaskTitle}" FontWeight="Medium"
                    BorderThickness="0" Background="Transparent"
@@ -186,13 +189,30 @@
                                  Width="16" Height="16"
                                  Cursor="Hand"/>
                       </Button>
-                      <TextBlock Grid.Column="1"
+                      <Panel Grid.Column="1" VerticalAlignment="Center">
-                                 Classes="subtask-title"
+                        <TextBlock Classes="subtask-title"
-                                 Text="{Binding Title}"
+                                   Text="{Binding Title}"
+                                   IsVisible="{Binding !IsEditing}"
+                                   FontSize="{StaticResource FontSizeBody}"
+                                   Foreground="{DynamicResource TextDimBrush}"
+                                   VerticalAlignment="Center"
+                                   TextWrapping="Wrap"
+                                   Cursor="Ibeam"
+                                   Tapped="OnSubtaskTitleTapped"/>
+                        <TextBox Classes="subtask-edit"
+                                 Text="{Binding Title, Mode=TwoWay}"
+                                 IsVisible="{Binding IsEditing}"
                                  FontSize="{StaticResource FontSizeBody}"
-                                 Foreground="{DynamicResource TextDimBrush}"
+                                 AcceptsReturn="False"
-                                 VerticalAlignment="Center"
+                                 TextWrapping="Wrap"
-                                 TextWrapping="Wrap"/>
+                                 LostFocus="OnSubtaskEditLostFocus">
+                          <TextBox.KeyBindings>
+                            <KeyBinding Gesture="Enter"
+                                        Command="{Binding $parent[ItemsControl].((vm:DetailsIslandViewModel)DataContext).CommitSubtaskEditCommand}"
+                                        CommandParameter="{Binding}"/>
+                          </TextBox.KeyBindings>
+                        </TextBox>
+                      </Panel>
                     </Grid>
                   </Border>
                 </DataTemplate>

src/ClaudeDo.Ui/Views/Islands/DetailsIslandView.axaml.cs

@@ -1,9 +1,13 @@
+using System.Linq;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.Views.Modals;
 using ClaudeDo.Ui.Views.Planning;
@@ -135,6 +139,31 @@ public partial class DetailsIslandView : UserControl
         return await tcs.Task;
     }
 
+    private void OnSubtaskTitleTapped(object? sender, TappedEventArgs e)
+    {
+        if (sender is not Control c || c.DataContext is not SubtaskRowViewModel row) return;
+        row.IsEditing = true;
+
+        var box = (c.GetVisualParent() as Panel)?.GetVisualDescendants().OfType<TextBox>().FirstOrDefault();
+        if (box is not null)
+            Dispatcher.UIThread.Post(() => { box.Focus(); box.SelectAll(); }, DispatcherPriority.Background);
+    }
+
+    private void OnSubtaskEditLostFocus(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is DetailsIslandViewModel vm
+            && sender is Control c && c.DataContext is SubtaskRowViewModel row)
+            vm.CommitSubtaskEditCommand.Execute(row);
+    }
+
+    private async void OnTaskIdTapped(object? sender, TappedEventArgs e)
+    {
+        if (DataContext is not DetailsIslandViewModel vm || vm.Task is null) return;
+        var clipboard = TopLevel.GetTopLevel(this)?.Clipboard;
+        if (clipboard is null) return;
+        await clipboard.SetTextAsync(vm.Task.Id);
+    }
+
     private async void OnCopyDescriptionClick(object? sender, RoutedEventArgs e)
     {
         if (DataContext is not DetailsIslandViewModel vm) return;

src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml

@@ -113,8 +113,18 @@
         <ItemsControl ItemsSource="{Binding UserLists}">
           <ItemsControl.ItemTemplate>
             <DataTemplate DataType="vm:ListNavItemViewModel">
-              <Border Classes="list-item" Classes.active="{Binding IsActive}"
+              <Grid RowDefinitions="Auto,Auto,Auto">
-                      Tapped="OnItemTapped">
+
+                <!-- Above-row drop indicator -->
+                <Border Grid.Row="0" Height="2" VerticalAlignment="Center" Margin="4,0"
+                        Background="{DynamicResource MossBrush}" CornerRadius="1"
+                        IsVisible="{Binding DropHintAbove}"/>
+
+              <Border Grid.Row="1" Classes="list-item" Classes.active="{Binding IsActive}"
+                      Tapped="OnItemTapped"
+                      DragDrop.AllowDrop="True"
+                      DragDrop.DragOver="OnListDragOver"
+                      DragDrop.Drop="OnListDrop">
                 <Border.ContextMenu>
                   <ContextMenu>
                     <MenuItem Header="Settings..."
@@ -123,6 +133,15 @@
                     <MenuItem Header="Worktrees…"
                               Command="{Binding $parent[UserControl].((vm:ListsIslandViewModel)DataContext).OpenWorktreesOverviewCommand}"
                               CommandParameter="{Binding}"/>
+                    <Separator IsVisible="{Binding WorkingDir, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"/>
+                    <MenuItem Header="Open in Explorer"
+                              IsVisible="{Binding WorkingDir, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"
+                              Command="{Binding $parent[UserControl].((vm:ListsIslandViewModel)DataContext).OpenInExplorerCommand}"
+                              CommandParameter="{Binding}"/>
+                    <MenuItem Header="Open in Terminal"
+                              IsVisible="{Binding WorkingDir, Converter={x:Static StringConverters.IsNotNullOrEmpty}}"
+                              Command="{Binding $parent[UserControl].((vm:ListsIslandViewModel)DataContext).OpenInTerminalCommand}"
+                              CommandParameter="{Binding}"/>
                   </ContextMenu>
                 </Border.ContextMenu>
                 <Grid ColumnDefinitions="20,*,Auto">
@@ -152,6 +171,12 @@
                              Text="{Binding Count}"/>
                 </Grid>
               </Border>
+
+                <!-- Below-row drop indicator (last item only) -->
+                <Border Grid.Row="2" Height="2" VerticalAlignment="Center" Margin="4,0"
+                        Background="{DynamicResource MossBrush}" CornerRadius="1"
+                        IsVisible="{Binding DropHintBelow}"/>
+              </Grid>
             </DataTemplate>
           </ItemsControl.ItemTemplate>
         </ItemsControl>

src/ClaudeDo.Ui/Views/Islands/ListsIslandView.axaml.cs

@@ -1,9 +1,11 @@
 using System.Linq;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
+using Avalonia.VisualTree;
 using ClaudeDo.Ui.ViewModels;
 using ClaudeDo.Ui.ViewModels.Islands;
 using ClaudeDo.Ui.ViewModels.Modals;
@@ -13,9 +15,13 @@ namespace ClaudeDo.Ui.Views.Islands;
 
 public partial class ListsIslandView : UserControl
 {
+    private static readonly DataFormat<string> ListRowFormat =
+        DataFormat.CreateStringApplicationFormat("claudedo-list-row");
+
     public ListsIslandView()
     {
         InitializeComponent();
+        AddHandler(PointerPressedEvent, OnTunnelPointerPressed, RoutingStrategies.Tunnel);
         DataContextChanged += (_, _) =>
         {
             if (DataContext is ListsIslandViewModel vm)
@@ -84,6 +90,127 @@ public partial class ListsIslandView : UserControl
             vm.SelectCommand.Execute(item);
     }
 
+    private async void OnTunnelPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (DataContext is not ListsIslandViewModel vm) return;
+        if (e.Source is not Visual src) return;
+
+        var border = FindListItemBorder(src);
+        if (border?.DataContext is not ListNavItemViewModel row || row.Kind != ListKind.User) return;
+        if (!e.GetCurrentPoint(border).Properties.IsLeftButtonPressed) return;
+
+        // Double-click opens the list's settings instead of starting a drag. Handled here
+        // because DoDragDropAsync captures the pointer and would swallow a DoubleTapped event.
+        if (e.ClickCount == 2)
+        {
+            vm.OpenListSettingsCommand.Execute(row);
+            return;
+        }
+
+        // Select now so the right pane updates whether the gesture becomes a click or a drag
+        // (the Tapped handler doesn't fire once DoDragDropAsync captures the pointer).
+        vm.SelectCommand.Execute(row);
+
+        var data = new DataTransfer();
+        data.Add(DataTransferItem.Create(ListRowFormat, row.Id));
+        try
+        {
+            await DragDrop.DoDragDropAsync(e, data, DragDropEffects.Move);
+        }
+        finally
+        {
+            vm.ClearDropHints();
+        }
+    }
+
+    private void OnListDragOver(object? sender, DragEventArgs e)
+    {
+        if (DataContext is not ListsIslandViewModel vm) { e.DragEffects = DragDropEffects.None; return; }
+        if (!e.DataTransfer?.Contains(ListRowFormat) ?? true)
+        {
+            e.DragEffects = DragDropEffects.None;
+            vm.ClearDropHints();
+            return;
+        }
+        if (sender is not Border b || b.DataContext is not ListNavItemViewModel target || target.Kind != ListKind.User)
+        {
+            e.DragEffects = DragDropEffects.None;
+            vm.ClearDropHints();
+            return;
+        }
+
+        var sourceId = e.DataTransfer?.TryGetValue(ListRowFormat);
+        if (string.IsNullOrEmpty(sourceId) || sourceId == target.Id)
+        {
+            e.DragEffects = DragDropEffects.None;
+            vm.ClearDropHints();
+            return;
+        }
+
+        var placeBelow = e.GetPosition(b).Y > b.Bounds.Height / 2;
+
+        // Canonicalize: "drop below X" == "drop above X+1". Only the last row shows a below-line.
+        ListNavItemViewModel hintRow = target;
+        bool hintBelow = false;
+        if (placeBelow)
+        {
+            var next = FindNextUserList(vm, target);
+            if (next is not null) { hintRow = next; hintBelow = false; }
+            else { hintRow = target; hintBelow = true; }
+        }
+
+        if (hintRow.Id == sourceId)
+        {
+            e.DragEffects = DragDropEffects.None;
+            vm.ClearDropHints();
+            return;
+        }
+
+        vm.SetDropHint(hintRow, hintBelow);
+        e.DragEffects = DragDropEffects.Move;
+    }
+
+    private async void OnListDrop(object? sender, DragEventArgs e)
+    {
+        if (DataContext is not ListsIslandViewModel vm) return;
+        try
+        {
+            if (sender is not Border b || b.DataContext is not ListNavItemViewModel target || target.Kind != ListKind.User) return;
+
+            var sourceId = e.DataTransfer?.TryGetValue(ListRowFormat);
+            if (string.IsNullOrEmpty(sourceId) || sourceId == target.Id) return;
+
+            var source = vm.UserLists.FirstOrDefault(r => r.Id == sourceId);
+            if (source is null) return;
+
+            var placeBelow = e.GetPosition(b).Y > b.Bounds.Height / 2;
+            vm.ClearDropHints();
+            await vm.ReorderAsync(source, target, placeBelow);
+        }
+        catch
+        {
+            vm.ClearDropHints();
+            throw;
+        }
+    }
+
+    private static Border? FindListItemBorder(Visual? v)
+    {
+        while (v is not null)
+        {
+            if (v is Border b && b.Classes.Contains("list-item")) return b;
+            v = v.GetVisualParent();
+        }
+        return null;
+    }
+
+    private static ListNavItemViewModel? FindNextUserList(ListsIslandViewModel vm, ListNavItemViewModel row)
+    {
+        var idx = vm.UserLists.IndexOf(row);
+        if (idx < 0) return null;
+        return idx + 1 < vm.UserLists.Count ? vm.UserLists[idx + 1] : null;
+    }
+
     private async System.Threading.Tasks.Task ShowSettingsAsync(SettingsModalViewModel settingsVm)
     {
         var owner = TopLevel.GetTopLevel(this) as Window;

src/ClaudeDo.Ui/Views/Islands/SessionTerminalView.axaml.cs

@@ -1,6 +1,5 @@
 using System.Collections.Specialized;
 using Avalonia.Controls;
-using Avalonia.Threading;
 using ClaudeDo.Ui.ViewModels.Islands;
 
 namespace ClaudeDo.Ui.Views.Islands;
@@ -9,16 +8,29 @@ public partial class SessionTerminalView : UserControl
 {
     public SessionTerminalView() { InitializeComponent(); }
 
+    private DetailsIslandViewModel? _boundVm;
+
     protected override void OnDataContextChanged(EventArgs e)
     {
         base.OnDataContextChanged(e);
-        if (DataContext is DetailsIslandViewModel vm)
+        if (_boundVm is not null)
-            vm.Log.CollectionChanged += OnLogChanged;
+            _boundVm.Log.CollectionChanged -= OnLogChanged;
+        _boundVm = DataContext as DetailsIslandViewModel;
+        if (_boundVm is not null)
+            _boundVm.Log.CollectionChanged += OnLogChanged;
     }
 
     private void OnLogChanged(object? sender, NotifyCollectionChangedEventArgs e)
     {
         if (e.Action != NotifyCollectionChangedAction.Add) return;
-        Dispatcher.UIThread.Post(() => LogScroll.ScrollToEnd(), DispatcherPriority.Background);
+        // Scroll after the next layout pass so the freshly-added (wrapping) line
+        // is measured first — otherwise ScrollToEnd stops short and clips it.
+        EventHandler? handler = null;
+        handler = (_, _) =>
+        {
+            LogScroll.LayoutUpdated -= handler;
+            LogScroll.ScrollToEnd();
+        };
+        LogScroll.LayoutUpdated += handler;
     }
 }

src/ClaudeDo.Ui/Views/Islands/TaskRowView.axaml

@@ -175,20 +175,6 @@
             </Border>
 
           </StackPanel>
-
-          <!-- Live-tail row (visible when running + has tail) -->
-          <Border Classes="task-live-tail" IsVisible="{Binding HasLiveTail}">
-            <StackPanel Spacing="3">
-              <TextBlock Text="{Binding LiveTail}"
-                         TextTrimming="CharacterEllipsis" MaxLines="1"/>
-              <Grid Height="3" HorizontalAlignment="Stretch">
-                <Rectangle Fill="{DynamicResource Surface3Brush}"
-                           HorizontalAlignment="Stretch" RadiusX="1.5" RadiusY="1.5"/>
-                <Rectangle Fill="{DynamicResource MossBrush}"
-                           HorizontalAlignment="Left" Width="60" RadiusX="1.5" RadiusY="1.5"/>
-              </Grid>
-            </StackPanel>
-          </Border>
         </StackPanel>
 
         <!-- Star toggle -->

src/ClaudeDo.Ui/Views/Islands/TasksIslandView.axaml

@@ -126,8 +126,17 @@
               <Binding Path="IsShowingCompleted"/>
             </MultiBinding>
           </StackPanel.IsVisible>
-          <TextBlock Classes="eyebrow section-label"
+          <Grid ColumnDefinitions="*,Auto" Margin="14,14,14,6">
-                     Text="{Binding CompletedHeader}" Margin="14,14,14,6"/>
+            <TextBlock Grid.Column="0" Classes="eyebrow section-label"
+                       Text="{Binding CompletedHeader}" VerticalAlignment="Center"/>
+            <Button Grid.Column="1" Classes="icon-btn"
+                    Command="{Binding ClearCompletedCommand}"
+                    ToolTip.Tip="Clear all completed"
+                    VerticalAlignment="Center">
+              <PathIcon Data="{StaticResource Icon.Trash}" Width="13" Height="13"
+                        Foreground="{DynamicResource BloodBrush}"/>
+            </Button>
+          </Grid>
           <ItemsControl ItemsSource="{Binding CompletedItems}">
             <ItemsControl.ItemTemplate>
               <DataTemplate DataType="vm:TaskRowViewModel">

src/ClaudeDo.Ui/Views/Modals/DiffModalView.axaml

@@ -5,9 +5,11 @@
         x:Class="ClaudeDo.Ui.Views.Modals.DiffModalView"
         x:DataType="vm:DiffModalViewModel"
         Title="Diff"
-        Width="1200" Height="800"
+        Width="1200" Height="800" MinWidth="700" MinHeight="450"
-        WindowDecorations="None"
+        CanResize="True"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
 

src/ClaudeDo.Ui/Views/Modals/ListSettingsModalView.axaml

@@ -8,8 +8,9 @@
         Width="520" Height="720"
         CanResize="True"
         MinWidth="460" MinHeight="520"
-        WindowDecorations="None"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
 

src/ClaudeDo.Ui/Views/Modals/MergeModalView.axaml

@@ -5,10 +5,11 @@
         x:Class="ClaudeDo.Ui.Views.Modals.MergeModalView"
         x:DataType="vm:MergeModalViewModel"
         Title="Merge worktree"
-        Width="560" Height="460"
+        Width="560" Height="460" MinWidth="460" MinHeight="360"
-        CanResize="False"
+        CanResize="True"
-        WindowDecorations="None"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
 

src/ClaudeDo.Ui/Views/Modals/RepoImportModalView.axaml

@@ -5,9 +5,11 @@
         x:Class="ClaudeDo.Ui.Views.Modals.RepoImportModalView"
         x:DataType="vm:RepoImportModalViewModel"
         Title="Add repos as lists"
-        Width="560" Height="480"
+        Width="560" Height="480" MinWidth="420" MinHeight="320"
-        WindowDecorations="None"
+        CanResize="True"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
   <Window.KeyBindings>

src/ClaudeDo.Ui/Views/Modals/SettingsModalView.axaml

@@ -7,9 +7,11 @@
         x:Class="ClaudeDo.Ui.Views.Modals.SettingsModalView"
         x:DataType="vm:SettingsModalViewModel"
         Title="Settings"
-        Width="580" Height="760"
+        Width="580" Height="760" MinWidth="480" MinHeight="520"
-        WindowDecorations="None"
+        CanResize="True"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
 
@@ -73,6 +75,14 @@
                             HorizontalAlignment="Stretch"/>
                 </StackPanel>
               </Grid>
+              <StackPanel Spacing="4">
+                <TextBlock Classes="field-label" Text="Max parallel executions"/>
+                <NumericUpDown Value="{Binding General.MaxParallelExecutions, Mode=TwoWay}"
+                               Minimum="1" Maximum="20" Increment="1" FormatString="0"
+                               HorizontalAlignment="Left" Width="140"/>
+                <TextBlock Text="How many queued tasks the worker runs at once."
+                           Opacity="0.6" FontSize="12"/>
+              </StackPanel>
             </StackPanel>
           </ScrollViewer>
         </TabItem>

src/ClaudeDo.Ui/Views/Modals/WorktreesOverviewModalView.axaml

@@ -11,7 +11,8 @@
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}"
         WindowDecorations="BorderOnly"
-        ExtendClientAreaToDecorationsHint="True">
+        ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1">
 
   <Window.Resources>
     <converters:WorktreeStateColorConverter x:Key="WorktreeStateColor"/>

src/ClaudeDo.Ui/Views/Planning/ConflictResolutionView.axaml

@@ -5,9 +5,11 @@
         x:DataType="vm:ConflictResolutionViewModel"
         x:Class="ClaudeDo.Ui.Views.Planning.ConflictResolutionView"
         Title="Merge conflict"
-        Width="560" SizeToContent="Height"
+        Width="560" SizeToContent="Height" MinWidth="460"
-        WindowDecorations="None"
+        CanResize="True"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
 

src/ClaudeDo.Ui/Views/Planning/PlanningDiffView.axaml

@@ -5,9 +5,11 @@
         x:Class="ClaudeDo.Ui.Views.Planning.PlanningDiffView"
         x:DataType="vm:PlanningDiffViewModel"
         Title="Planning — Combined diff"
-        Width="1100" Height="700"
+        Width="1100" Height="700" MinWidth="700" MinHeight="450"
-        WindowDecorations="None"
+        CanResize="True"
+        WindowDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
+        ExtendClientAreaTitleBarHeightHint="-1"
         WindowStartupLocation="CenterOwner"
         Background="{DynamicResource SurfaceBrush}">
 

src/ClaudeDo.Worker/External/ExternalMcpService.cs

@@ -1,15 +1,24 @@
 using System.ComponentModel;
+using System.Diagnostics;
+using ClaudeDo.Data;
+using ClaudeDo.Data.Git;
 using ClaudeDo.Data.Models;
 using ClaudeDo.Data.Repositories;
 using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Lifecycle;
 using ClaudeDo.Worker.Queue;
 using ClaudeDo.Worker.State;
+using ClaudeDo.Worker.Worktrees;
+using Microsoft.EntityFrameworkCore;
 using ModelContextProtocol.Server;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
 
 namespace ClaudeDo.Worker.External;
 
 public sealed record TaskListDto(string Id, string Name, string? WorkingDir);
+public sealed record DeleteTaskResult(bool Deleted, string Id);
+public sealed record CancelTaskResult(bool Cancelled, string Id);
+public sealed record StatusValueDto(string Status, string Meaning);
 
 public sealed record TaskDto(
     string Id,
@@ -23,6 +32,23 @@ public sealed record TaskDto(
     DateTime? StartedAt,
     DateTime? FinishedAt);
 
+public sealed record WorktreeInfoDto(
+    string Path, string Branch, string HeadCommit, string BaseCommit,
+    int Ahead, int Behind, bool IsDirty);
+
+public sealed record TaskDiffDto(
+    string Content, IReadOnlyList<string> Files, bool Truncated, int TotalBytes);
+
+public sealed record MergeTaskResultDto(
+    bool Merged, string? MergeCommit, IReadOnlyList<string> Conflicts);
+
+public sealed record WorktreeListItemDto(
+    string? TaskId, string Path, string Branch,
+    string HeadCommit, bool IsDirty, bool MergedIntoMain);
+
+public sealed record CleanupWorktreeResult(
+    bool Removed, string WorktreePath, bool BranchDeleted);
+
 [McpServerToolType]
 public sealed class ExternalMcpService
 {
@@ -31,19 +57,31 @@ public sealed class ExternalMcpService
     private readonly QueueService _queue;
     private readonly HubBroadcaster _broadcaster;
     private readonly ITaskStateService _state;
+    private readonly GitService _git;
+    private readonly IDbContextFactory<ClaudeDoDbContext> _dbFactory;
+    private readonly WorktreeMaintenanceService _maintenance;
+    private readonly TaskMergeService _merge;
 
     public ExternalMcpService(
         TaskRepository tasks,
         ListRepository lists,
         QueueService queue,
         HubBroadcaster broadcaster,
-        ITaskStateService state)
+        ITaskStateService state,
+        GitService git,
+        IDbContextFactory<ClaudeDoDbContext> dbFactory,
+        WorktreeMaintenanceService maintenance,
+        TaskMergeService merge)
     {
         _tasks = tasks;
         _lists = lists;
         _queue = queue;
         _broadcaster = broadcaster;
         _state = state;
+        _git = git;
+        _dbFactory = dbFactory;
+        _maintenance = maintenance;
+        _merge = merge;
     }
 
     [McpServerTool, Description("List all task lists available in ClaudeDo.")]
@@ -53,7 +91,9 @@ public sealed class ExternalMcpService
         return lists.Select(l => new TaskListDto(l.Id, l.Name, l.WorkingDir)).ToList();
     }
 
-    [McpServerTool, Description("List tasks in a given list. Optionally filter by creator (CreatedBy) and/or status.")]
+    [McpServerTool, Description(
+        "List tasks in a given list. Optionally filter by creator (createdBy) and/or status. " +
+        "Valid status values: Idle, Queued, Running, Done, Failed, Cancelled.")]
     public async Task<IReadOnlyList<TaskDto>> ListTasks(
         string listId,
         string? createdBy,
@@ -64,7 +104,8 @@ public sealed class ExternalMcpService
         if (!string.IsNullOrWhiteSpace(status))
         {
             if (!Enum.TryParse<TaskStatus>(status, ignoreCase: true, out var parsed))
-                throw new InvalidOperationException($"Unknown status '{status}'.");
+                throw new InvalidOperationException(
+                    $"Unknown status '{status}'. Valid values: Idle, Queued, Running, Done, Failed, Cancelled.");
             statusFilter = parsed;
         }
 
@@ -78,7 +119,10 @@ public sealed class ExternalMcpService
         return query.Select(ToDto).ToList();
     }
 
-    [McpServerTool, Description("Get a single task by id, including its current status and result.")]
+    [McpServerTool, Description(
+        "Get a single task by id, including its current status and result. " +
+        "Status lifecycle: Idle → Queued → Running → Done | Failed | Cancelled. " +
+        "Done/Failed/Cancelled tasks can be reset to Idle for re-execution.")]
     public async Task<TaskDto> GetTask(string taskId, CancellationToken cancellationToken)
     {
         var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
@@ -90,17 +134,15 @@ public sealed class ExternalMcpService
     public async Task<TaskDto> AddTask(
         string listId,
         string title,
-        string? description,
+        string? description = null,
-        string createdBy,
+        string? createdBy = null,
-        bool queueImmediately,
+        bool queueImmediately = false,
-        CancellationToken cancellationToken)
+        CancellationToken cancellationToken = default)
     {
         if (string.IsNullOrWhiteSpace(listId))
             throw new InvalidOperationException("listId is required.");
         if (string.IsNullOrWhiteSpace(title))
             throw new InvalidOperationException("title is required.");
-        if (string.IsNullOrWhiteSpace(createdBy))
-            throw new InvalidOperationException("createdBy is required.");
 
         var list = await _lists.GetByIdAsync(listId, cancellationToken)
             ?? throw new InvalidOperationException($"List {listId} not found.");
@@ -114,13 +156,12 @@ public sealed class ExternalMcpService
             Status = TaskStatus.Idle,
             CreatedAt = DateTime.UtcNow,
             CommitType = list.DefaultCommitType,
-            CreatedBy = createdBy,
+            CreatedBy = createdBy.NullIfBlank() ?? "mcp",
         };
         await _tasks.AddAsync(entity, cancellationToken);
 
         if (queueImmediately)
         {
-            // Routes through TaskStateService so the queue is woken automatically.
             var enqueue = await _state.EnqueueAsync(entity.Id, cancellationToken);
             if (!enqueue.Ok)
                 throw new InvalidOperationException(enqueue.Reason ?? "Cannot enqueue task.");
@@ -154,14 +195,19 @@ public sealed class ExternalMcpService
         return ToDto(reload);
     }
 
-    [McpServerTool, Description("Update a task's status. Only 'Idle' and 'Queued' are permitted — use RunTaskNow or CancelTask for execution control.")]
+    [McpServerTool, Description(
+        "Update a task's status. Only 'Idle' and 'Queued' are permitted externally — " +
+        "use run_task_now or cancel_task for execution control. " +
+        "Settable: Idle (reset to editable), Queued (enqueue for execution). " +
+        "Full lifecycle: Idle → Queued → Running → Done | Failed | Cancelled.")]
     public async Task<TaskDto> UpdateTaskStatus(
         string taskId,
         string status,
         CancellationToken cancellationToken)
     {
         if (!Enum.TryParse<TaskStatus>(status, ignoreCase: true, out var target))
-            throw new InvalidOperationException($"Unknown status '{status}'.");
+            throw new InvalidOperationException(
+                $"Unknown status '{status}'. Valid values: Idle, Queued, Running, Done, Failed, Cancelled.");
 
         var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
             ?? throw new InvalidOperationException($"Task {taskId} not found.");
@@ -181,7 +227,7 @@ public sealed class ExternalMcpService
 
             default:
                 throw new InvalidOperationException(
-                    $"Status '{target}' is not settable externally. Use RunTaskNow or CancelTask.");
+                    $"Status '{target}' is not settable externally. Use run_task_now or cancel_task.");
         }
 
         var reload = (await _tasks.GetByIdAsync(taskId, cancellationToken))!;
@@ -206,16 +252,16 @@ public sealed class ExternalMcpService
         await _broadcaster.TaskUpdated(taskId);
     }
 
-    [McpServerTool, Description("Cancel a running task. Returns true if the task was running and cancellation was requested.")]
+    [McpServerTool, Description("Cancel a running task. Returns { cancelled: true, id } if the task was running and cancellation was requested; cancelled is false if the task was not running.")]
-    public async Task<bool> CancelTask(string taskId, CancellationToken cancellationToken)
+    public async Task<CancelTaskResult> CancelTask(string taskId, CancellationToken cancellationToken)
     {
         var cancelled = _queue.CancelTask(taskId);
         if (cancelled) await _broadcaster.TaskUpdated(taskId);
-        return cancelled;
+        return new CancelTaskResult(cancelled, taskId);
     }
 
-    [McpServerTool, Description("Delete a task. Refuses if the task is currently Running — cancel it first.")]
+    [McpServerTool, Description("Delete a task. Returns { deleted: true, id } on success. Throws if the task is not found or is currently Running — cancel it first.")]
-    public async Task DeleteTask(string taskId, CancellationToken cancellationToken)
+    public async Task<DeleteTaskResult> DeleteTask(string taskId, CancellationToken cancellationToken)
     {
         var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
             ?? throw new InvalidOperationException($"Task {taskId} not found.");
@@ -224,6 +270,257 @@ public sealed class ExternalMcpService
 
         await _tasks.DeleteAsync(taskId, cancellationToken);
         await _broadcaster.TaskUpdated(taskId);
+        return new DeleteTaskResult(true, taskId);
+    }
+
+    // ── Status reference ─────────────────────────────────────────────────────
+
+    [McpServerTool, Description("Returns all valid task status values and their meanings. Use before filtering by status or interpreting task state.")]
+    public Task<IReadOnlyList<StatusValueDto>> GetTaskStatusValues() =>
+        Task.FromResult<IReadOnlyList<StatusValueDto>>([
+            new("Idle",      "Not yet queued; task is editable and will not run until enqueued."),
+            new("Queued",    "Waiting for an agent execution slot. Tasks with a blocker (BlockedByTaskId) are skipped by the queue picker until their predecessor finishes."),
+            new("Running",   "Agent is actively executing the task; cannot be edited or deleted until cancelled."),
+            new("Done",      "Completed successfully; result text is available in the result field. Can be reset to Idle for re-execution."),
+            new("Failed",    "Execution ended with an error; task can be reset to Idle or re-queued directly."),
+            new("Cancelled", "Cancelled by the user; task can be reset to Idle or re-queued directly."),
+        ]);
+
+    // ── Worktree / git tools ──────────────────────────────────────────────────
+
+    [McpServerTool, Description(
+        "Get git worktree details for a task: path, branch, headCommit (current HEAD SHA), " +
+        "baseCommit (SHA where the branch was created), ahead (commits on branch since base), " +
+        "behind (commits on main not yet on this branch; 0 if 'main' ref is unreachable), " +
+        "isDirty (has uncommitted changes in the worktree directory). " +
+        "Throws if the task or its worktree does not exist.")]
+    public async Task<WorktreeInfoDto> GetTaskWorktree(string taskId, CancellationToken cancellationToken)
+    {
+        var (_, _, wt) = await LoadWorktreeContextAsync(taskId, cancellationToken);
+
+        var headCommit = !string.IsNullOrWhiteSpace(wt.HeadCommit)
+            ? wt.HeadCommit
+            : await TryRunGitAsync(wt.Path, ["rev-parse", "HEAD"], cancellationToken) ?? wt.BaseCommit;
+
+        var isDirty = Directory.Exists(wt.Path) && await _git.HasChangesAsync(wt.Path, cancellationToken);
+        var ahead  = await GitRevListCountAsync(wt.Path, $"{wt.BaseCommit}..HEAD", cancellationToken);
+        var behind = await GitRevListCountAsync(wt.Path, "HEAD..main", cancellationToken);
+
+        return new WorktreeInfoDto(wt.Path, wt.BranchName, headCommit!, wt.BaseCommit, ahead, behind, isDirty);
+    }
+
+    [McpServerTool, Description(
+        "Get the diff for a task's worktree relative to its base commit. " +
+        "stat=false (default): returns the full unified diff, capped at 200 KB (truncated=true when larger). " +
+        "stat=true: returns a --stat summary (changed files with insertion/deletion counts). " +
+        "files always lists the changed file paths regardless of stat mode. " +
+        "totalBytes is the uncapped diff size (useful when truncated=true). " +
+        "Throws if the task has no worktree or the worktree directory is missing from disk.")]
+    public async Task<TaskDiffDto> GetTaskDiff(
+        string taskId, bool stat = false, CancellationToken cancellationToken = default)
+    {
+        var (_, _, wt) = await LoadWorktreeContextAsync(taskId, cancellationToken);
+
+        if (!Directory.Exists(wt.Path))
+            throw new InvalidOperationException($"Worktree directory does not exist on disk: {wt.Path}");
+
+        const int maxBytes = 200 * 1024;
+
+        if (stat)
+        {
+            var diffStat = await _git.DiffStatAsync(wt.Path, wt.BaseCommit, "HEAD", cancellationToken);
+            return new TaskDiffDto(diffStat, ParseDiffStatFileNames(diffStat), false, diffStat.Length);
+        }
+
+        var diff = await _git.GetBranchDiffAsync(wt.Path, wt.BaseCommit, cancellationToken);
+        var files = ParseDiffFileNames(diff);
+
+        if (diff.Length <= maxBytes)
+            return new TaskDiffDto(diff, files, false, diff.Length);
+
+        return new TaskDiffDto(diff[..maxBytes], files, true, diff.Length);
+    }
+
+    [McpServerTool, Description(
+        "Merge a task's worktree branch into targetBranch (default: main). " +
+        "noFf=true (default): always creates a merge commit (--no-ff). " +
+        "dryRun=true: validates preconditions only, does not perform the merge; merged=false in the result means 'not actually merged'. " +
+        "Refuses if task status is not Done (status values: Idle, Queued, Running, Done, Failed, Cancelled). " +
+        "On success: merged=true, mergeCommit contains the new merge commit SHA. " +
+        "On conflict: the merge is cleanly aborted (no half-merged state left); merged=false and conflicts lists the affected files.")]
+    public async Task<MergeTaskResultDto> MergeTask(
+        string taskId,
+        string targetBranch = "main",
+        bool noFf = true,
+        bool dryRun = false,
+        CancellationToken cancellationToken = default)
+    {
+        var task = await _tasks.GetByIdAsync(taskId, cancellationToken)
+            ?? throw new InvalidOperationException($"Task {taskId} not found.");
+        if (task.Status != TaskStatus.Done)
+            throw new InvalidOperationException(
+                $"Task must be Done to merge (current status: {task.Status}). " +
+                "Valid statuses for merge: Done.");
+
+        var list = await _lists.GetByIdAsync(task.ListId, cancellationToken);
+
+        if (dryRun)
+        {
+            using var ctx = _dbFactory.CreateDbContext();
+            var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken)
+                ?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
+            if (wt.State != WorktreeState.Active)
+                throw new InvalidOperationException(
+                    $"Worktree state must be Active to merge (current: {wt.State}).");
+            return new MergeTaskResultDto(false, null, []);
+        }
+
+        var commitMessage = $"Merge task branch for: {task.Title}";
+        var result = await _merge.MergeAsync(
+            taskId, targetBranch, removeWorktree: false, commitMessage, cancellationToken);
+
+        if (result.Status == TaskMergeService.StatusMerged)
+        {
+            string? mergeCommit = null;
+            try
+            {
+                if (!string.IsNullOrWhiteSpace(list?.WorkingDir) && Directory.Exists(list.WorkingDir))
+                    mergeCommit = await _git.RevParseHeadAsync(list.WorkingDir, cancellationToken);
+            }
+            catch { /* mergeCommit is optional */ }
+            return new MergeTaskResultDto(true, mergeCommit, []);
+        }
+
+        if (result.Status == TaskMergeService.StatusConflict)
+            return new MergeTaskResultDto(false, null, result.ConflictFiles);
+
+        throw new InvalidOperationException(result.ErrorMessage ?? $"Merge blocked: {result.Status}");
+    }
+
+    [McpServerTool, Description(
+        "List all ClaudeDo-tracked worktrees. " +
+        "Each entry: taskId, path, branch, headCommit (empty if path missing on disk), " +
+        "isDirty (has uncommitted changes), mergedIntoMain (worktree state is Merged). " +
+        "Only worktrees recorded in the ClaudeDo database are returned.")]
+    public async Task<IReadOnlyList<WorktreeListItemDto>> ListWorktrees(CancellationToken cancellationToken)
+    {
+        var rows = await _maintenance.GetOverviewAsync(null, cancellationToken);
+        var results = await Task.WhenAll(rows.Select(async row =>
+        {
+            var isDirty = row.PathExistsOnDisk && await TryGetIsDirtyAsync(row.Path, cancellationToken);
+            var headCommit = row.PathExistsOnDisk
+                ? (await TryRunGitAsync(row.Path, ["rev-parse", "HEAD"], cancellationToken) ?? "")
+                : "";
+            return new WorktreeListItemDto(
+                row.TaskId, row.Path, row.BranchName, headCommit,
+                isDirty, row.State == WorktreeState.Merged);
+        }));
+        return results;
+    }
+
+    [McpServerTool, Description(
+        "Remove a task's worktree directory and delete its git branch. " +
+        "force=false (default): refuses if the worktree has uncommitted changes or the task is Running. " +
+        "force=true: removes even a dirty worktree (uncommitted changes are lost); task must not be Running. " +
+        "Returns removed=true on success; branchDeleted reflects whether the branch was also removed.")]
+    public async Task<CleanupWorktreeResult> CleanupTaskWorktree(
+        string taskId, bool force = false, CancellationToken cancellationToken = default)
+    {
+        using var ctx = _dbFactory.CreateDbContext();
+        var task = await new TaskRepository(ctx).GetByIdAsync(taskId, cancellationToken)
+            ?? throw new InvalidOperationException($"Task {taskId} not found.");
+        var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, cancellationToken)
+            ?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
+
+        if (task.Status == TaskStatus.Running)
+            throw new InvalidOperationException("Cannot remove worktree of a running task.");
+
+        if (!force && Directory.Exists(wt.Path))
+        {
+            var isDirty = await _git.HasChangesAsync(wt.Path, cancellationToken);
+            if (isDirty)
+                throw new InvalidOperationException(
+                    "Worktree has uncommitted changes. Use force=true to remove anyway (changes will be lost).");
+        }
+
+        var path = wt.Path;
+        var result = await _maintenance.ForceRemoveAsync(taskId, cancellationToken);
+        return new CleanupWorktreeResult(result.Removed, path, result.Removed);
+    }
+
+    // ── Private helpers ───────────────────────────────────────────────────────
+
+    private async Task<(TaskEntity Task, ListEntity List, WorktreeEntity Wt)> LoadWorktreeContextAsync(
+        string taskId, CancellationToken ct)
+    {
+        using var ctx = _dbFactory.CreateDbContext();
+        var task = await new TaskRepository(ctx).GetByIdAsync(taskId, ct)
+            ?? throw new InvalidOperationException($"Task {taskId} not found.");
+        var list = await new ListRepository(ctx).GetByIdAsync(task.ListId, ct)
+            ?? throw new InvalidOperationException("List not found.");
+        var wt = await new WorktreeRepository(ctx).GetByTaskIdAsync(taskId, ct)
+            ?? throw new InvalidOperationException($"Task {taskId} has no worktree.");
+        return (task, list, wt);
+    }
+
+    private async Task<bool> TryGetIsDirtyAsync(string path, CancellationToken ct)
+    {
+        try { return await _git.HasChangesAsync(path, ct); }
+        catch { return false; }
+    }
+
+    // Minimal git runner for operations not covered by GitService (rev-list --count, rev-parse from worktree).
+    private static async Task<string?> TryRunGitAsync(string dir, string[] args, CancellationToken ct)
+    {
+        try
+        {
+            var psi = new ProcessStartInfo("git")
+            {
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                CreateNoWindow = true,
+            };
+            psi.ArgumentList.Add("-C");
+            psi.ArgumentList.Add(dir);
+            foreach (var a in args) psi.ArgumentList.Add(a);
+            using var proc = Process.Start(psi)!;
+            await using var _ = ct.Register(() => { try { proc.Kill(entireProcessTree: true); } catch { } });
+            var stdout = await proc.StandardOutput.ReadToEndAsync();
+            await proc.WaitForExitAsync(CancellationToken.None);
+            ct.ThrowIfCancellationRequested();
+            return proc.ExitCode == 0 ? stdout.Trim() : null;
+        }
+        catch (OperationCanceledException) { throw; }
+        catch { return null; }
+    }
+
+    private static async Task<int> GitRevListCountAsync(string dir, string range, CancellationToken ct)
+    {
+        var result = await TryRunGitAsync(dir, ["rev-list", "--count", range], ct);
+        return int.TryParse(result, out var n) ? n : 0;
+    }
+
+    private static IReadOnlyList<string> ParseDiffFileNames(string diff)
+    {
+        var files = new List<string>();
+        foreach (var line in diff.Split('\n'))
+        {
+            var s = line.TrimEnd('\r');
+            if (s.StartsWith("+++ b/", StringComparison.Ordinal))
+                files.Add(s[6..]);
+        }
+        return files;
+    }
+
+    private static IReadOnlyList<string> ParseDiffStatFileNames(string stat)
+    {
+        var files = new List<string>();
+        foreach (var line in stat.Split('\n'))
+        {
+            var idx = line.IndexOf('|');
+            if (idx > 0) files.Add(line[..idx].Trim());
+        }
+        return files;
     }
 
     private static TaskDto ToDto(TaskEntity t) => new(

src/ClaudeDo.Worker/External/RunHistoryMcpTools.cs

@@ -11,6 +11,12 @@ public sealed record RunDto(
     int? ExitCode, int? TurnCount, int? TokensIn, int? TokensOut,
     DateTime? StartedAt, DateTime? FinishedAt);
 
+public sealed record TaskLogResult(
+    bool Available,
+    IReadOnlyList<string> Entries,
+    int TotalLines,
+    bool Truncated);
+
 [McpServerToolType]
 public sealed class RunHistoryMcpTools
 {
@@ -33,26 +39,68 @@ public sealed class RunHistoryMcpTools
         return ToDto(run);
     }
 
-    private const int MaxLogBytes = 256 * 1024;
+    [McpServerTool, Description(
-
+        "Fetch log entries from a task's latest run. " +
-    [McpServerTool, Description("Fetch the raw log output of a task's latest run. Throws if no log is available.")]
+        "Returns { available, entries, totalLines, truncated }. " +
-    public async Task<string> GetTaskLog(string taskId, CancellationToken cancellationToken)
+        "available=false means no log exists yet (task is queued or just started — not an error). " +
+        "entries are the individual lines (NDJSON messages) from Claude's streaming output. " +
+        "Default: returns the last 50 entries (tail=50). " +
+        "tail: override the number of trailing entries to return. " +
+        "offset+limit: return entries starting at position offset (0-based); overrides tail when provided. " +
+        "truncated=true when fewer entries are returned than totalLines.")]
+    public async Task<TaskLogResult> GetTaskLog(
+        string taskId,
+        int? tail = null,
+        int? offset = null,
+        int? limit = null,
+        CancellationToken cancellationToken = default)
     {
-        var run = await _runs.GetLatestByTaskIdAsync(taskId, cancellationToken)
+        var run = await _runs.GetLatestByTaskIdAsync(taskId, cancellationToken);
-            ?? throw new InvalidOperationException($"No runs found for task {taskId}.");
+        if (run is null || string.IsNullOrWhiteSpace(run.LogPath) || !File.Exists(run.LogPath))
-        if (string.IsNullOrWhiteSpace(run.LogPath) || !File.Exists(run.LogPath))
+            return new TaskLogResult(false, [], 0, false);
-            throw new InvalidOperationException("No log available for the latest run.");
 
-        var totalBytes = new FileInfo(run.LogPath).Length;
+        string allText;
-        if (totalBytes <= MaxLogBytes)
+        try
-            return await File.ReadAllTextAsync(run.LogPath, cancellationToken);
+        {
+            await using var fs = new FileStream(
+                run.LogPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            using var reader = new StreamReader(fs);
+            allText = await reader.ReadToEndAsync(cancellationToken);
+        }
+        catch (IOException)
+        {
+            return new TaskLogResult(false, [], 0, false);
+        }
 
-        var buffer = new byte[MaxLogBytes];
+        var lines = allText.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
-        await using var fs = new FileStream(run.LogPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+        var totalLines = lines.Length;
-        fs.Seek(totalBytes - MaxLogBytes, SeekOrigin.Begin);
+
-        var read = await fs.ReadAsync(buffer, cancellationToken);
+        IReadOnlyList<string> entries;
-        var tail = System.Text.Encoding.UTF8.GetString(buffer, 0, read);
+        bool truncated;
-        return $"[truncated: showing last {MaxLogBytes} of {totalBytes} bytes]\n{tail}";
+
+        if (offset.HasValue || limit.HasValue)
+        {
+            var start = Math.Max(0, offset ?? 0);
+            var count = limit.HasValue ? Math.Min(limit.Value, totalLines - start) : totalLines - start;
+            entries = lines.Skip(start).Take(count).ToArray();
+            truncated = start > 0 || (start + count) < totalLines;
+        }
+        else
+        {
+            var take = tail ?? 50;
+            if (totalLines <= take)
+            {
+                entries = lines;
+                truncated = false;
+            }
+            else
+            {
+                entries = lines[^take..];
+                truncated = true;
+            }
+        }
+
+        return new TaskLogResult(true, entries, totalLines, truncated);
     }
 
     private static RunDto ToDto(TaskRunEntity r) => new(

src/ClaudeDo.Worker/Hub/WorkerHub.cs

@@ -22,6 +22,7 @@ public record AppSettingsDto(
     string DefaultModel,
     int DefaultMaxTurns,
     string DefaultPermissionMode,
+    int MaxParallelExecutions,
     string WorktreeStrategy,
     string? CentralWorktreeRoot,
     bool WorktreeAutoCleanupEnabled,
@@ -202,6 +203,7 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
             row.DefaultModel,
             row.DefaultMaxTurns,
             row.DefaultPermissionMode,
+            row.MaxParallelExecutions,
             row.WorktreeStrategy,
             row.CentralWorktreeRoot,
             row.WorktreeAutoCleanupEnabled,
@@ -219,6 +221,7 @@ public sealed class WorkerHub : Microsoft.AspNetCore.SignalR.Hub
             DefaultModel = dto.DefaultModel ?? ModelRegistry.DefaultAlias,
             DefaultMaxTurns = dto.DefaultMaxTurns,
             DefaultPermissionMode = dto.DefaultPermissionMode ?? PermissionModeRegistry.DefaultMode,
+            MaxParallelExecutions = dto.MaxParallelExecutions,
             WorktreeStrategy = dto.WorktreeStrategy ?? "sibling",
             CentralWorktreeRoot = dto.CentralWorktreeRoot,
             WorktreeAutoCleanupEnabled = dto.WorktreeAutoCleanupEnabled,

src/ClaudeDo.Worker/Program.cs

@@ -204,6 +204,9 @@ if (cfg.ExternalMcpPort > 0)
     externalBuilder.Services.AddSingleton(app.Services.GetRequiredService<WorktreeManager>());
     externalBuilder.Services.AddSingleton(app.Services.GetRequiredService<AgentFileService>());
     externalBuilder.Services.AddSingleton(app.Services.GetRequiredService<TaskResetService>());
+    externalBuilder.Services.AddSingleton(app.Services.GetRequiredService<GitService>());
+    externalBuilder.Services.AddSingleton(app.Services.GetRequiredService<WorktreeMaintenanceService>());
+    externalBuilder.Services.AddSingleton(app.Services.GetRequiredService<TaskMergeService>());
     externalBuilder.Services.AddScoped<ExternalMcpService>();
     externalBuilder.Services.AddScoped<ListMcpTools>();
     externalBuilder.Services.AddScoped<ConfigMcpTools>();

src/ClaudeDo.Worker/Queue/QueueService.cs

@@ -18,7 +18,7 @@ public sealed class QueueService : BackgroundService
     private readonly OverrideSlotService _override;
 
     private readonly object _lock = new();
-    private volatile QueueSlotState? _queueSlot;
+    private readonly Dictionary<string, QueueSlotState> _queueSlots = new();
 
     public QueueService(
         IDbContextFactory<ClaudeDoDbContext> dbFactory,
@@ -41,8 +41,11 @@ public sealed class QueueService : BackgroundService
     public IReadOnlyList<(string slot, string taskId, DateTime startedAt)> GetActive()
     {
         var list = new List<(string, string, DateTime)>();
-        var q = _queueSlot;
+        lock (_lock)
-        if (q is not null) list.Add(("queue", q.TaskId, q.StartedAt));
+        {
+            foreach (var slot in _queueSlots.Values)
+                list.Add(("queue", slot.TaskId, slot.StartedAt));
+        }
         var o = _override.CurrentSlot;
         if (o is not null) list.Add(("override", o.TaskId, o.StartedAt));
         return list;
@@ -64,7 +67,7 @@ public sealed class QueueService : BackgroundService
     {
         lock (_lock)
         {
-            if (_queueSlot?.TaskId == taskId)
+            if (_queueSlots.ContainsKey(taskId))
                 throw new InvalidOperationException("task is already running in queue slot");
         }
     }
@@ -75,9 +78,9 @@ public sealed class QueueService : BackgroundService
 
         lock (_lock)
         {
-            if (_queueSlot is not null && _queueSlot.TaskId == taskId)
+            if (_queueSlots.TryGetValue(taskId, out var slot))
             {
-                _queueSlot.Cts.Cancel();
+                slot.Cts.Cancel();
                 return true;
             }
         }
@@ -100,26 +103,33 @@ public sealed class QueueService : BackgroundService
 
                 await Task.WhenAny(wakeTask, timerTask);
 
-                if (_queueSlot is not null) continue;
+                var maxParallel = await GetMaxParallelAsync(stoppingToken);
 
-                var task = await _picker.ClaimNextAsync(DateTime.UtcNow, stoppingToken);
+                // Fill as many free slots as the limit allows.
-                if (task is null) continue;
+                while (!stoppingToken.IsCancellationRequested)
-
-                lock (_lock)
                 {
-                    if (_queueSlot is not null) continue;
+                    lock (_lock)
-
-                    var cts = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
-                    _queueSlot = new QueueSlotState { TaskId = task.Id, StartedAt = DateTime.UtcNow, Cts = cts };
-
-                    _ = RunInSlotAsync(task.Id, cts.Token).ContinueWith(t =>
                     {
-                        if (t.IsFaulted)
+                        if (_queueSlots.Count >= maxParallel) break;
-                            _logger.LogError(t.Exception, "RunInSlotAsync failed for task {TaskId} in queue slot", task.Id);
+                    }
-                        lock (_lock) { _queueSlot = null; }
+
-                        cts.Dispose();
+                    var task = await _picker.ClaimNextAsync(DateTime.UtcNow, stoppingToken);
-                        _waker.Wake(); // Check for next task immediately.
+                    if (task is null) break;
-                    }, TaskScheduler.Default);
+
+                    lock (_lock)
+                    {
+                        var cts = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken);
+                        _queueSlots[task.Id] = new QueueSlotState { TaskId = task.Id, StartedAt = DateTime.UtcNow, Cts = cts };
+
+                        _ = RunInSlotAsync(task.Id, cts.Token).ContinueWith(t =>
+                        {
+                            if (t.IsFaulted)
+                                _logger.LogError(t.Exception, "RunInSlotAsync failed for task {TaskId} in queue slot", task.Id);
+                            lock (_lock) { _queueSlots.Remove(task.Id); }
+                            cts.Dispose();
+                            _waker.Wake(); // Check for next task immediately.
+                        }, TaskScheduler.Default);
+                    }
                 }
             }
             catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
@@ -135,6 +145,21 @@ public sealed class QueueService : BackgroundService
         _logger.LogInformation("QueueService stopping");
     }
 
+    private async Task<int> GetMaxParallelAsync(CancellationToken ct)
+    {
+        try
+        {
+            using var context = _dbFactory.CreateDbContext();
+            var settings = await new AppSettingsRepository(context).GetAsync(ct);
+            return Math.Max(1, settings.MaxParallelExecutions);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to read max parallel executions; defaulting to 1");
+            return 1;
+        }
+    }
+
     private async Task RunInSlotAsync(string taskId, CancellationToken ct)
     {
         try

src/ClaudeDo.Worker/Runner/StreamAnalyzer.cs

@@ -44,6 +44,14 @@ public sealed class StreamAnalyzer
                         _structuredOutputJson = structuredProp.ToString();
                     if (root.TryGetProperty("session_id", out var sessionProp))
                         _sessionId = sessionProp.GetString();
+                    // Authoritative token totals live on the result event.
+                    if (root.TryGetProperty("usage", out var resultUsage))
+                    {
+                        if (resultUsage.TryGetProperty("input_tokens", out var inp))
+                            _tokensIn = inp.GetInt32();
+                        if (resultUsage.TryGetProperty("output_tokens", out var outp))
+                            _tokensOut = outp.GetInt32();
+                    }
                     break;
 
                 case "assistant":
@@ -66,7 +74,7 @@ public sealed class StreamAnalyzer
 
     public StreamResult GetResult() => new()
     {
-        ResultMarkdown = _resultMarkdown,
+        ResultMarkdown = FallbackResult(),
         StructuredOutputJson = _structuredOutputJson,
         SessionId = _sessionId,
         TurnCount = _turnCount,
@@ -75,6 +83,20 @@ public sealed class StreamAnalyzer
         ApiRetryCount = _apiRetryCount,
     };
 
+    private string? FallbackResult()
+    {
+        if (!string.IsNullOrEmpty(_resultMarkdown)) return _resultMarkdown;
+        if (_structuredOutputJson is null) return _resultMarkdown;
+        try
+        {
+            using var doc = JsonDocument.Parse(_structuredOutputJson);
+            if (doc.RootElement.TryGetProperty("summary", out var s))
+                return s.GetString();
+        }
+        catch { }
+        return _structuredOutputJson;
+    }
+
     private void TryAccumulateUsage(JsonElement root)
     {
         if (!root.TryGetProperty("event", out var eventProp)) return;

src/ClaudeDo.Worker/Runner/TaskRunner.cs

@@ -238,6 +238,11 @@ public sealed class TaskRunner
         {
             var runRepo = new TaskRunRepository(context);
             await runRepo.AddAsync(run, ct);
+
+            // Point the task at this run's log immediately so the UI can replay
+            // live output when the user navigates away and back mid-run.
+            var taskRepo = new TaskRepository(context);
+            await taskRepo.SetLogPathAsync(taskId, logPath, ct);
         }
 
         await _broadcaster.RunCreated(taskId, runNumber, isRetry);
@@ -277,9 +282,6 @@ public sealed class TaskRunner
             {
                 var runRepo = new TaskRunRepository(context);
                 await runRepo.UpdateAsync(run, CancellationToken.None);
-
-                var taskRepo = new TaskRepository(context);
-                await taskRepo.SetLogPathAsync(taskId, logPath, CancellationToken.None);
             }
 
             return result;
@@ -296,9 +298,6 @@ public sealed class TaskRunner
                 using var context = _dbFactory.CreateDbContext();
                 var runRepo = new TaskRunRepository(context);
                 await runRepo.UpdateAsync(run, CancellationToken.None);
-
-                var taskRepo = new TaskRepository(context);
-                await taskRepo.SetLogPathAsync(taskId, logPath, CancellationToken.None);
             }
             catch (Exception updateEx)
             {

tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs

@@ -5,10 +5,12 @@ using ClaudeDo.Data.Repositories;
 using ClaudeDo.Worker.Config;
 using ClaudeDo.Worker.External;
 using ClaudeDo.Worker.Hub;
+using ClaudeDo.Worker.Lifecycle;
 using ClaudeDo.Worker.Queue;
 using ClaudeDo.Worker.Runner;
 using ClaudeDo.Worker.Tests.Infrastructure;
 using ClaudeDo.Worker.Tests.Services;
+using ClaudeDo.Worker.Worktrees;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.Extensions.Logging.Abstractions;
 using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
@@ -87,9 +89,17 @@ public sealed class ExternalMcpServiceTests : IDisposable
         return task;
     }
 
-    private ExternalMcpService BuildSut(QueueService queue) =>
+    private ExternalMcpService BuildSut(QueueService queue)
-        new(_tasks, _lists, queue, _broadcaster,
+    {
-            TaskStateServiceBuilder.Build(_db.CreateFactory()).State);
+        var git = new GitService();
+        var factory = _db.CreateFactory();
+        var maintenance = new WorktreeMaintenanceService(factory, git, NullLogger<WorktreeMaintenanceService>.Instance);
+        var merge = new TaskMergeService(factory, git, _broadcaster, NullLogger<TaskMergeService>.Instance);
+        return new ExternalMcpService(
+            _tasks, _lists, queue, _broadcaster,
+            TaskStateServiceBuilder.Build(factory).State,
+            git, factory, maintenance, merge);
+    }
 
     private QueueService CreateQueue()
     {

tests/ClaudeDo.Worker.Tests/External/RunHistoryMcpToolsTests.cs

@@ -54,13 +54,16 @@ public sealed class RunHistoryMcpToolsTests : IDisposable
     }
 
     [Fact]
-    public async Task GetTaskLog_NoLog_Throws()
+    public async Task GetTaskLog_NoRun_ReturnsUnavailable()
     {
         var taskId = Guid.NewGuid().ToString();
         await SeedTaskAsync(taskId);
 
-        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+        var result = await _sut.GetTaskLog(taskId, cancellationToken: CancellationToken.None);
-            _sut.GetTaskLog(taskId, CancellationToken.None));
+
+        Assert.False(result.Available);
+        Assert.Empty(result.Entries);
+        Assert.Equal(0, result.TotalLines);
     }
 
     [Fact]
@@ -69,24 +72,26 @@ public sealed class RunHistoryMcpToolsTests : IDisposable
         var taskId = Guid.NewGuid().ToString();
         await SeedTaskAsync(taskId);
         var logPath = Path.Combine(Path.GetTempPath(), $"claudedo_log_{Guid.NewGuid():N}.txt");
-        await File.WriteAllTextAsync(logPath, "hello log");
+        await File.WriteAllTextAsync(logPath, "line1\nline2\nline3");
         await _runs.AddAsync(new TaskRunEntity
         {
             Id = Guid.NewGuid().ToString(), TaskId = taskId, RunNumber = 1,
             IsRetry = false, Prompt = "p", LogPath = logPath,
         });
 
-        string content;
+        TaskLogResult result;
         try
         {
-            content = await _sut.GetTaskLog(taskId, CancellationToken.None);
+            result = await _sut.GetTaskLog(taskId, cancellationToken: CancellationToken.None);
         }
         finally
         {
             File.Delete(logPath);
         }
 
-        Assert.Equal("hello log", content);
+        Assert.True(result.Available);
+        Assert.Equal(3, result.TotalLines);
+        Assert.Contains("line1", result.Entries);
     }
 
     [Fact]
@@ -97,7 +102,7 @@ public sealed class RunHistoryMcpToolsTests : IDisposable
     }
 
     [Fact]
-    public async Task GetTaskLog_RunExistsButNoLogPath_Throws()
+    public async Task GetTaskLog_RunExistsButNoLogPath_ReturnsUnavailable()
     {
         var taskId = Guid.NewGuid().ToString();
         await SeedTaskAsync(taskId);
@@ -107,22 +112,22 @@ public sealed class RunHistoryMcpToolsTests : IDisposable
             IsRetry = false, Prompt = "p", LogPath = null,
         });
 
-        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+        var result = await _sut.GetTaskLog(taskId, cancellationToken: CancellationToken.None);
-            _sut.GetTaskLog(taskId, CancellationToken.None));
+
+        Assert.False(result.Available);
+        Assert.Empty(result.Entries);
     }
 
     [Fact]
-    public async Task GetTaskLog_LargeFile_ReturnsTruncatedTail()
+    public async Task GetTaskLog_ManyLines_DefaultTailReturnsLast50()
     {
         var taskId = Guid.NewGuid().ToString();
         await SeedTaskAsync(taskId);
         var logPath = Path.Combine(Path.GetTempPath(), $"claudedo_log_{Guid.NewGuid():N}.txt");
 
-        // Write 300 KB so it exceeds the 256 KB cap
+        // Write 108 lines (the observed real-world size that exceeded token limits)
-        var chunk = new string('A', 1024);
+        var lines = Enumerable.Range(1, 108).Select(i => $"{{\"line\":{i}}}");
-        await using (var w = new StreamWriter(logPath, append: false))
+        await File.WriteAllLinesAsync(logPath, lines);
-            for (var i = 0; i < 300; i++)
-                await w.WriteAsync(chunk);
 
         await _runs.AddAsync(new TaskRunEntity
         {
@@ -130,17 +135,84 @@ public sealed class RunHistoryMcpToolsTests : IDisposable
             IsRetry = false, Prompt = "p", LogPath = logPath,
         });
 
-        string content;
+        TaskLogResult result;
         try
         {
-            content = await _sut.GetTaskLog(taskId, CancellationToken.None);
+            result = await _sut.GetTaskLog(taskId, cancellationToken: CancellationToken.None);
         }
         finally
         {
             File.Delete(logPath);
         }
 
-        Assert.StartsWith("[truncated:", content);
+        Assert.True(result.Available);
-        Assert.True(content.Length < 300 * 1024);
+        Assert.True(result.Truncated);
+        Assert.Equal(108, result.TotalLines);
+        Assert.Equal(50, result.Entries.Count);
+        Assert.Contains("{\"line\":108}", result.Entries);    // last line is present
+        Assert.DoesNotContain("{\"line\":1}", result.Entries); // first line is not
+    }
+
+    [Fact]
+    public async Task GetTaskLog_TailParam_ReturnsRequestedCount()
+    {
+        var taskId = Guid.NewGuid().ToString();
+        await SeedTaskAsync(taskId);
+        var logPath = Path.Combine(Path.GetTempPath(), $"claudedo_log_{Guid.NewGuid():N}.txt");
+        var lines = Enumerable.Range(1, 20).Select(i => $"line{i}");
+        await File.WriteAllLinesAsync(logPath, lines);
+
+        await _runs.AddAsync(new TaskRunEntity
+        {
+            Id = Guid.NewGuid().ToString(), TaskId = taskId, RunNumber = 1,
+            IsRetry = false, Prompt = "p", LogPath = logPath,
+        });
+
+        TaskLogResult result;
+        try
+        {
+            result = await _sut.GetTaskLog(taskId, tail: 5, cancellationToken: CancellationToken.None);
+        }
+        finally
+        {
+            File.Delete(logPath);
+        }
+
+        Assert.True(result.Available);
+        Assert.True(result.Truncated);
+        Assert.Equal(5, result.Entries.Count);
+        Assert.Equal("line20", result.Entries[^1]);
+    }
+
+    [Fact]
+    public async Task GetTaskLog_OffsetLimit_ReturnsSlice()
+    {
+        var taskId = Guid.NewGuid().ToString();
+        await SeedTaskAsync(taskId);
+        var logPath = Path.Combine(Path.GetTempPath(), $"claudedo_log_{Guid.NewGuid():N}.txt");
+        var lines = Enumerable.Range(1, 10).Select(i => $"line{i}");
+        await File.WriteAllLinesAsync(logPath, lines);
+
+        await _runs.AddAsync(new TaskRunEntity
+        {
+            Id = Guid.NewGuid().ToString(), TaskId = taskId, RunNumber = 1,
+            IsRetry = false, Prompt = "p", LogPath = logPath,
+        });
+
+        TaskLogResult result;
+        try
+        {
+            result = await _sut.GetTaskLog(taskId, offset: 2, limit: 3, cancellationToken: CancellationToken.None);
+        }
+        finally
+        {
+            File.Delete(logPath);
+        }
+
+        Assert.True(result.Available);
+        Assert.Equal(3, result.Entries.Count);
+        Assert.Equal("line3", result.Entries[0]);
+        Assert.Equal("line5", result.Entries[^1]);
+        Assert.True(result.Truncated);
     }
 }

tests/ClaudeDo.Worker.Tests/Runner/StreamAnalyzerTests.cs

@@ -79,4 +79,45 @@ public sealed class StreamAnalyzerTests
         Assert.Null(result.ResultMarkdown);
         Assert.Null(result.SessionId);
     }
+
+    [Fact]
+    public void Token_Usage_From_Result_Event()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"result","result":"done","session_id":"s1","usage":{"input_tokens":150,"output_tokens":75,"cache_read_input_tokens":0}}""");
+        var result = analyzer.GetResult();
+        Assert.Equal(150, result.TokensIn);
+        Assert.Equal(75, result.TokensOut);
+    }
+
+    [Fact]
+    public void Result_Usage_Overrides_Stream_Event_Accumulation()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"stream_event","event":{"type":"message_start","message":{"usage":{"input_tokens":10,"output_tokens":5}}}}""");
+        analyzer.ProcessLine("""{"type":"result","result":"done","session_id":"s1","usage":{"input_tokens":200,"output_tokens":90}}""");
+        var result = analyzer.GetResult();
+        Assert.Equal(200, result.TokensIn);
+        Assert.Equal(90, result.TokensOut);
+    }
+
+    [Fact]
+    public void Empty_Result_Falls_Back_To_Structured_Output_Summary()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"result","result":"","structured_output":{"summary":"Task completed successfully.","data":{}},"session_id":"s1"}""");
+        var result = analyzer.GetResult();
+        Assert.Equal("Task completed successfully.", result.ResultMarkdown);
+        Assert.Contains("summary", result.StructuredOutputJson);
+    }
+
+    [Fact]
+    public void Empty_Result_Falls_Back_To_Full_Json_When_No_Summary()
+    {
+        var analyzer = new StreamAnalyzer();
+        analyzer.ProcessLine("""{"type":"result","result":"","structured_output":{"output":"42"},"session_id":"s1"}""");
+        var result = analyzer.GetResult();
+        Assert.Contains("output", result.ResultMarkdown);
+        Assert.Contains("42", result.ResultMarkdown);
+    }
 }