Function start

packages/arctic/src/session/benchmark.ts:68–149

(input: {
    sessionID: string
    count?: number
    models?: BenchmarkSchema.Model[]
    allowDuplicates?: boolean
  })

  }

  export async function start(input: {
    sessionID: string
    count?: number
    models?: BenchmarkSchema.Model[]
    allowDuplicates?: boolean
  }) {
    let parent = await Session.get(input.sessionID)
    if (isChild(parent)) {
      parent = await Session.get(parent.benchmark.parentID)
    }
    if (isParent(parent)) {
      await stop({ sessionID: parent.id })
    }

    const models = await resolveModels({
      sessionID: parent.id,
      models: input.models,
      count: input.count,
    })

    if (!input.allowDuplicates && hasDuplicates(models)) {
      throw new DuplicateModelsError({
        models: models.map((item) => `${item.providerID}/${item.modelID}`),
      })
    }

    const baseSnapshot = await Snapshot.track()
    if (!baseSnapshot) {
      throw new SnapshotUnavailableError({
        message: "Benchmark mode requires snapshots (git) to be enabled.",
      })
    }

    // Create worktree root directory
    const worktreeRoot = path.join(Global.Path.data, "benchmark", parent.id)
    await fs.mkdir(worktreeRoot, { recursive: true })

    // Create base worktree (+1 worktree for initial codebase)
    const baseWorktree = path.join(worktreeRoot, "base")
    await fs.mkdir(baseWorktree, { recursive: true })
    await Snapshot.restoreTo(baseSnapshot, baseWorktree, { cleanUntracked: true })

    const children: BenchmarkSchema.Child[] = []
    for (const model of models) {
      const title = `Benchmark - ${model.providerID}/${model.modelID} - ${new Date().toISOString()}`
      const childID = Identifier.descending("session")
      const childWorktree = path.join(worktreeRoot, childID)
      const child = await Session.createNext({
        id: childID,
        parentID: parent.id,
        directory: childWorktree,
        title,
      })
      await fs.mkdir(childWorktree, { recursive: true })
      await Snapshot.restoreTo(baseSnapshot, childWorktree, { cleanUntracked: true })
      await Session.update(child.id, (draft) => {
        draft.benchmark = {
          type: "child",