Method createMany

src/node/services/taskService.ts:2179–2507

(
    argsList: TaskCreateArgs[],
    options: TaskCreateManyOptions = {}
  )

  }

  async createMany(
    argsList: TaskCreateArgs[],
    options: TaskCreateManyOptions = {}
  ): Promise<Result<TaskCreateResult[], string>> {
    if (argsList.length === 0) {
      return Ok([]);
    }

    // sharedWorkspacePath is set for honored isolation: "none" plans; the entry is persisted
    // pointing at the parent's checkout and startReservedAgentTask reuses it without fork/init.
    const plans: Array<
      TaskLaunchPlan & { status: "queued" | "starting"; sharedWorkspacePath?: string }
    > = [];
    const results: TaskCreateResult[] = [];

    await using _lock = await this.mutex.acquire();

    const cfg = this.config.loadConfigOrDefault();
    const taskSettings = cfg.taskSettings ?? DEFAULT_TASK_SETTINGS;
    let reservedActiveCount =
      this.countActiveAgentTasks(cfg) + (await this.countActiveWorkspaceTurns());

    for (const args of argsList) {
      const parentWorkspaceId = coerceNonEmptyString(args.parentWorkspaceId);
      if (!parentWorkspaceId) return Err("Task.createMany: parentWorkspaceId is required");
      if (args.kind !== "agent") return Err("Task.createMany: unsupported kind");

      const prompt = coerceNonEmptyString(args.prompt);
      if (!prompt) return Err("Task.createMany: prompt is required");

      const normalizedAgentId = normalizeAgentId(args.agentId ?? args.agentType, "");
      if (!normalizedAgentId) return Err("Task.createMany: agentId is required");
      const parsedAgentId = AgentIdSchema.safeParse(normalizedAgentId);
      if (!parsedAgentId.success) {
        return Err(`Task.createMany: invalid agentId (${normalizedAgentId})`);
      }
      const agentId = parsedAgentId.data;
      const agentType = agentId;

      let normalizedBestOf: TaskCreateArgs["bestOf"];
      const bestOf = args.bestOf;
      if (bestOf) {
        const groupId = coerceNonEmptyString(bestOf.groupId);
        if (!groupId)
          return Err("Task.createMany: bestOf.groupId is required when bestOf is provided");
        if (!Number.isInteger(bestOf.index) || bestOf.index < 0) {
          return Err("Task.createMany: bestOf.index must be a non-negative integer");
        }
        if (!Number.isInteger(bestOf.total) || bestOf.total < 2) {
          return Err("Task.createMany: bestOf.total must be an integer >= 2");
        }
        if (bestOf.index >= bestOf.total) {
          return Err("Task.createMany: bestOf.index must be less than bestOf.total");
        }
        const kind = normalizeTaskGroupKind(bestOf.kind);
        const label = normalizeTaskGroupLabel(bestOf.label);
        if (kind === TASK_GROUP_KIND.VARIANTS && !label) {
          return Err("Task.createMany: bestOf.label is required when bestOf.kind is variants");