feat(planning): let CreateChildTask set maxTurns on child tasks

Planning sessions could already steer a subtask's model but not its turn
budget, so a visibly large subtask would still die at the global default
turn limit. maxTurns is optional (default null = inherit list/global
default, matching model); 0/negative values are rejected as invalid input,
consistent with the existing model-alias validation.

src/ClaudeDo.Data/PromptFiles.cs

@@ -168,6 +168,12 @@ public static class PromptFiles
         - sonnet — normal coding work; the sensible default when unsure.
         - opus — only for genuinely complex, cross-cutting, or hard-to-debug work.
         Do not default everything to opus — most subtasks are haiku or sonnet.
+
+        Only for a subtask you can tell will need noticeably more turns than the
+        default budget (a large or sprawling piece of work), also pass CreateChildTask's
+        `maxTurns` argument with a generous turn count, so the run doesn't die mid-work
+        at the turn limit. Leave `maxTurns` null for everything else — it inherits the
+        list/global default.
         """;
 
     private const string PlanningInitialDefault = """

src/ClaudeDo.Data/Repositories/TaskRepository.cs

@@ -276,8 +276,12 @@ public sealed class TaskRepository
         string? commitType,
         string? createdBy = null,
         string? model = null,
+        int? maxTurns = null,
         CancellationToken ct = default)
     {
+        if (maxTurns.HasValue && maxTurns.Value <= 0)
+            throw new ArgumentException($"maxTurns must be positive, got {maxTurns.Value}.");
+
         // AsNoTracking: SetPlanningStartedAsync mutates via ExecuteUpdate which
         // bypasses the change tracker; a tracked Find would return stale data.
         var parent = await _context.Tasks.AsNoTracking()
@@ -303,6 +307,7 @@ public sealed class TaskRepository
             SortOrder = (maxSort ?? -1) + 1,
             CreatedBy = createdBy,
             Model = ModelRegistry.NormalizeAlias(model),
+            MaxTurns = maxTurns,
         };
         _context.Tasks.Add(child);
         await _context.SaveChangesAsync(ct);

src/ClaudeDo.Worker/CLAUDE.md

@@ -184,7 +184,7 @@ Loaded from `~/.todo-app/worker.config.json`:
   - The refresh token is NOT in this file — stored encrypted via DPAPI at `~/.todo-app/online-inbox.token`
 - `usage_poll_interval_seconds` (default 60, clamped to a minimum of 15 on load) — poll interval for `UsageMonitorService`
 
-Per-list config (`list_config` in DB) provides defaults for `model`, `system_prompt`, `agent_path`; tasks can override each individually. Task-generating MCP tools (`AddTask`, planning `CreateChildTask`, `SuggestImprovement`) accept an optional `model` (alias-validated via `ModelRegistry.NormalizeAlias` — `haiku`/`sonnet`/`opus`, blank = inherit) so Claude assigns the cheapest capable model at creation time; the planning/system/improvement prompts instruct it to do so (`ModelRegistry.ByCostAscending` = the cost order).
+Per-list config (`list_config` in DB) provides defaults for `model`, `system_prompt`, `agent_path`; tasks can override each individually. Task-generating MCP tools (`AddTask`, planning `CreateChildTask`, `SuggestImprovement`) accept an optional `model` (alias-validated via `ModelRegistry.NormalizeAlias` — `haiku`/`sonnet`/`opus`, blank = inherit) so Claude assigns the cheapest capable model at creation time; the planning/system/improvement prompts instruct it to do so (`ModelRegistry.ByCostAscending` = the cost order). Planning's `CreateChildTask` additionally accepts an optional `maxTurns` (positive int; `0`/negative rejected with `ArgumentException`, null = inherit list/global default) so the planner can raise the turn budget for a subtask it knows will run long; `SuggestImprovement`/`AddTask` do not expose it.
 
 ## Notes
 

src/ClaudeDo.Worker/Planning/PlanningMcpService.cs

@@ -41,16 +41,18 @@ public sealed class PlanningMcpService
         "Create a new draft child task under the current planning session's parent task. " +
         "Set model to the cheapest model that can do this subtask well — 'haiku' for trivial/mechanical " +
         "work, 'sonnet' for normal coding (the default), 'opus' only for complex or cross-cutting work. " +
-        "Leave model null to inherit the list/global default.")]
+        "Leave model null to inherit the list/global default. Set maxTurns only when this subtask is " +
+        "visibly larger than the default turn budget; leave it null to inherit the list/global default.")]
     public async Task<CreatedChildDto> CreateChildTask(
         string title,
         string? description,
         string? commitType,
         string? model,
-        CancellationToken cancellationToken)
+        int? maxTurns = null,
+        CancellationToken cancellationToken = default)
     {
         var ctx = _contextAccessor.Current;
-        var child = await _tasks.CreateChildAsync(ctx.ParentTaskId, title, description, commitType, createdBy: null, model: model, ct: cancellationToken);
+        var child = await _tasks.CreateChildAsync(ctx.ParentTaskId, title, description, commitType, createdBy: null, model: model, maxTurns: maxTurns, ct: cancellationToken);
         await BroadcastTaskUpdatedAsync(child.Id, cancellationToken);
         await BroadcastTaskUpdatedAsync(ctx.ParentTaskId, cancellationToken);
         return new CreatedChildDto(child.Id, child.Status.ToString());