type Mode = 'task' | 'overview'; /** * How to size the grouping, given what the project can actually run at once. * * The prompt used to say one group of everything is "preferred" with no * mention of concurrency, which is right for tokens and wrong for wall-clock: * a project set to run 4 groups at once still got a single 17-task session, so * the multi-agent setting bought nothing. This is where the real cap enters the * prompt — otherwise "prefer fewer, larger groups" always wins, because nothing * in the planner's context says a split group would actually overlap. * * `null`/absent means concurrency is unavailable (switch off, or a cap of 1), * which is the historical behaviour preserved exactly. */ export declare function groupingGuidance(parallelCap: number | null | undefined): string; /** * One planner-decided combined run. `mode` / `dependsOn` / `workers` are * optional on purpose: a bridge older than the backend simply drops them and * the batch runs sequentially, exactly as it did before this existed. */ interface PlannerGroup { name?: string; taskIds: string[]; /** Default "combined" (one group at a time). "parallel" fans out. */ mode?: 'combined' | 'parallel'; /** Names of groups that must complete first. */ dependsOn?: string[]; /** Hint only — the backend clamps it to the project cap. */ workers?: number; workerAgentId?: string; workerHint?: string; } /** One group inside a stage (2026-11). */ interface PlannerStageGroup { key?: string; name?: string; taskIds: string[]; mode?: 'combined' | 'parallel'; workerAgentId?: string; workerHint?: string; workers?: number; } /** One ordered barrier of groups. */ interface PlannerStage { key?: string; name?: string; groups: PlannerStageGroup[]; maxWorkers?: number; failurePolicy?: 'halt' | 'continue'; } interface PlannerEdge { fromGroup: string; toGroup: string; } interface PlanResult { tasks: Array<{ title: string; description: string; dependencies: number[]; verification: string[]; }>; orderedTaskIds: string[]; dependencies: Array<[string, string]>; /** Overview mode: the planner's decided combined-run grouping. */ groups?: PlannerGroup[]; /** Overview mode: the planner's ordered barrier plan (2026-11). */ stages?: PlannerStage[]; /** Extra edges beyond the barrier. */ edges?: PlannerEdge[]; planMarkdown?: string; acceptanceCriteria?: string; /** Short, structured summary of the whole plan (goal, ordered steps, risks). */ planSummary?: string; /** A better name for the plan/parent task, chosen by the planner. */ planTitle?: string; } export declare function cmdPlanner(flags: Map): Promise; /** * Read + normalize the plan the agent submitted via `submit_plan`. When no * plan was submitted the given queue is preserved untouched (no invented * tasks) so the run still proceeds. * * Exported so the group's concurrency fields (`mode` / `dependsOn` / * `workers`) are unit-tested on THIS side of the wire — rebuilding only * `{name, taskIds}` here is what would make the whole schema expansion a * silent no-op between the MCP tool and the backend. */ export declare function readResultFile(resultPath: string, mode: Mode, queueIds: string[], log: (text: string, level?: 'stdout' | 'stderr') => void): PlanResult; export {};