Function apply

packages/arctic/src/session/benchmark.ts:222–274

(input: { sessionID: string; targetSessionID?: string; allowDirty?: boolean })

   * 2. Restore AI's exact file states to workspace
   */
  export async function apply(input: { sessionID: string; targetSessionID?: string; allowDirty?: boolean }) {
    return withWorktreeLock(async () => {
      const child = await resolveChild(input.sessionID, input.targetSessionID)
      if (!child) return Session.get(input.sessionID)
      const parent = await Session.get(child.benchmark.parentID)
      if (!isParent(parent) || !parent.benchmark.enabled) return parent

      const dirty = await isDirty()
      if (!input.allowDirty && dirty) {
        throw new WorkingTreeDirtyError({ message: "Working tree has uncommitted changes." })
      }

      const childSnapshot = child.benchmark.lastSnapshot ?? (await latestSnapshot(child.id))
      if (!childSnapshot) {
        throw new SnapshotUnavailableError({
          message: "No snapshot available for this benchmark session.",
        })
      }

      // Step 1: Create checkpoint of current workspace state
      const checkpoint = await Snapshot.track()
      if (!checkpoint) {
        throw new SnapshotUnavailableError({
          message: "Benchmark mode requires snapshots (git) to be enabled.",
        })
      }

      const currentAppliedID = parent.benchmark.appliedSessionID

      // If we are currently in a child session, save its state before switching
      if (currentAppliedID) {
        const currentChild = await Session.get(currentAppliedID)
        if (isChild(currentChild) && currentChild.benchmark.parentID === parent.id) {
          await updateChildSnapshot(currentChild.id, checkpoint)
          const currentWorktree = await ensureChildWorktree(parent, currentChild)
          await Snapshot.restoreTo(checkpoint, currentWorktree, { cleanUntracked: true })
        }
      }

      // Step 2: Restore AI's exact file states to workspace
      await Snapshot.restoreTo(childSnapshot, Instance.worktree, { cleanUntracked: true })

      return Session.update(parent.id, (draft) => {
        if (draft.benchmark?.type === "parent") {
          draft.benchmark.appliedSessionID = child.id
          // Only update checkpointSnapshot if we are switching from the parent session
          if (!currentAppliedID) {
            draft.benchmark.checkpointSnapshot = checkpoint
          }
        }
      })
    })
  }

  /**
   * Undo applied benchmark changes.