Final deployment for HF with landing page

.dockerignore

@@ -0,0 +1,5 @@
+dist-server/
+cli/
+node_modules/
+plandex-server
+plandex-cloud

.gitattributes

@@ -0,0 +1 @@
+*.sh		text eol=lf

.github/workflows/docker-publish.yml

@@ -0,0 +1,113 @@
+name: Build and publish Docker Image
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch: # enable manual triggering
+
+jobs:
+  check_release:
+    runs-on: ubuntu-latest
+    outputs:
+      should_build: ${{ steps.check_release.outputs.should_build }}
+      tag: ${{ steps.check_release.outputs.tag }}
+    
+    steps:
+      - name: Check release tag and find latest server tag
+        id: check_release
+        run: |
+          if [ "${{ github.event_name }}" == "release" ]; then
+            # This is a release event - check if the tag starts with 'server'
+            if [[ "${{ github.ref_name }}" == server* ]]; then
+              echo "This is a server release: ${{ github.ref_name }}"
+              echo "should_build=true" >> $GITHUB_OUTPUT
+              echo "tag=${{ github.ref_name }}" >> $GITHUB_OUTPUT
+            else
+              echo "This is not a server release. Skipping build."
+              echo "should_build=false" >> $GITHUB_OUTPUT
+            fi
+          else
+            # This is a manual workflow_dispatch event
+            echo "This is a manual workflow trigger. Proceeding to find latest server tag."
+            echo "should_build=true" >> $GITHUB_OUTPUT
+            echo "tag=latest_server" >> $GITHUB_OUTPUT
+          fi
+
+  build_and_push:
+    needs: check_release
+    if: needs.check_release.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out the repo
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0  # Fetch all history and tags
+
+      - name: Find latest server tag
+        id: find_tag
+        if: needs.check_release.outputs.tag == 'latest_server'
+        run: |
+          # Find the latest tag that starts with 'server'
+          LATEST_SERVER_TAG=$(git tag -l "server*" --sort=-creatordate | head -n 1)
+          
+          if [ -z "$LATEST_SERVER_TAG" ]; then
+            echo "No tags starting with 'server' found."
+            echo "skip=true" >> $GITHUB_OUTPUT
+          else
+            echo "Found latest server tag: $LATEST_SERVER_TAG"
+            echo "skip=false" >> $GITHUB_OUTPUT
+            echo "tag=$LATEST_SERVER_TAG" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
+      - name: Set release tag
+        id: set_tag
+        if: needs.check_release.outputs.tag != 'latest_server'
+        run: |
+          echo "skip=false" >> $GITHUB_OUTPUT
+          echo "tag=${{ needs.check_release.outputs.tag }}" >> $GITHUB_OUTPUT
+
+      - name: Skip build if no server tag found
+        if: (steps.find_tag.outputs.skip == 'true' && needs.check_release.outputs.tag == 'latest_server')
+        run: |
+          echo "Skipping build because no tag starting with 'server' was found."
+          exit 1
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Determine tag to use
+        id: determine_tag
+        run: |
+          if [ "${{ needs.check_release.outputs.tag }}" == "latest_server" ]; then
+            TAG="${{ steps.find_tag.outputs.tag }}"
+          else
+            TAG="${{ needs.check_release.outputs.tag }}"
+          fi
+          echo "Using tag: $TAG"
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+
+      - name: Sanitize tag name
+        id: sanitize
+        run: echo "SANITIZED_TAG_NAME=$(echo ${{ steps.determine_tag.outputs.tag }} | tr '/' '-' | tr '+' '-')" >> $GITHUB_OUTPUT
+
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          context: ./app/
+          file: ./app/server/Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            plandexai/plandex-server:${{ steps.sanitize.outputs.SANITIZED_TAG_NAME }}
+            plandexai/plandex-server:latest

.gitignore

@@ -0,0 +1,27 @@
+.plandex/
+.plandex-dev/
+.plandex-v2/
+.plandex-dev-v2/
+.envkey
+.env
+.env.*
+plandex
+plandex-dev
+plandex-server
+*.exe
+node_modules/
+/tools/
+/static/
+/infra/
+/payments-dashboard/
+.DS_Store
+.goreleaser.yml
+dist/
+__pycache__/
+
+.aider.*
+*.code-workspace
+
+__pycache__/
+
+.repo_ignore

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 PlandexAI Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,234 @@
+<h1 align="center">
+ <a href="https://plandex.ai">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="images/plandex-logo-dark-v2.png"/>
+    <source media="(prefers-color-scheme: light)" srcset="images/plandex-logo-light-v2.png"/>
+    <img width="400" src="images/plandex-logo-dark-bg-v2.png"/>
+ </a>
+ <br />
+</h1>
+<br />
+
+<div align="center">
+
+<p align="center">
+  <!-- Call to Action Links -->
+  <a href="#install">
+    <b>30-Second Install</b>
+  </a>
+   ·
+  <a href="https://plandex.ai">
+    <b>Website</b>
+  </a>
+   ·
+  <a href="https://docs.plandex.ai/">
+    <b>Docs</b>
+  </a>
+   ·
+  <a href="#examples-">
+    <b>Examples</b>
+  </a>
+   ·
+  <a href="https://docs.plandex.ai/hosting/self-hosting/local-mode-quickstart">
+    <b>Local Self-Hosted Mode</b>
+  </a>
+</p>
+
+<br>
+
+[![Discord](https://img.shields.io/discord/1214825831973785600.svg?style=flat&logo=discord&label=Discord&refresh=1)](https://discord.gg/plandex-ai)
+[![GitHub Repo stars](https://img.shields.io/github/stars/plandex-ai/plandex?style=social)](https://github.com/plandex-ai/plandex)
+[![Twitter Follow](https://img.shields.io/twitter/follow/PlandexAI?style=social)](https://twitter.com/PlandexAI)
+
+</div>
+
+<p align="center">
+  <!-- Badges -->
+<a href="https://github.com/plandex-ai/plandex/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg" alt="PRs Welcome" /></a> <a href="https://github.com/plandex-ai/plandex/releases?q=cli"><img src="https://img.shields.io/github/v/release/plandex-ai/plandex?filter=cli*" alt="Release" /></a>
+<a href="https://github.com/plandex-ai/plandex/releases?q=server"><img src="https://img.shields.io/github/v/release/plandex-ai/plandex?filter=server*" alt="Release" /></a>
+
+  <!-- <a href="https://github.com/your_username/your_project/issues">
+    <img src="https://img.shields.io/github/issues-closed/your_username/your_project.svg" alt="Issues Closed" />
+  </a> -->
+
+</p>
+
+<br />
+
+<div align="center">
+<a href="https://trendshift.io/repositories/8994" target="_blank"><img src="https://trendshift.io/api/badge/repositories/8994" alt="plandex-ai%2Fplandex | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+</div>
+
+<br>
+
+<h1 align="center" >
+  An AI coding agent designed for large tasks and real world projects.<br/><br/>
+</h1>
+
+<!-- <h2 align="center">
+  Designed for large tasks and real world projects.<br/><br/>
+  </h2> -->
+  <br/>
+
+<div align="center">
+  <a href="https://www.youtube.com/watch?v=SFSu2vNmlLk">
+    <img src="images/plandex-v2-yt.png" alt="Plandex v2 Demo Video" width="800">
+  </a>
+</div>
+
+<br/>
+
+💻  Plandex is a terminal-based AI development tool that can **plan and execute** large coding tasks that span many steps and touch dozens of files. It can handle up to 2M tokens of context directly (~100k per file), and can index directories with 20M tokens or more using tree-sitter project maps.
+
+🔬  **A cumulative diff review sandbox** keeps AI-generated changes separate from your project files until they are ready to go. Command execution is controlled so you can easily roll back and debug. Plandex helps you get the most out of AI without leaving behind a mess in your project.
+
+🧠  **Combine the best models** from Anthropic, OpenAI, Google, and open source providers to build entire features and apps with a robust terminal-based workflow.
+
+🚀  Plandex is capable of <strong>full autonomy</strong>—it can load relevant files, plan and implement changes, execute commands, and automatically debug—but it's also highly flexible and configurable, giving developers fine-grained control and a step-by-step review process when needed.
+
+💪  Plandex is designed to be resilient to <strong>large projects and files</strong>. If you've found that others tools struggle once your project gets past a certain size or the changes are too complex, give Plandex a shot.
+
+## Smart context management that works in big projects
+
+- 🐘 **2M token effective context window** with default model pack. Plandex loads only what's needed for each step.
+
+- 🗄️ **Reliable in large projects and files.** Easily generate, review, revise, and apply changes spanning dozens of files.
+
+- 🗺️ **Fast project map generation** and syntax validation with tree-sitter. Supports 30+ languages.
+
+- 💰 **Context caching** is used across the board for OpenAI, Anthropic, and Google models, reducing costs and latency.
+
+## Tight control or full autonomy—it's up to you
+
+- 🚦 **Configurable autonomy:** go from full auto mode to fine-grained control depending on the task.
+
+- 🐞 **Automated debugging** of terminal commands (like builds, linters, tests, deployments, and scripts). If you have Chrome installed, you can also automatically debug browser applications.
+
+## Tools that help you get production-ready results
+
+- 💬 **A project-aware chat mode** that helps you flesh out ideas before moving to implementation. Also great for asking questions and learning about a codebase.
+
+- 🧠 **Easily try + combine models** from multiple providers. Curated model packs offer different tradeoffs of capability, cost, and speed, as well as open source and provider-specific packs.
+
+- 🛡️ **Reliable file edits** that prioritize correctness. While most edits are quick and cheap, Plandex validates both syntax and logic as needed, with multiple fallback layers when there are problems.
+
+- 🔀 **Full-fledged version control** for every update to the plan, including branches for exploring multiple paths or comparing different models.
+
+- 📂 **Git integration** with commit message generation and optional automatic commits.
+
+## Dev-friendly, easy to install
+
+- 🧑‍💻 **REPL mode** with fuzzy auto-complete for commands and file loading. Just run `plandex` in any project to get started.
+
+- 🛠️ **CLI interface** for scripting or piping data into context.
+
+- 📦 **One-line, zero dependency CLI install**. Dockerized local mode for easily self-hosting the server. Cloud-hosting options for extra reliability and convenience.
+
+## Workflow  🔄
+
+<img src="images/plandex-workflow.png" alt="Plandex workflow" width="100%"/>
+
+## Examples  🎥
+
+  <br/>
+
+<div align="center">
+  <a href="https://www.youtube.com/watch?v=g-_76U_nK0Y">
+    <img src="images/plandex-browser-debug-yt.png" alt="Plandex Browser Debugging Example" width="800">
+  </a>
+</div>
+
+<br/>
+
+## Install  📥
+
+```bash
+curl -sL https://plandex.ai/install.sh | bash
+```
+
+**Note:** Windows is supported via [WSL](https://learn.microsoft.com/en-us/windows/wsl/install). Plandex only works correctly on Windows in the WSL shell. It doesn't work in the Windows CMD prompt or PowerShell.
+
+[More installation options.](https://docs.plandex.ai/install)
+
+## Hosting  ⚖️
+
+| Option                     | Description                                                                                                                                                                                                                                                                                                                                                 |
+| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Plandex Cloud**          | Winding down as of 10/3/2025 and no longer accepting new users. <a href="https://plandex.ai/blog/winding-down">Learn more.</a>                                                                                                                                                                                                                              |
+| **Self-hosted/Local Mode** | • Run Plandex locally with Docker or host on your own server.<br/>• Use your own [OpenRouter.ai](https://openrouter.ai) key (or [other model provider](https://docs.plandex.ai/models/model-providers) accounts and API keys).<br/>• Follow the [local-mode quickstart](https://docs.plandex.ai/hosting/self-hosting/local-mode-quickstart) to get started. |
+
+## Provider keys  🔑
+
+<!-- If you're going with a 'BYO API Key' option above (whether cloud or self-hosted), you'll need to set API keys for the [model providers](https://docs.plandex.ai/models/model-providers) you're using: -->
+
+```bash
+export OPENROUTER_API_KEY=... # if using OpenRouter.ai
+```
+
+<br/>
+
+## Claude Pro/Max subscription  🖇️
+
+If you have a Claude Pro or Max subscription, Plandex can use it when calling Anthropic models. You'll be asked if you want to connect a subscription the first time you run Plandex.
+
+<br/>
+
+## Get started  🚀
+
+First, `cd` into a **project directory** where you want to get something done or chat about the project. Make a new directory first with `mkdir your-project-dir` if you're starting on a new project.
+
+```bash
+cd your-project-dir
+```
+
+For a new project, you might also want to initialize a git repo. Plandex doesn't require that your project is in a git repo, but it does integrate well with git if you use it.
+
+```bash
+git init
+```
+
+Now start the Plandex REPL in your project:
+
+```bash
+plandex
+```
+
+or for short:
+
+```bash
+pdx
+```
+
+<!-- ☁️ _If you're using Plandex Cloud, you'll be prompted at this point to start a trial._
+
+Then just give the REPL help text a quick read, and you're ready go. The REPL starts in _chat mode_ by default, which is good for fleshing out ideas before moving to implementation. Once the task is clear, Plandex will prompt you to switch to _tell mode_ to make a detailed plan and start writing code. -->
+
+<br/>
+
+## Docs  🛠���
+
+### [👉  Full documentation.](https://docs.plandex.ai/)
+
+<br/>
+
+## Discussion and discord  💬
+
+Please feel free to give your feedback, ask questions, report a bug, or just hang out:
+
+- [Discord](https://discord.gg/plandex-ai)
+- [Discussions](https://github.com/plandex-ai/plandex/discussions)
+- [Issues](https://github.com/plandex-ai/plandex/issues)
+
+## Follow and subscribe
+
+- [Follow @PlandexAI](https://x.com/PlandexAI)
+- [Follow @Danenania](https://x.com/Danenania) (Plandex's creator)
+- [Subscribe on YouTube](https://x.com/PlandexAI)
+
+<br/>
+
+## Contributors  👥
+
+⭐️  Please star, fork, explore, and contribute to Plandex. There's a lot of work to do and so much that can be improved.
+
+[Here's an overview on setting up a development environment.](https://docs.plandex.ai/development)

app/.dockerignore

@@ -0,0 +1,2 @@
+cli/
+plandex-server

app/.gitignore

@@ -0,0 +1 @@
+.env

app/clear_local.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+# Get the absolute path to the script's directory, regardless of where it's run from
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+# Change to the app directory if we're not already there
+cd "$SCRIPT_DIR"
+
+echo "WARNING: This will delete all Plandex server data and reset the database."
+echo "This action cannot be undone."
+read -p "Are you sure you want to continue? (y/N) " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]
+then
+    echo "Reset cancelled."
+    exit 1
+fi
+
+echo "Resetting local mode..."
+echo "Stopping containers and removing volumes..."
+
+# Stop containers and remove volumes
+docker compose down -v
+
+echo "Database and data directories cleared. Server stopped."

app/cli/api/clients.go

@@ -0,0 +1,161 @@
+package api
+
+import (
+	"math"
+	"math/rand"
+	"net"
+	"net/http"
+	"os"
+	"plandex-cli/auth"
+	"plandex-cli/types"
+	"time"
+)
+
+const dialTimeout = 10 * time.Second
+const fastReqTimeout = 30 * time.Second
+const slowReqTimeout = 5 * time.Minute
+
+type Api struct{}
+
+var CloudApiHost string
+var Client types.ApiClient = (*Api)(nil)
+
+func init() {
+	if os.Getenv("PLANDEX_ENV") == "development" {
+		CloudApiHost = os.Getenv("PLANDEX_API_HOST")
+		if CloudApiHost == "" {
+			CloudApiHost = "http://localhost:8099"
+		}
+	} else {
+		CloudApiHost = "https://api-v2.plandex.ai"
+	}
+}
+
+func GetApiHost() string {
+	if auth.Current == nil {
+		return CloudApiHost
+	} else if auth.Current.IsCloud {
+		return CloudApiHost
+	} else {
+		return auth.Current.Host
+	}
+}
+
+type authenticatedTransport struct {
+	underlyingTransport http.RoundTripper
+}
+
+func (t *authenticatedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	err := auth.SetAuthHeader(req)
+	if err != nil {
+		return nil, err
+	}
+	auth.SetVersionHeader(req)
+	return t.underlyingTransport.RoundTrip(req)
+}
+
+type unauthenticatedTransport struct {
+	underlyingTransport http.RoundTripper
+}
+
+func (t *unauthenticatedTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	auth.SetVersionHeader(req)
+	return t.underlyingTransport.RoundTrip(req)
+}
+
+type retryTransport struct {
+	Base          http.RoundTripper
+	MaxRetries    int
+	BaseDelay     time.Duration
+	MaxDelay      time.Duration
+	Jitter        time.Duration
+	RetryStatuses map[int]bool
+}
+
+func (t *retryTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	if t.Base == nil {
+		t.Base = http.DefaultTransport
+	}
+	var resp *http.Response
+	var err error
+
+	for attempt := 0; attempt <= t.MaxRetries; attempt++ {
+		resp, err = t.Base.RoundTrip(req)
+
+		// If there's a low-level error (e.g. network), retry unless it's a timeout, as these are often transient.
+		if err != nil {
+			if netErr, ok := err.(net.Error); ok {
+				if netErr.Timeout() {
+					return resp, err
+				}
+			}
+			// continue to next attempt
+		} else {
+			// If status code not in our RetryStatuses, return immediately.
+			if !t.RetryStatuses[resp.StatusCode] {
+				return resp, nil
+			}
+
+			// Close the body before retrying.
+			_ = resp.Body.Close()
+		}
+
+		// If we reached the max, break out of loop (will return last resp).
+		if attempt == t.MaxRetries {
+			break
+		}
+
+		// Exponential backoff + jitter
+		backoff := float64(t.BaseDelay) * math.Pow(2, float64(attempt))
+		if backoff > float64(t.MaxDelay) {
+			backoff = float64(t.MaxDelay)
+		}
+		sleepDuration := time.Duration(backoff) + time.Duration(rand.Int63n(int64(t.Jitter)))
+		time.Sleep(sleepDuration)
+	}
+	return resp, err
+}
+
+var netDialer = &net.Dialer{
+	Timeout: dialTimeout,
+}
+
+var baseTransport = &http.Transport{
+	Dial: netDialer.Dial,
+}
+
+var sharedRetryTransport = &retryTransport{
+	Base:          baseTransport,
+	MaxRetries:    3,
+	BaseDelay:     500 * time.Millisecond,
+	MaxDelay:      5 * time.Second,
+	Jitter:        300 * time.Millisecond,
+	RetryStatuses: map[int]bool{502: true, 503: true, 504: true},
+}
+
+var unauthenticatedClient = &http.Client{
+	Transport: &unauthenticatedTransport{
+		underlyingTransport: sharedRetryTransport,
+	},
+	Timeout: fastReqTimeout,
+}
+
+var authenticatedFastClient = &http.Client{
+	Transport: &authenticatedTransport{
+		underlyingTransport: sharedRetryTransport,
+	},
+	Timeout: fastReqTimeout,
+}
+
+var authenticatedSlowClient = &http.Client{
+	Transport: &authenticatedTransport{
+		underlyingTransport: sharedRetryTransport,
+	},
+	Timeout: slowReqTimeout,
+}
+
+var authenticatedStreamingClient = &http.Client{
+	Transport: &authenticatedTransport{
+		underlyingTransport: sharedRetryTransport,
+	},
+}

app/cli/api/errors.go

@@ -0,0 +1,61 @@
+package api
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"plandex-cli/auth"
+	"plandex-cli/term"
+	"strings"
+
+	shared "plandex-shared"
+)
+
+func HandleApiError(r *http.Response, errBody []byte) *shared.ApiError {
+	// Check if the response is JSON
+	if r.Header.Get("Content-Type") != "application/json" {
+		return &shared.ApiError{
+			Type:   shared.ApiErrorTypeOther,
+			Status: r.StatusCode,
+			Msg:    strings.TrimSpace(string(errBody)),
+		}
+	}
+
+	var apiError shared.ApiError
+	if err := json.Unmarshal(errBody, &apiError); err != nil {
+		log.Printf("Error unmarshalling JSON: %v\n", err)
+		return &shared.ApiError{
+			Type:   shared.ApiErrorTypeOther,
+			Status: r.StatusCode,
+			Msg:    strings.TrimSpace(string(errBody)),
+		}
+	}
+
+	// return error if token/auth refresh is needed
+	if apiError.Type == shared.ApiErrorTypeInvalidToken || apiError.Type == shared.ApiErrorTypeAuthOutdated {
+		return &apiError
+	}
+
+	term.HandleApiError(&apiError)
+
+	return &apiError
+}
+
+func refreshAuthIfNeeded(apiErr *shared.ApiError) (bool, *shared.ApiError) {
+	if apiErr.Type == shared.ApiErrorTypeInvalidToken {
+		err := auth.RefreshInvalidToken()
+		if err != nil {
+			return false, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: "error refreshing invalid token"}
+		}
+		return true, nil
+	} else if apiErr.Type == shared.ApiErrorTypeAuthOutdated {
+		err := auth.RefreshAuth()
+		if err != nil {
+			return false, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: "error refreshing auth"}
+		}
+
+		return true, nil
+	}
+
+	return false, apiErr
+}

app/cli/api/methods.go

@@ -0,0 +1,2454 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"plandex-cli/types"
+	"strings"
+
+	shared "plandex-shared"
+
+	"github.com/shopspring/decimal"
+)
+
+func (a *Api) CreateCliTrialSession() (string, *shared.ApiError) {
+	serverUrl := CloudApiHost + "/accounts/cli_trial_session"
+
+	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", nil)
+
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		return "", apiErr
+	}
+
+	bytes, err := io.ReadAll(resp.Body)
+
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response: %v", err)}
+	}
+
+	return string(bytes), nil
+}
+
+func (a *Api) GetCliTrialSession(token string) (*shared.SessionResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/accounts/cli_trial_session/%s", CloudApiHost, token)
+
+	resp, err := unauthenticatedClient.Get(serverUrl)
+
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	if resp.StatusCode == 404 {
+		return nil, nil
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		return nil, apiErr
+	}
+
+	var session shared.SessionResponse
+	err = json.NewDecoder(resp.Body).Decode(&session)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &session, nil
+}
+
+func (a *Api) CreateProject(req shared.CreateProjectRequest) (*shared.CreateProjectResponse, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/projects"
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.CreateProject(req)
+		}
+		return nil, apiErr
+	}
+
+	var respBody shared.CreateProjectResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &respBody, nil
+}
+
+func (a *Api) ListProjects() ([]*shared.Project, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/projects"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListProjects()
+		}
+		return nil, apiErr
+	}
+
+	var projects []*shared.Project
+	err = json.NewDecoder(resp.Body).Decode(&projects)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return projects, nil
+}
+
+func (a *Api) SetProjectPlan(projectId string, req shared.SetProjectPlanRequest) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/projects/%s/set_plan", GetApiHost(), projectId)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.SetProjectPlan(projectId, req)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) RenameProject(projectId string, req shared.RenameProjectRequest) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/projects/%s/rename", GetApiHost(), projectId)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.RenameProject(projectId, req)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+func (a *Api) ListPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans?", GetApiHost())
+	parts := []string{}
+	for _, projectId := range projectIds {
+		parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
+	}
+	serverUrl += strings.Join(parts, "&")
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.ListPlans(projectIds)
+		}
+		return nil, apiErr
+	}
+
+	var plans []*shared.Plan
+	err = json.NewDecoder(resp.Body).Decode(&plans)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return plans, nil
+}
+
+func (a *Api) ListArchivedPlans(projectIds []string) ([]*shared.Plan, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/archive?", GetApiHost())
+	parts := []string{}
+	for _, projectId := range projectIds {
+		parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
+	}
+	serverUrl += strings.Join(parts, "&")
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListArchivedPlans(projectIds)
+		}
+		return nil, apiErr
+	}
+
+	var plans []*shared.Plan
+	err = json.NewDecoder(resp.Body).Decode(&plans)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return plans, nil
+}
+
+func (a *Api) ListPlansRunning(projectIds []string, includeRecent bool) (*shared.ListPlansRunningResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/ps?", GetApiHost())
+	parts := []string{}
+	for _, projectId := range projectIds {
+		parts = append(parts, fmt.Sprintf("projectId=%s", projectId))
+	}
+	serverUrl += strings.Join(parts, "&")
+	if includeRecent {
+		serverUrl += "&recent=true"
+	}
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListPlansRunning(projectIds, includeRecent)
+		}
+		return nil, apiErr
+	}
+
+	var respBody *shared.ListPlansRunningResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return respBody, nil
+}
+
+func (a *Api) GetCurrentBranchByPlanId(projectId string, req shared.GetCurrentBranchByPlanIdRequest) (map[string]*shared.Branch, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/projects/%s/plans/current_branches", GetApiHost(), projectId)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
+
+	if err != nil {
+		return nil, &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+
+	if err != nil {
+		return nil, &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.GetCurrentBranchByPlanId(projectId, req)
+		}
+		return nil, apiErr
+	}
+
+	var respBody map[string]*shared.Branch
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return respBody, nil
+}
+
+func (a *Api) CreatePlan(projectId string, req shared.CreatePlanRequest) (*shared.CreatePlanResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/projects/%s/plans", GetApiHost(), projectId)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.CreatePlan(projectId, req)
+		}
+		return nil, apiErr
+	}
+
+	var respBody shared.CreatePlanResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &respBody, nil
+}
+
+func (a *Api) GetPlan(planId string) (*shared.Plan, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s", GetApiHost(), planId)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetPlan(planId)
+		}
+		return nil, apiErr
+	}
+
+	var plan shared.Plan
+	err = json.NewDecoder(resp.Body).Decode(&plan)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &plan, nil
+}
+
+func (a *Api) DeletePlan(planId string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s", GetApiHost(), planId)
+
+	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.DeletePlan(planId)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) DeleteAllPlans(projectId string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/projects/%s/plans", GetApiHost(), projectId)
+
+	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+
+		if didRefresh {
+			return a.DeleteAllPlans(projectId)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) TellPlan(planId, branch string, req shared.TellPlanRequest, onStream types.OnStreamPlan) *shared.ApiError {
+
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/tell", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	var client *http.Client
+	if req.ConnectStream {
+		client = authenticatedStreamingClient
+	} else {
+		client = authenticatedFastClient
+	}
+
+	resp, err := client.Do(request)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+
+		if didRefresh {
+			return a.TellPlan(planId, branch, req, onStream)
+		}
+		return apiErr
+	}
+
+	if req.ConnectStream {
+		log.Println("Connecting stream")
+		connectPlanRespStream(resp.Body, onStream)
+	} else {
+		// log.Println("Background exec - not connecting stream")
+		resp.Body.Close()
+	}
+
+	return nil
+}
+
+func (a *Api) BuildPlan(planId, branch string, req shared.BuildPlanRequest, onStream types.OnStreamPlan) *shared.ApiError {
+
+	log.Println("Calling BuildPlan")
+
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/build", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	var client *http.Client
+	if req.ConnectStream {
+		client = authenticatedStreamingClient
+	} else {
+		client = authenticatedFastClient
+	}
+
+	resp, err := client.Do(request)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	if resp.StatusCode >= 400 {
+		log.Println("Error response from build plan", resp.StatusCode)
+
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+
+		if didRefresh {
+			return a.BuildPlan(planId, branch, req, onStream)
+		}
+		return apiErr
+	}
+
+	if req.ConnectStream {
+		log.Println("Connecting stream")
+		connectPlanRespStream(resp.Body, onStream)
+	} else {
+		// log.Println("Background exec - not connecting stream")
+		resp.Body.Close()
+	}
+
+	return nil
+}
+
+func (a *Api) RespondMissingFile(planId, branch string, req shared.RespondMissingFileRequest) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/respond_missing_file", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPost, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+
+		if didRefresh {
+			return a.RespondMissingFile(planId, branch, req)
+		}
+		return apiErr
+	}
+
+	return nil
+
+}
+
+func (a *Api) ConnectPlan(planId, branch string, onStream types.OnStreamPlan) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/connect", GetApiHost(), planId, branch)
+
+	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedStreamingClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+
+		if didRefresh {
+			return a.ConnectPlan(planId, branch, onStream)
+		}
+
+		return apiErr
+	}
+
+	connectPlanRespStream(resp.Body, onStream)
+
+	return nil
+}
+
+func (a *Api) StopPlan(ctx context.Context, planId, branch string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/stop", GetApiHost(), planId, branch)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.StopPlan(ctx, planId, branch)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) GetCurrentPlanState(planId, branch string) (*shared.CurrentPlanState, *shared.ApiError) {
+	return a.getCurrentPlanState(planId, branch, "")
+}
+
+func (a *Api) GetCurrentPlanStateAtSha(planId, sha string) (*shared.CurrentPlanState, *shared.ApiError) {
+	return a.getCurrentPlanState(planId, "", sha)
+}
+
+func (a *Api) getCurrentPlanState(planId, branch, sha string) (*shared.CurrentPlanState, *shared.ApiError) {
+	var serverUrl string
+	if sha != "" {
+		serverUrl = fmt.Sprintf("%s/plans/%s/current_plan/%s", GetApiHost(), planId, sha)
+	} else {
+		serverUrl = fmt.Sprintf("%s/plans/%s/%s/current_plan", GetApiHost(), planId, branch)
+	}
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.getCurrentPlanState(planId, branch, sha)
+		}
+		return nil, apiErr
+	}
+
+	var state shared.CurrentPlanState
+	err = json.NewDecoder(resp.Body).Decode(&state)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &state, nil
+}
+
+func (a *Api) ApplyPlan(planId, branch string, req shared.ApplyPlanRequest) (string, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/apply", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return "", &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return "", &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return "", &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.ApplyPlan(planId, branch, req)
+		}
+		return "", apiErr
+	}
+
+	// Reading the body on success
+	responseData, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", &shared.ApiError{Msg: fmt.Sprintf("error reading response body: %v", err)}
+	}
+
+	return string(responseData), nil
+}
+
+func (a *Api) ArchivePlan(planId string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/archive", GetApiHost(), planId)
+
+	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.ArchivePlan(planId)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) UnarchivePlan(planId string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/unarchive", GetApiHost(), planId)
+
+	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.ArchivePlan(planId)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) RenamePlan(planId string, name string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/rename", GetApiHost(), planId)
+
+	reqBytes, err := json.Marshal(shared.RenamePlanRequest{Name: name})
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.RenamePlan(planId, name)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) RejectAllChanges(planId, branch string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/reject_all", GetApiHost(), planId, branch)
+
+	req, err := http.NewRequest(http.MethodPatch, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			return a.RejectAllChanges(planId, branch)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) RejectFile(planId, branch, filePath string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/reject_file", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(shared.RejectFileRequest{FilePath: filePath})
+
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	req, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			a.RejectFile(planId, branch, filePath)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) RejectFiles(planId, branch string, paths []string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/reject_files", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(shared.RejectFilesRequest{Paths: paths})
+
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	req, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		didRefresh, apiErr := refreshAuthIfNeeded(apiErr)
+		if didRefresh {
+			a.RejectFiles(planId, branch, paths)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) LoadContext(planId, branch string, req shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	// use the slow client since we may be uploading relatively large files
+	resp, err := authenticatedSlowClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.LoadContext(planId, branch, req)
+		}
+		return nil, apiErr
+	}
+
+	var loadContextResponse shared.LoadContextResponse
+	err = json.NewDecoder(resp.Body).Decode(&loadContextResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &loadContextResponse, nil
+}
+
+func (a *Api) UpdateContext(planId, branch string, req shared.UpdateContextRequest) (*shared.UpdateContextResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+
+	// use the slow client since we may be uploading relatively large files
+	resp, err := authenticatedSlowClient.Do(request)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.UpdateContext(planId, branch, req)
+		}
+		return nil, apiErr
+	}
+
+	var updateContextResponse shared.UpdateContextResponse
+	err = json.NewDecoder(resp.Body).Decode(&updateContextResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &updateContextResponse, nil
+}
+
+func (a *Api) DeleteContext(planId, branch string, req shared.DeleteContextRequest) (*shared.DeleteContextResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodDelete, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.DeleteContext(planId, branch, req)
+		}
+		return nil, apiErr
+	}
+
+	var deleteContextResponse shared.DeleteContextResponse
+	err = json.NewDecoder(resp.Body).Decode(&deleteContextResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &deleteContextResponse, nil
+}
+
+func (a *Api) ListContext(planId, branch string) ([]*shared.Context, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context", GetApiHost(), planId, branch)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListContext(planId, branch)
+		}
+		return nil, apiErr
+	}
+
+	var contexts []*shared.Context
+	err = json.NewDecoder(resp.Body).Decode(&contexts)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return contexts, nil
+}
+
+func (a *Api) LoadCachedFileMap(planId, branch string, req shared.LoadCachedFileMapRequest) (*shared.LoadCachedFileMapResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/load_cached_file_map", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		return nil, apiErr
+	}
+
+	var loadResp shared.LoadCachedFileMapResponse
+	err = json.NewDecoder(resp.Body).Decode(&loadResp)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &loadResp, nil
+}
+
+func (a *Api) ListConvo(planId, branch string) ([]*shared.ConvoMessage, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/convo", GetApiHost(), planId, branch)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListConvo(planId, branch)
+		}
+		return nil, apiErr
+	}
+
+	var convos []*shared.ConvoMessage
+	err = json.NewDecoder(resp.Body).Decode(&convos)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return convos, nil
+}
+
+func (a *Api) GetPlanStatus(planId, branch string) (string, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/status", GetApiHost(), planId, branch)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetPlanStatus(planId, branch)
+		}
+		return "", apiErr
+	}
+
+	body, err := io.ReadAll(resp.Body)
+
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response body: %v", err)}
+	}
+
+	return string(body), nil
+}
+
+func (a *Api) GetPlanDiffs(planId, branch string, plain bool) (string, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/diffs", GetApiHost(), planId, branch)
+
+	if plain {
+		serverUrl += "?plain=true"
+	}
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetPlanDiffs(planId, branch, plain)
+		}
+		return "", apiErr
+	}
+
+	body, err := io.ReadAll(resp.Body)
+
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response body: %v", err)}
+	}
+
+	return string(body), nil
+}
+
+func (a *Api) ListLogs(planId, branch string) (*shared.LogResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/logs", GetApiHost(), planId, branch)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListLogs(planId, branch)
+		}
+		return nil, apiErr
+	}
+
+	var logs shared.LogResponse
+	err = json.NewDecoder(resp.Body).Decode(&logs)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &logs, nil
+}
+
+func (a *Api) RewindPlan(planId, branch string, req shared.RewindPlanRequest) (*shared.RewindPlanResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/rewind", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPatch, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.RewindPlan(planId, branch, req)
+		}
+		return nil, apiErr
+	}
+
+	var rewindPlanResponse shared.RewindPlanResponse
+	err = json.NewDecoder(resp.Body).Decode(&rewindPlanResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &rewindPlanResponse, nil
+}
+
+func (a *Api) SignIn(req shared.SignInRequest, customHost string) (*shared.SessionResponse, *shared.ApiError) {
+	host := customHost
+	if host == "" {
+		host = CloudApiHost
+	}
+	serverUrl := host + "/accounts/sign_in"
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		return nil, apiErr
+	}
+
+	var sessionResponse shared.SessionResponse
+	err = json.NewDecoder(resp.Body).Decode(&sessionResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &sessionResponse, nil
+}
+
+func (a *Api) CreateAccount(req shared.CreateAccountRequest, customHost string) (*shared.SessionResponse, *shared.ApiError) {
+	host := customHost
+	if host == "" {
+		host = CloudApiHost
+	}
+	serverUrl := host + "/accounts"
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		return nil, apiErr
+	}
+
+	var sessionResponse shared.SessionResponse
+	err = json.NewDecoder(resp.Body).Decode(&sessionResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &sessionResponse, nil
+}
+
+func (a *Api) CreateOrg(req shared.CreateOrgRequest) (*shared.CreateOrgResponse, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/orgs"
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.CreateOrg(req)
+		}
+		return nil, apiErr
+	}
+
+	var createOrgResponse shared.CreateOrgResponse
+	err = json.NewDecoder(resp.Body).Decode(&createOrgResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &createOrgResponse, nil
+}
+
+func (a *Api) GetOrgSession() (*shared.Org, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/orgs/session"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetOrgSession()
+		}
+		return nil, apiErr
+	}
+
+	var org *shared.Org
+
+	err = json.NewDecoder(resp.Body).Decode(&org)
+
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return org, nil
+}
+
+func (a *Api) ListOrgs() ([]*shared.Org, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/orgs"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListOrgs()
+		}
+		return nil, apiErr
+	}
+
+	var orgs []*shared.Org
+	err = json.NewDecoder(resp.Body).Decode(&orgs)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return orgs, nil
+}
+
+func (a *Api) GetOrgUserConfig() (*shared.OrgUserConfig, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/org_user_config"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetOrgUserConfig()
+		}
+		return nil, apiErr
+	}
+
+	var orgUserConfig shared.OrgUserConfig
+	err = json.NewDecoder(resp.Body).Decode(&orgUserConfig)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &orgUserConfig, nil
+}
+
+func (a *Api) UpdateOrgUserConfig(c shared.OrgUserConfig) *shared.ApiError {
+	serverUrl := GetApiHost() + "/org_user_config"
+
+	reqBytes, err := json.Marshal(c)
+
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.UpdateOrgUserConfig(c)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) DeleteUser(userId string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/orgs/users/%s", GetApiHost(), userId)
+	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.DeleteUser(userId)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) ListOrgRoles() ([]*shared.OrgRole, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/orgs/roles"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListOrgRoles()
+		}
+		return nil, apiErr
+	}
+
+	var roles []*shared.OrgRole
+	err = json.NewDecoder(resp.Body).Decode(&roles)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+	}
+
+	return roles, nil
+}
+
+func (a *Api) InviteUser(req shared.InviteRequest) *shared.ApiError {
+	serverUrl := GetApiHost() + "/invites"
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.InviteUser(req)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) ListPendingInvites() ([]*shared.Invite, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/invites/pending"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListPendingInvites()
+		}
+		return nil, apiErr
+	}
+
+	var invites []*shared.Invite
+	err = json.NewDecoder(resp.Body).Decode(&invites)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return invites, nil
+}
+
+func (a *Api) ListAcceptedInvites() ([]*shared.Invite, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/invites/accepted"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListAcceptedInvites()
+		}
+		return nil, apiErr
+	}
+
+	var invites []*shared.Invite
+	err = json.NewDecoder(resp.Body).Decode(&invites)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return invites, nil
+}
+
+func (a *Api) ListAllInvites() ([]*shared.Invite, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/invites/all"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListAllInvites()
+		}
+		return nil, apiErr
+	}
+
+	var invites []*shared.Invite
+	err = json.NewDecoder(resp.Body).Decode(&invites)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return invites, nil
+}
+
+func (a *Api) DeleteInvite(inviteId string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/invites/%s", GetApiHost(), inviteId)
+	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.DeleteInvite(inviteId)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) CreateEmailVerification(email, customHost, userId string) (*shared.CreateEmailVerificationResponse, *shared.ApiError) {
+	host := customHost
+	if host == "" {
+		host = CloudApiHost
+	}
+	serverUrl := host + "/accounts/email_verifications"
+	req := shared.CreateEmailVerificationRequest{Email: email, UserId: userId}
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := unauthenticatedClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		return nil, HandleApiError(resp, errorBody)
+	}
+
+	var verificationResponse shared.CreateEmailVerificationResponse
+	err = json.NewDecoder(resp.Body).Decode(&verificationResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &verificationResponse, nil
+}
+
+func (a *Api) CreateSignInCode() (string, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/accounts/sign_in_codes"
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", nil)
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.CreateSignInCode()
+		}
+		return "", apiErr
+	}
+
+	var signInCode string
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error reading response body: %v", err)}
+	}
+	signInCode = string(body)
+
+	return signInCode, nil
+}
+
+func (a *Api) SignOut() *shared.ApiError {
+	serverUrl := GetApiHost() + "/accounts/sign_out"
+
+	req, err := http.NewRequest(http.MethodPost, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		return HandleApiError(resp, errorBody)
+	}
+
+	return nil
+}
+
+func (a *Api) ListUsers() (*shared.ListUsersResponse, *shared.ApiError) {
+	serverUrl := GetApiHost() + "/users"
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListUsers()
+		}
+		return nil, apiErr
+	}
+
+	var r *shared.ListUsersResponse
+	err = json.NewDecoder(resp.Body).Decode(&r)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return r, nil
+}
+
+func (a *Api) ListBranches(planId string) ([]*shared.Branch, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/branches", GetApiHost(), planId)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListBranches(planId)
+		}
+		return nil, apiErr
+	}
+
+	var branches []*shared.Branch
+	err = json.NewDecoder(resp.Body).Decode(&branches)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+	}
+
+	return branches, nil
+}
+
+func (a *Api) CreateBranch(planId, branch string, req shared.CreateBranchRequest) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/branches", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.CreateBranch(planId, branch, req)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) DeleteBranch(planId, branch string) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/branches/%s", GetApiHost(), planId, branch)
+
+	req, err := http.NewRequest(http.MethodDelete, serverUrl, nil)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
+	}
+
+	resp, err := authenticatedFastClient.Do(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.DeleteBranch(planId, branch)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) GetSettings(planId, branch string) (*shared.PlanSettings, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/settings", GetApiHost(), planId, branch)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetSettings(planId, branch)
+		}
+		return nil, apiErr
+	}
+
+	var settings shared.PlanSettings
+	err = json.NewDecoder(resp.Body).Decode(&settings)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+	}
+
+	return &settings, nil
+}
+
+func (a *Api) UpdateSettings(planId, branch string, req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/settings", GetApiHost(), planId, branch)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
+	}
+
+	// log.Println("UpdateSettings", string(reqBytes))
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.UpdateSettings(planId, branch, req)
+		}
+		return nil, apiErr
+	}
+
+	var updateRes shared.UpdateSettingsResponse
+	err = json.NewDecoder(resp.Body).Decode(&updateRes)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+	}
+
+	return &updateRes, nil
+
+}
+
+func (a *Api) GetOrgDefaultSettings() (*shared.PlanSettings, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/default_settings", GetApiHost())
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetOrgDefaultSettings()
+		}
+		return nil, apiErr
+	}
+
+	var settings shared.PlanSettings
+	err = json.NewDecoder(resp.Body).Decode(&settings)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+	}
+
+	return &settings, nil
+}
+
+func (a *Api) UpdateOrgDefaultSettings(req shared.UpdateSettingsRequest) (*shared.UpdateSettingsResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/default_settings", GetApiHost())
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %s", err)}
+	}
+
+	// log.Println("UpdateSettings", string(reqBytes))
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %s", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %s", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.UpdateOrgDefaultSettings(req)
+		}
+		return nil, apiErr
+	}
+
+	var updateRes shared.UpdateSettingsResponse
+	err = json.NewDecoder(resp.Body).Decode(&updateRes)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %s", err)}
+	}
+
+	return &updateRes, nil
+}
+
+func (a *Api) GetPlanConfig(planId string) (*shared.PlanConfig, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/config", GetApiHost(), planId)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetPlanConfig(planId)
+		}
+		return nil, apiErr
+	}
+
+	var res shared.GetPlanConfigResponse
+	err = json.NewDecoder(resp.Body).Decode(&res)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return res.Config, nil
+}
+
+func (a *Api) UpdatePlanConfig(planId string, req shared.UpdatePlanConfigRequest) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/plans/%s/config", GetApiHost(), planId)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.UpdatePlanConfig(planId, req)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) GetDefaultPlanConfig() (*shared.PlanConfig, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/default_plan_config", GetApiHost())
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetDefaultPlanConfig()
+		}
+		return nil, apiErr
+	}
+
+	var res shared.GetDefaultPlanConfigResponse
+	err = json.NewDecoder(resp.Body).Decode(&res)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return res.Config, nil
+}
+
+func (a *Api) UpdateDefaultPlanConfig(req shared.UpdateDefaultPlanConfigRequest) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/default_plan_config", GetApiHost())
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	request, err := http.NewRequest(http.MethodPut, serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	resp, err := authenticatedFastClient.Do(request)
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.UpdateDefaultPlanConfig(req)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) CreateCustomModels(input *shared.ModelsInput) *shared.ApiError {
+	serverUrl := fmt.Sprintf("%s/custom_models", GetApiHost())
+	body, err := json.Marshal(input)
+	if err != nil {
+		return &shared.ApiError{Msg: "Failed to marshal model"}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(body))
+	if err != nil {
+		return &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.CreateCustomModels(input)
+		}
+		return apiErr
+	}
+
+	return nil
+}
+
+func (a *Api) ListCustomModels() ([]*shared.CustomModel, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/custom_models", GetApiHost())
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListCustomModels()
+		}
+		return nil, apiErr
+	}
+
+	var models []*shared.CustomModel
+	err = json.NewDecoder(resp.Body).Decode(&models)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return models, nil
+}
+
+func (a *Api) ListCustomProviders() ([]*shared.CustomProvider, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/custom_providers", GetApiHost())
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListCustomProviders()
+		}
+		return nil, apiErr
+	}
+
+	var providers []*shared.CustomProvider
+	err = json.NewDecoder(resp.Body).Decode(&providers)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return providers, nil
+}
+
+func (a *Api) ListModelPacks() ([]*shared.ModelPack, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/model_sets", GetApiHost())
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.ListModelPacks()
+		}
+		return nil, apiErr
+	}
+
+	var sets []*shared.ModelPack
+	err = json.NewDecoder(resp.Body).Decode(&sets)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return sets, nil
+
+}
+
+func (a *Api) GetCreditsTransactions(pageSize, pageNum int, req shared.CreditsLogRequest) (*shared.CreditsLogResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/billing/credits_transactions?size=%d&page=%d", GetApiHost(), pageSize, pageNum)
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetCreditsTransactions(pageSize, pageNum, req)
+		}
+		return nil, apiErr
+	}
+
+	var res *shared.CreditsLogResponse
+	err = json.NewDecoder(resp.Body).Decode(&res)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return res, nil
+}
+
+func (a *Api) GetCreditsSummary(req shared.CreditsLogRequest) (*shared.CreditsSummaryResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/billing/credits_summary", GetApiHost())
+
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedFastClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetCreditsSummary(req)
+		}
+		return nil, apiErr
+	}
+
+	var res *shared.CreditsSummaryResponse
+	err = json.NewDecoder(resp.Body).Decode(&res)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return res, nil
+}
+
+func (a *Api) GetBalance() (decimal.Decimal, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/billing/balance", GetApiHost())
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return decimal.Zero, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetBalance()
+		}
+		return decimal.Zero, apiErr
+	}
+
+	var res *shared.GetBalanceResponse
+	err = json.NewDecoder(resp.Body).Decode(&res)
+	if err != nil {
+		return decimal.Zero, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return res.Balance, nil
+}
+
+func (a *Api) GetFileMap(req shared.GetFileMapRequest) (*shared.GetFileMapResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/file_map", GetApiHost())
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	resp, err := authenticatedSlowClient.Post(serverUrl, "application/json", bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetFileMap(req)
+		}
+		return nil, apiErr
+	}
+
+	var respBody shared.GetFileMapResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &respBody, nil
+}
+
+func (a *Api) GetContextBody(planId, branch, contextId string) (*shared.GetContextBodyResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/context/%s/body", GetApiHost(), planId, branch, contextId)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetContextBody(planId, branch, contextId)
+		}
+		return nil, apiErr
+	}
+
+	var respBody shared.GetContextBodyResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &respBody, nil
+}
+
+func (a *Api) AutoLoadContext(ctx context.Context, planId, branch string, req shared.LoadContextRequest) (*shared.LoadContextResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/auto_load_context", GetApiHost(), planId, branch)
+	reqBytes, err := json.Marshal(req)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error marshalling request: %v", err)}
+	}
+
+	// Create a new request with context
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", serverUrl, bytes.NewBuffer(reqBytes))
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error creating request: %v", err)}
+	}
+
+	// Set the content type header
+	httpReq.Header.Set("Content-Type", "application/json")
+
+	// Use the slow client since we may be uploading relatively large files
+	resp, err := authenticatedSlowClient.Do(httpReq)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.LoadContext(planId, branch, req)
+		}
+		return nil, apiErr
+	}
+
+	var loadContextResponse shared.LoadContextResponse
+	err = json.NewDecoder(resp.Body).Decode(&loadContextResponse)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &loadContextResponse, nil
+}
+
+func (a *Api) GetBuildStatus(planId, branch string) (*shared.GetBuildStatusResponse, *shared.ApiError) {
+	serverUrl := fmt.Sprintf("%s/plans/%s/%s/build_status", GetApiHost(), planId, branch)
+
+	resp, err := authenticatedFastClient.Get(serverUrl)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error sending request: %v", err)}
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		errorBody, _ := io.ReadAll(resp.Body)
+		apiErr := HandleApiError(resp, errorBody)
+		authRefreshed, apiErr := refreshAuthIfNeeded(apiErr)
+		if authRefreshed {
+			return a.GetBuildStatus(planId, branch)
+		}
+		return nil, apiErr
+	}
+
+	var respBody shared.GetBuildStatusResponse
+	err = json.NewDecoder(resp.Body).Decode(&respBody)
+	if err != nil {
+		return nil, &shared.ApiError{Type: shared.ApiErrorTypeOther, Msg: fmt.Sprintf("error decoding response: %v", err)}
+	}
+
+	return &respBody, nil
+}

app/cli/api/stream.go

@@ -0,0 +1,85 @@
+package api
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"plandex-cli/types"
+	"time"
+
+	shared "plandex-shared"
+)
+
+// 3 heartbeat misses = timeout
+const HeartbeatTimeout = 16 * time.Second
+
+func connectPlanRespStream(body io.ReadCloser, onStream types.OnStreamPlan) {
+	reader := bufio.NewReader(body)
+	timer := time.NewTimer(HeartbeatTimeout)
+	defer timer.Stop()
+
+	go func() {
+		for {
+			select {
+			case <-timer.C:
+				log.Println("Connection to plan stream timed out due to missing heartbeats")
+				onStream(types.OnStreamPlanParams{Msg: nil, Err: fmt.Errorf("connection to plan stream timed out due to missing heartbeats")})
+				body.Close()
+				return
+			default:
+			}
+
+			s, err := readUntilSeparator(reader, shared.STREAM_MESSAGE_SEPARATOR)
+			if err != nil {
+				log.Println("Error reading line:", err)
+				onStream(types.OnStreamPlanParams{Msg: nil, Err: err})
+				body.Close()
+				return
+			}
+
+			timer.Reset(HeartbeatTimeout)
+
+			// ignore heartbeats
+			if s == string(shared.StreamMessageHeartbeat) {
+				continue
+			}
+
+			var msg shared.StreamMessage
+			err = json.Unmarshal([]byte(s), &msg)
+			if err != nil {
+				log.Println("Error unmarshalling message:", err)
+				onStream(types.OnStreamPlanParams{Msg: nil, Err: err})
+				body.Close()
+				return
+			}
+
+			// log.Println("connectPlanRespStream: received message:", msg)
+
+			onStream(types.OnStreamPlanParams{Msg: &msg, Err: nil})
+
+			if msg.Type == shared.StreamMessageFinished || msg.Type == shared.StreamMessageError || msg.Type == shared.StreamMessageAborted {
+				body.Close()
+				return
+			}
+
+		}
+	}()
+}
+
+func readUntilSeparator(reader *bufio.Reader, separator string) (string, error) {
+	var result []byte
+	sepBytes := []byte(separator)
+	for {
+		b, err := reader.ReadByte()
+		if err != nil {
+			return string(result), err
+		}
+		result = append(result, b)
+		if len(result) >= len(sepBytes) && bytes.HasSuffix(result, sepBytes) {
+			return string(result[:len(result)-len(separator)]), nil
+		}
+	}
+}

app/cli/auth/account.go

@@ -0,0 +1,367 @@
+package auth
+
+import (
+	"fmt"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+)
+
+const AddAccountOption = "Add another account"
+
+func SelectOrSignInOrCreate() error {
+	accounts, err := loadAccounts()
+
+	if err != nil {
+		return fmt.Errorf("error loading accounts: %v", err)
+	}
+
+	if len(accounts) == 0 {
+		err := promptSignInNewAccount()
+		if err != nil {
+			return fmt.Errorf("error signing in to new account: %v", err)
+		}
+
+		return nil
+	}
+
+	var options []string
+	for _, account := range accounts {
+		options = append(options, fmt.Sprintf("<%s> %s", account.UserName, account.Email))
+	}
+
+	options = append(options, AddAccountOption)
+
+	// either select from existing accounts or sign in/create account
+
+	selectedOpt, err := term.SelectFromList("Select an account:", options)
+
+	if err != nil {
+		return fmt.Errorf("error selecting account: %v", err)
+	}
+
+	if selectedOpt == AddAccountOption {
+		err := promptSignInNewAccount()
+		if err != nil {
+			return fmt.Errorf("error prompting for sign in to new account: %v", err)
+		}
+		return nil
+	}
+
+	var selected *shared.ClientAccount
+	for i, opt := range options {
+		if selectedOpt == opt {
+			selected = accounts[i]
+			break
+		}
+	}
+
+	if selected == nil {
+		return fmt.Errorf("error selecting account: account not found")
+	}
+
+	selectedAuth := *selected
+
+	setAuth(&shared.ClientAuth{
+		ClientAccount: selectedAuth,
+	})
+
+	term.StartSpinner("")
+	orgs, apiErr := apiClient.ListOrgs()
+	term.StopSpinner()
+
+	if apiErr != nil {
+		return fmt.Errorf("error listing orgs: %v", apiErr.Msg)
+	}
+
+	org, err := resolveOrgAuth(orgs, selectedAuth.IsLocalMode)
+
+	if err != nil {
+		return fmt.Errorf("error resolving org: %v", err)
+	}
+
+	err = setAuth(&shared.ClientAuth{
+		ClientAccount:        *selected,
+		OrgId:                org.Id,
+		OrgName:              org.Name,
+		OrgIsTrial:           org.IsTrial,
+		IntegratedModelsMode: org.IntegratedModelsMode,
+	})
+
+	if err != nil {
+		return fmt.Errorf("error setting auth: %v", err)
+	}
+
+	_, apiErr = apiClient.GetOrgSession()
+
+	if apiErr != nil {
+		return fmt.Errorf("error getting org session: %v", apiErr.Msg)
+	}
+
+	fmt.Printf("✅ Signed in as %s | Org: %s\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("<%s> %s", Current.UserName, Current.Email), color.New(term.ColorHiCyan).Sprint(Current.OrgName))
+	fmt.Println()
+
+	if !term.IsRepl {
+		term.PrintCmds("", "")
+	}
+
+	return nil
+}
+
+func SignInWithCode(code, host string) error {
+	term.StartSpinner("")
+	res, apiErr := apiClient.SignIn(shared.SignInRequest{
+		Pin:          code,
+		IsSignInCode: true,
+	}, host)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		return fmt.Errorf("error signing in: %v", apiErr.Msg)
+	}
+
+	return handleSignInResponse(res, host)
+}
+
+func promptInitialAuth() error {
+	fmt.Println("👋 Hey there!\nIt looks like this is your first time using Plandex on this computer.")
+
+	err := SelectOrSignInOrCreate()
+
+	if err != nil {
+		return fmt.Errorf("error selecting or signing in to account: %v", err)
+	}
+
+	return nil
+}
+
+const (
+	// SignInCloudOption = "Plandex Cloud"
+	SignInLocalOption = "Local mode host"
+	SignInOtherOption = "Another host"
+)
+
+func promptSignInNewAccount() error {
+	selected, err := term.SelectFromList("Use local mode or another host?", []string{SignInLocalOption, SignInOtherOption})
+
+	if err != nil {
+		return fmt.Errorf("error selecting sign in option: %v", err)
+	}
+
+	var host string
+	var email string
+
+	if selected == SignInLocalOption {
+		host, err = term.GetRequiredUserStringInputWithDefault("Host:", "http://localhost:8099")
+	} else {
+		host, err = term.GetRequiredUserStringInput("Host:")
+	}
+
+	if err != nil {
+		return fmt.Errorf("error prompting host: %v", err)
+	}
+
+	if selected == SignInLocalOption {
+		email = "local-admin@plandex.ai"
+	} else {
+		email, err = term.GetRequiredUserStringInput("Your email:")
+	}
+
+	if err != nil {
+		return fmt.Errorf("error prompting email: %v", err)
+	}
+
+	res, err := verifyEmail(email, host)
+
+	if err != nil {
+		return fmt.Errorf("error verifying email: %v", err)
+	}
+
+	if res.hasAccount {
+		err := signIn(email, res.pin, host)
+		if err != nil {
+			return fmt.Errorf("error signing in: %v", err)
+		}
+	} else {
+		err := createAccount(email, res.pin, host, res.isLocalMode)
+		if err != nil {
+			return fmt.Errorf("error creating account: %v", err)
+		}
+	}
+
+	if !term.IsRepl {
+		term.PrintCmds("", "")
+	}
+
+	return nil
+}
+
+type verifyEmailRes struct {
+	hasAccount  bool
+	isLocalMode bool
+	pin         string
+}
+
+func verifyEmail(email, host string) (*verifyEmailRes, error) {
+	term.StartSpinner("")
+	res, apiErr := apiClient.CreateEmailVerification(email, host, "")
+	term.StopSpinner()
+
+	if apiErr != nil {
+		return nil, fmt.Errorf("error creating email verification: %v", apiErr.Msg)
+	}
+
+	if res.IsLocalMode {
+		return &verifyEmailRes{
+			hasAccount:  res.HasAccount,
+			isLocalMode: true,
+			pin:         "",
+		}, nil
+	}
+
+	fmt.Println("✉️  You'll now receive a 6 character pin by email. It will be valid for 5 minutes.")
+
+	pin, err := term.GetUserPasswordInput("Please enter your pin:")
+
+	if err != nil {
+		return nil, fmt.Errorf("error prompting pin: %v", err)
+	}
+
+	return &verifyEmailRes{
+		hasAccount:  res.HasAccount,
+		isLocalMode: false,
+		pin:         pin,
+	}, nil
+}
+
+func signIn(email, pin, host string) error {
+	term.StartSpinner("")
+	res, apiErr := apiClient.SignIn(shared.SignInRequest{
+		Email: email,
+		Pin:   pin,
+	}, host)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		return fmt.Errorf("error signing in: %v", apiErr.Msg)
+	}
+
+	return handleSignInResponse(res, host)
+}
+
+func handleSignInResponse(res *shared.SessionResponse, host string) error {
+	isLocalMode := host != "" && res.IsLocalMode
+
+	err := setAuth(&shared.ClientAuth{
+		ClientAccount: shared.ClientAccount{
+			Email:       res.Email,
+			UserId:      res.UserId,
+			UserName:    res.UserName,
+			Token:       res.Token,
+			IsTrial:     false,
+			IsCloud:     host == "",
+			Host:        host,
+			IsLocalMode: isLocalMode,
+		},
+	})
+
+	if err != nil {
+		return fmt.Errorf("error setting auth: %v", err)
+	}
+
+	org, err := resolveOrgAuth(res.Orgs, isLocalMode)
+
+	if err != nil {
+		return fmt.Errorf("error resolving org: %v", err)
+	}
+
+	Current.OrgId = org.Id
+	Current.OrgName = org.Name
+	Current.IntegratedModelsMode = org.IntegratedModelsMode
+
+	err = writeCurrentAuth()
+
+	if err != nil {
+		return fmt.Errorf("error writing auth: %v", err)
+	}
+
+	fmt.Printf("✅ Signed in as %s | Org: %s\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("<%s> %s", Current.UserName, Current.Email), color.New(term.ColorHiCyan).Sprint(Current.OrgName))
+	fmt.Println()
+
+	return nil
+}
+
+func createAccount(email, pin, host string, isLocalMode bool) error {
+	var name string
+
+	if isLocalMode {
+		name = "Local Admin"
+	} else {
+		var err error
+		name, err = term.GetUserStringInput("Your name:")
+
+		if err != nil {
+			return fmt.Errorf("error prompting name: %v", err)
+		}
+	}
+
+	term.StartSpinner("🌟 Creating account...")
+	res, apiErr := apiClient.CreateAccount(shared.CreateAccountRequest{
+		Email:    email,
+		UserName: name,
+		Pin:      pin,
+	}, host)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		return fmt.Errorf("error creating account: %v", apiErr.Msg)
+	}
+
+	if res.IsLocalMode {
+		isLocalMode = true
+	}
+
+	err := setAuth(&shared.ClientAuth{
+		ClientAccount: shared.ClientAccount{
+			Email:       res.Email,
+			UserId:      res.UserId,
+			UserName:    res.UserName,
+			Token:       res.Token,
+			IsTrial:     false,
+			IsCloud:     host == "",
+			Host:        host,
+			IsLocalMode: isLocalMode,
+		},
+	})
+
+	if err != nil {
+		return fmt.Errorf("error setting auth: %v", err)
+	}
+
+	org, err := resolveOrgAuth(res.Orgs, isLocalMode)
+
+	if err != nil {
+		return fmt.Errorf("error resolving org: %v", err)
+	}
+
+	if org == nil {
+		return fmt.Errorf("no org selected")
+	}
+
+	Current.OrgId = org.Id
+	Current.OrgName = org.Name
+	Current.IntegratedModelsMode = org.IntegratedModelsMode
+
+	err = writeCurrentAuth()
+
+	if err != nil {
+		return fmt.Errorf("error writing auth: %v", err)
+	}
+
+	fmt.Printf("✅ Signed in as %s | Org: %s\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("<%s> %s", Current.UserName, Current.Email), color.New(term.ColorHiCyan).Sprint(Current.OrgName))
+	fmt.Println()
+
+	return nil
+}

app/cli/auth/api.go

@@ -0,0 +1,48 @@
+package auth
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"plandex-cli/types"
+	"plandex-cli/version"
+
+	shared "plandex-shared"
+)
+
+var apiClient types.ApiClient
+
+func SetApiClient(client types.ApiClient) {
+	apiClient = client
+}
+
+func SetAuthHeader(req *http.Request) error {
+	if Current == nil {
+		return fmt.Errorf("error setting auth header: auth not loaded")
+	}
+	hash := Current.ToHash()
+
+	authHeader := shared.AuthHeader{
+		Token: Current.Token,
+		OrgId: Current.OrgId,
+		Hash:  hash,
+	}
+
+	bytes, err := json.Marshal(authHeader)
+
+	if err != nil {
+		return fmt.Errorf("error marshalling auth header: %v", err)
+	}
+
+	// base64 encode
+	token := base64.URLEncoding.EncodeToString(bytes)
+
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	return nil
+}
+
+func SetVersionHeader(req *http.Request) {
+	req.Header.Set("X-Client-Version", version.Version)
+}

app/cli/auth/auth.go

@@ -0,0 +1,136 @@
+package auth
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"plandex-cli/fs"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+)
+
+var openUnauthenticatedCloudURL func(msg, path string)
+var openAuthenticatedURL func(msg, path string)
+
+func SetOpenUnauthenticatedCloudURLFn(fn func(msg, path string)) {
+	openUnauthenticatedCloudURL = fn
+}
+
+func SetOpenAuthenticatedURLFn(fn func(msg, path string)) {
+	openAuthenticatedURL = fn
+}
+
+func MustResolveAuthWithOrg() {
+	MustResolveAuth(true)
+}
+
+func MustResolveAuth(requireOrg bool) {
+	if apiClient == nil {
+		term.OutputErrorAndExit("error resolving auth: api client not set")
+	}
+
+	// load HomeAuthPath file into ClientAuth struct
+	bytes, err := os.ReadFile(fs.HomeAuthPath)
+
+	if err != nil {
+		if os.IsNotExist(err) {
+			err = promptInitialAuth()
+
+			if err != nil {
+				term.OutputErrorAndExit("error resolving auth: %v", err)
+			}
+
+			return
+		} else {
+			term.OutputErrorAndExit("error reading auth.json: %v", err)
+		}
+	}
+
+	var auth shared.ClientAuth
+	err = json.Unmarshal(bytes, &auth)
+	if err != nil {
+		term.OutputErrorAndExit("error unmarshalling auth.json: %v", err)
+	}
+
+	Current = &auth
+
+	if requireOrg && Current.OrgId == "" {
+		term.StartSpinner("")
+		orgs, apiErr := apiClient.ListOrgs()
+		term.StopSpinner()
+
+		if apiErr != nil {
+			term.OutputErrorAndExit("Error listing orgs: %v", apiErr.Msg)
+		}
+
+		org, err := resolveOrgAuth(orgs, Current.IsLocalMode)
+
+		if err != nil {
+			term.OutputErrorAndExit("Error resolving org: %v", err)
+		}
+
+		if org.Id == "" {
+			// still no org--exit now
+			term.OutputErrorAndExit("No org")
+		}
+
+		Current.OrgId = org.Id
+		Current.OrgName = org.Name
+		Current.IntegratedModelsMode = org.IntegratedModelsMode
+
+		err = writeCurrentAuth()
+
+		if err != nil {
+			term.OutputErrorAndExit("Error writing auth: %v", err)
+		}
+	}
+}
+
+func RefreshInvalidToken() error {
+	if Current == nil {
+		return fmt.Errorf("error refreshing token: auth not loaded")
+	}
+	res, err := verifyEmail(Current.Email, Current.Host)
+
+	if err != nil {
+		return fmt.Errorf("error verifying email: %v", err)
+	}
+
+	if res.hasAccount {
+		return signIn(Current.Email, res.pin, Current.Host)
+	} else {
+		host := Current.Host
+		if host == "" {
+			host = "Plandex Cloud"
+		}
+
+		term.OutputErrorAndExit("Account %s not found on %s", Current.Email, host)
+	}
+
+	return nil
+}
+
+func RefreshAuth() error {
+	if Current == nil {
+		return fmt.Errorf("error refreshing auth: auth not loaded")
+	}
+
+	org, apiErr := apiClient.GetOrgSession()
+
+	if apiErr != nil {
+		return fmt.Errorf("error getting org session: %v", apiErr.Msg)
+	}
+
+	Current.OrgName = org.Name
+	Current.OrgIsTrial = org.IsTrial
+	Current.IntegratedModelsMode = org.IntegratedModelsMode
+
+	err := writeCurrentAuth()
+
+	if err != nil {
+		return fmt.Errorf("error writing auth: %v", err)
+	}
+
+	return nil
+}

app/cli/auth/org.go

@@ -0,0 +1,137 @@
+package auth
+
+import (
+	"fmt"
+	"plandex-cli/term"
+	"strings"
+
+	shared "plandex-shared"
+)
+
+func resolveOrgAuth(orgs []*shared.Org, isLocalMode bool) (*shared.Org, error) {
+	var org *shared.Org
+	var err error
+
+	if len(orgs) == 0 {
+		if isLocalMode {
+			org, err = createOrg(isLocalMode)
+		} else {
+			org, err = promptNoOrgs()
+		}
+
+		if err != nil {
+			return nil, fmt.Errorf("error prompting no orgs: %v", err)
+		}
+
+	} else if len(orgs) == 1 {
+		org = orgs[0]
+	} else {
+		org, err = selectOrg(orgs, isLocalMode)
+
+		if err != nil {
+			return nil, fmt.Errorf("error selecting org: %v", err)
+		}
+	}
+
+	return org, nil
+}
+
+func promptNoOrgs() (*shared.Org, error) {
+	fmt.Println("🧐 You don't have access to any orgs yet.\n\nTo join an existing org, ask an admin to either invite you directly or give your whole email domain access.\n\nOtherwise, you can go ahead and create a new org.")
+
+	shouldCreate, err := term.ConfirmYesNo("Create a new org now?")
+
+	if err != nil {
+		return nil, fmt.Errorf("error prompting create org: %v", err)
+	}
+
+	if shouldCreate {
+		return createOrg(false)
+	}
+
+	return nil, nil
+}
+
+func createOrg(isLocalMode bool) (*shared.Org, error) {
+	var err error
+	var name string
+	var autoAddDomainUsers bool
+
+	if isLocalMode {
+		name = "Local Org"
+	} else {
+		name, err = term.GetRequiredUserStringInput("Org name:")
+	}
+	if err != nil {
+		return nil, fmt.Errorf("error prompting org name: %v", err)
+	}
+
+	if !isLocalMode {
+		autoAddDomainUsers, err = promptAutoAddUsersIfValid(Current.Email)
+		if err != nil {
+			return nil, fmt.Errorf("error prompting auto add domain users: %v", err)
+		}
+	}
+
+	term.StartSpinner("")
+	res, apiErr := apiClient.CreateOrg(shared.CreateOrgRequest{
+		Name:               name,
+		AutoAddDomainUsers: autoAddDomainUsers,
+	})
+	term.StopSpinner()
+
+	if apiErr != nil {
+		return nil, fmt.Errorf("error creating org: %v", apiErr.Msg)
+	}
+
+	return &shared.Org{Id: res.Id, Name: name}, nil
+}
+
+func promptAutoAddUsersIfValid(email string) (bool, error) {
+	userDomain := strings.Split(email, "@")[1]
+	var autoAddDomainUsers bool
+	var err error
+	if !shared.IsEmailServiceDomain(userDomain) {
+		fmt.Println("With domain auto-join, you can allow any user with an email ending in @"+userDomain, "to auto-join this org.")
+		autoAddDomainUsers, err = term.ConfirmYesNo(fmt.Sprintf("Enable auto-join for %s?", userDomain))
+
+		if err != nil {
+			return false, err
+		}
+	}
+	return autoAddDomainUsers, nil
+}
+
+const CreateOrgOption = "Create a new org"
+
+func selectOrg(orgs []*shared.Org, isLocalMode bool) (*shared.Org, error) {
+	var options []string
+	for _, org := range orgs {
+		options = append(options, org.Name)
+	}
+	options = append(options, CreateOrgOption)
+
+	selected, err := term.SelectFromList("Select an org:", options)
+
+	if err != nil {
+		return nil, fmt.Errorf("error selecting org: %v", err)
+	}
+
+	if selected == CreateOrgOption {
+		return createOrg(isLocalMode)
+	}
+
+	var selectedOrg *shared.Org
+	for _, org := range orgs {
+		if org.Name == selected {
+			selectedOrg = org
+			break
+		}
+	}
+
+	if selectedOrg == nil {
+		return nil, fmt.Errorf("error selecting org: org not found")
+	}
+
+	return selectedOrg, nil
+}

app/cli/auth/state.go

@@ -0,0 +1,107 @@
+package auth
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"plandex-cli/fs"
+
+	shared "plandex-shared"
+)
+
+var Current *shared.ClientAuth
+
+func loadAccounts() ([]*shared.ClientAccount, error) {
+	bytes, err := os.ReadFile(fs.HomeAccountsPath)
+
+	if err != nil {
+		if os.IsNotExist(err) {
+			// no accounts
+			return []*shared.ClientAccount{}, nil
+		} else {
+			return nil, fmt.Errorf("error reading accounts.json: %v", err)
+		}
+	}
+
+	var accounts []*shared.ClientAccount
+	err = json.Unmarshal(bytes, &accounts)
+
+	if err != nil {
+		return nil, fmt.Errorf("error unmarshalling accounts.json: %v", err)
+	}
+
+	return accounts, nil
+}
+
+func setAuth(auth *shared.ClientAuth) error {
+	err := storeAccount(&auth.ClientAccount)
+
+	if err != nil {
+		return fmt.Errorf("error storing account: %v", err)
+	}
+
+	Current = auth
+
+	err = writeCurrentAuth()
+
+	if err != nil {
+		return fmt.Errorf("error writing auth: %v", err)
+	}
+
+	return nil
+}
+
+func storeAccount(toStore *shared.ClientAccount) error {
+	accounts, err := loadAccounts()
+
+	if err != nil {
+		return fmt.Errorf("error loading accounts: %v", err)
+	}
+
+	found := false
+	for i, account := range accounts {
+		if account.UserId == toStore.UserId {
+			accounts[i] = toStore
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		accounts = append(accounts, toStore)
+	}
+
+	bytes, err := json.Marshal(accounts)
+
+	if err != nil {
+		return fmt.Errorf("error marshalling accounts: %v", err)
+	}
+
+	err = os.WriteFile(fs.HomeAccountsPath, bytes, os.ModePerm)
+
+	if err != nil {
+		return fmt.Errorf("error writing accounts: %v", err)
+	}
+
+	return nil
+}
+
+func writeCurrentAuth() error {
+	if Current == nil {
+		return fmt.Errorf("error writing auth: auth not loaded")
+	}
+
+	bytes, err := json.Marshal(Current)
+
+	if err != nil {
+		return fmt.Errorf("error marshalling auth: %v", err)
+	}
+
+	err = os.WriteFile(fs.HomeAuthPath, bytes, os.ModePerm)
+
+	if err != nil {
+		return fmt.Errorf("error writing auth: %v", err)
+	}
+
+	return nil
+}

app/cli/auth/trial.go

@@ -0,0 +1,87 @@
+package auth
+
+import (
+	"fmt"
+	"plandex-cli/term"
+	"time"
+)
+
+func ConvertTrial() {
+	openAuthenticatedURL("Opening Plandex Cloud upgrade flow in your browser.", "/settings/billing?upgrade=1&cliUpgrade=1")
+
+	fmt.Println("\nCommand will continue automatically once you've upgraded...")
+	fmt.Println()
+	term.StartSpinner("")
+
+	startTime := time.Now()
+	expirationTime := startTime.Add(1 * time.Hour)
+
+	for time.Now().Before(expirationTime) {
+		org, apiErr := apiClient.GetOrgSession()
+
+		if apiErr != nil {
+			term.StopSpinner()
+			term.OutputErrorAndExit("error getting org session: %s", apiErr.Msg)
+		}
+
+		if org != nil && !org.IsTrial {
+			term.StopSpinner()
+			fmt.Println("🚀 Trial upgraded")
+			fmt.Println()
+			return
+		}
+
+		time.Sleep(1500 * time.Millisecond)
+	}
+
+	term.StopSpinner()
+	term.OutputErrorAndExit("Timed out waiting for upgrade. Please try again. Email support@plandex.ai if the problem persists.")
+}
+
+func startTrial() {
+	term.StartSpinner("")
+	cliTrialToken, apiErr := apiClient.CreateCliTrialSession()
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("error starting trial: %s", apiErr.Msg)
+	}
+
+	openUnauthenticatedCloudURL(
+		"Opening Plandex Cloud trial flow in your browser.",
+		fmt.Sprintf("/start?cliTrialToken=%s", cliTrialToken),
+	)
+
+	fmt.Println("\nCommand will continue automatically once you've started your trial...")
+	fmt.Println()
+	term.StartSpinner("")
+
+	startTime := time.Now()
+	expirationTime := startTime.Add(1 * time.Hour)
+
+	for time.Now().Before(expirationTime) {
+		cliTrialSession, apiErr := apiClient.GetCliTrialSession(cliTrialToken)
+
+		if apiErr != nil {
+			term.StopSpinner()
+			term.OutputErrorAndExit("error getting cli trial session: %s", apiErr.Msg)
+		}
+
+		if cliTrialSession != nil {
+			// Trial session is valid, break the loop and sign in
+			term.StopSpinner()
+			fmt.Println("🚀 Trial started")
+			fmt.Println()
+			err := handleSignInResponse(cliTrialSession, "")
+			if err != nil {
+				term.OutputErrorAndExit("error signing in after trial started: %s", err)
+			}
+			return
+		}
+
+		time.Sleep(1500 * time.Millisecond)
+	}
+
+	term.StopSpinner()
+	term.OutputErrorAndExit("Timed out waiting for trial to start. Please try again. Email support@plandex.ai if the problem persists.")
+}

app/cli/cmd/apply.go

@@ -0,0 +1,74 @@
+package cmd
+
+import (
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/plan_exec"
+	"plandex-cli/term"
+	"plandex-cli/types"
+
+	"github.com/spf13/cobra"
+)
+
+var autoCommit, skipCommit, autoExec bool
+
+func init() {
+	initApplyFlags(applyCmd, false)
+	initExecScriptFlags(applyCmd)
+	RootCmd.AddCommand(applyCmd)
+
+	applyCmd.Flags().BoolVar(&fullAuto, "full", false, "Apply the plan and debug in full auto mode")
+}
+
+var applyCmd = &cobra.Command{
+	Use:     "apply",
+	Aliases: []string{"ap"},
+	Short:   "Apply a plan to the project",
+	Run:     apply,
+}
+
+func apply(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if fullAuto {
+		term.StartSpinner("")
+		config := lib.MustGetCurrentPlanConfig()
+		_, updatedConfig, printFn := resolveAutoModeSilent(config)
+		lib.SetCachedPlanConfig(updatedConfig)
+		term.StopSpinner()
+		printFn()
+	}
+
+	mustSetPlanExecFlags(cmd, true)
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	applyFlags := types.ApplyFlags{
+		AutoConfirm: true,
+		AutoCommit:  autoCommit,
+		NoCommit:    skipCommit,
+		AutoExec:    autoExec,
+		NoExec:      noExec,
+		AutoDebug:   autoDebug,
+	}
+
+	tellFlags := types.TellFlags{
+		TellBg:      tellBg,
+		TellStop:    tellStop,
+		TellNoBuild: tellNoBuild,
+		AutoContext: tellAutoContext,
+		ExecEnabled: !noExec,
+		AutoApply:   tellAutoApply,
+	}
+
+	lib.MustApplyPlan(lib.ApplyPlanParams{
+		PlanId:     lib.CurrentPlanId,
+		Branch:     lib.CurrentBranch,
+		ApplyFlags: applyFlags,
+		TellFlags:  tellFlags,
+		OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
+	})
+}

app/cli/cmd/archive.go

@@ -0,0 +1,99 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+	"strings"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var archiveCmd = &cobra.Command{
+	Use:     "archive [name-or-index]",
+	Aliases: []string{"arc"},
+	Short:   "Archive a plan",
+	Args:    cobra.MaximumNArgs(1),
+	Run:     archive,
+}
+
+func init() {
+	RootCmd.AddCommand(archiveCmd)
+}
+
+func archive(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	var nameOrIdx string
+	if len(args) > 0 {
+		nameOrIdx = strings.TrimSpace(args[0])
+	}
+
+	var plan *shared.Plan
+
+	term.StartSpinner("")
+	plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
+	}
+
+	if len(plans) == 0 {
+		fmt.Println("🤷‍♂️ No plans available to archive")
+		return
+	}
+
+	if nameOrIdx == "" {
+		opts := make([]string, len(plans))
+		for i, p := range plans {
+			opts[i] = p.Name
+		}
+
+		selected, err := term.SelectFromList("Select a plan to archive", opts)
+		if err != nil {
+			term.OutputErrorAndExit("Error selecting plan: %v", err)
+		}
+
+		for _, p := range plans {
+			if p.Name == selected {
+				plan = p
+				break
+			}
+		}
+	} else {
+		idx, err := strconv.Atoi(nameOrIdx)
+		if err == nil && idx > 0 && idx <= len(plans) {
+			plan = plans[idx-1]
+		} else {
+			for _, p := range plans {
+				if p.Name == nameOrIdx {
+					plan = p
+					break
+				}
+			}
+		}
+	}
+
+	if plan == nil {
+		term.OutputErrorAndExit("Plan not found")
+	}
+
+	err := api.Client.ArchivePlan(plan.Id)
+	if err != nil {
+		term.OutputErrorAndExit("Error archiving plan: %v", err)
+	}
+
+	fmt.Printf("✅ Plan %s archived\n", color.New(color.Bold, term.ColorHiYellow).Sprint(plan.Name))
+
+	fmt.Println()
+
+	term.PrintCmds("", "plans --archived", "unarchive")
+}

app/cli/cmd/billing.go

@@ -0,0 +1,29 @@
+package cmd
+
+import (
+	"plandex-cli/auth"
+	"plandex-cli/term"
+	"plandex-cli/ui"
+
+	"github.com/spf13/cobra"
+)
+
+var billingCmd = &cobra.Command{
+	Use:   "billing",
+	Short: "Open the billing page in the browser",
+	Run:   billing,
+}
+
+func init() {
+	RootCmd.AddCommand(billingCmd)
+}
+
+func billing(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	if !auth.Current.IsCloud {
+		term.OutputErrorAndExit("This command is only available for Plandex Cloud accounts.")
+	}
+
+	ui.OpenAuthenticatedURL("Opening billing page in your default browser...", "/settings/billing")
+}

app/cli/cmd/branches.go

@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/format"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+
+	"github.com/fatih/color"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+)
+
+var branchesCmd = &cobra.Command{
+	Use:     "branches",
+	Aliases: []string{"br"},
+	Short:   "List plan branches",
+	Run:     branches,
+}
+
+func init() {
+	RootCmd.AddCommand(branchesCmd)
+}
+
+func branches(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+
+	branches, apiErr := api.Client.ListBranches(lib.CurrentPlanId)
+
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting branches: %v", apiErr)
+		return
+	}
+
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetAutoWrapText(false)
+	table.SetHeader([]string{"#", "Name", "Updated" /* "Created",*/, "Context", "Convo"})
+
+	for i, b := range branches {
+		num := strconv.Itoa(i + 1)
+		if b.Name == lib.CurrentBranch {
+			num = color.New(color.Bold, term.ColorHiGreen).Sprint(num)
+		}
+
+		var name string
+		if b.Name == lib.CurrentBranch {
+			name = color.New(color.Bold, term.ColorHiGreen).Sprint(b.Name) + " 👈"
+		} else {
+			name = b.Name
+		}
+
+		row := []string{
+			num,
+			name,
+			format.Time(b.UpdatedAt),
+			// format.Time(b.CreatedAt),
+			strconv.Itoa(b.ContextTokens) + " 🪙",
+			strconv.Itoa(b.ConvoTokens) + " 🪙",
+		}
+
+		var style []tablewriter.Colors
+		if b.Name == lib.CurrentPlanId {
+			style = []tablewriter.Colors{
+				{tablewriter.FgGreenColor, tablewriter.Bold},
+			}
+		} else {
+			style = []tablewriter.Colors{
+				{tablewriter.Bold},
+			}
+		}
+
+		table.Rich(row, style)
+
+	}
+	table.Render()
+	fmt.Println()
+	term.PrintCmds("", "checkout", "delete-branch")
+
+}

app/cli/cmd/browser.go

@@ -0,0 +1,259 @@
+package cmd
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+
+	chrome_log "github.com/chromedp/cdproto/log"
+	chrome_runtime "github.com/chromedp/cdproto/runtime"
+	"github.com/chromedp/cdproto/target"
+	"github.com/chromedp/chromedp"
+	"github.com/spf13/cobra"
+)
+
+var timeoutSeconds int
+
+// browserCmd is our cobra command
+var browserCmd = &cobra.Command{
+	Use:   "browser [urls...]",
+	Short: "Open browser windows with given URLs, capturing console logs and exiting on JS errors",
+	RunE:  browser,
+}
+
+func init() {
+	RootCmd.AddCommand(browserCmd)
+	browserCmd.Flags().IntVar(&timeoutSeconds, "timeout", 10, "Timeout in seconds for browser to load")
+}
+
+// browser is the main function for our command.
+func browser(cmd *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return errors.New("no URLs provided")
+	}
+
+	// See if we can find Chrome or Firefox in PATH:
+	chromePath, _ := findChrome()
+
+	if chromePath != "" {
+		fmt.Println("Using Chrome (not default browser, but found in PATH).")
+		return openChromeWithLogs(args)
+	}
+
+	// Fallback: open with OS default tool (open/xdg-open)
+	fmt.Println("No Chrome or Firefox found; falling back to OS default opener.")
+	return openWithOSDefault(args)
+}
+
+// findChrome returns the path to Chrome/Chromium if found, or "" if not found.
+func findChrome() (string, error) {
+	switch runtime.GOOS {
+	case "darwin":
+		// macOS standard installation paths
+		macPaths := []string{
+			"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+			"/Applications/Chromium.app/Contents/MacOS/Chromium",
+		}
+		for _, p := range macPaths {
+			if _, err := os.Stat(p); err == nil {
+				return p, nil
+			}
+		}
+	case "linux", "freebsd":
+		// Linux/FreeBSD (usually in PATH)
+		candidates := []string{
+			"google-chrome",
+			"google-chrome-stable",
+			"chromium",
+			"chromium-browser",
+		}
+		for _, c := range candidates {
+			if path, err := exec.LookPath(c); err == nil {
+				return path, nil
+			}
+		}
+	}
+	return "", errors.New("Chrome/Chromium not found")
+}
+
+var pages = map[target.ID]string{}
+
+// openChromeWithLogs uses chromedp to open each URL in a visible Chrome browser,
+// logs JS console messages, and exits on the first JS error (or if user presses Ctrl+C).
+func openChromeWithLogs(urls []string) error {
+	if len(urls) == 0 {
+		return errors.New("no URLs provided")
+	}
+
+	fmt.Println("Launching Chrome with console log capture...")
+	// 1) Create a cancellable context that sets up a Chrome ExecAllocator
+	rootCtx, cancelAllocator := chromedp.NewExecAllocator(context.Background(),
+		chromedp.Flag("headless", false), // Visible, not headless
+		chromedp.Flag("disable-gpu", false),
+		chromedp.Flag("no-first-run", true),             // Avoid "Welcome" dialog
+		chromedp.Flag("no-default-browser-check", true), // Avoid default browser dialog
+		chromedp.Flag("disable-default-apps", true),     // Prevent default apps/extensions from loading
+		chromedp.Flag("remote-debugging-port", "0"),     // Ensures separate debug session
+	)
+	defer cancelAllocator()
+
+	// 2) Create a new browser context from the allocator
+	browserCtx, cancelBrowser := chromedp.NewContext(rootCtx)
+	defer cancelBrowser()
+
+	// Add this to get the initial target
+	var initialTargetID target.ID
+	chromedp.ListenTarget(browserCtx, func(ev interface{}) {
+		if e, ok := ev.(*target.EventTargetCreated); ok {
+			// fmt.Printf("[DEBUG] Got event: %#v\n", e)
+			if e.TargetInfo.Type == "page" {
+				initialTargetID = e.TargetInfo.TargetID
+			}
+		}
+	})
+
+	if err := chromedp.Run(
+		browserCtx,
+		chrome_runtime.Enable(),
+		chrome_log.Enable(),
+	); err != nil {
+		log.Fatal(err)
+	}
+
+	// Listen for console API calls & JS exceptions
+	chromedp.ListenBrowser(browserCtx, func(ev interface{}) {
+		// fmt.Printf("[DEBUG] Got event: %#v\n", ev)
+		switch e := ev.(type) {
+
+		case *target.EventTargetCreated:
+		case *target.EventAttachedToTarget:
+			// This sometimes also includes target info
+			info := e.TargetInfo
+			if info.Type == "page" {
+				url := info.URL
+				if url == "about:blank" {
+					url = urls[0]
+				}
+				pages[info.TargetID] = url
+			}
+
+		case *target.EventTargetDestroyed:
+			// Something was destroyed
+			destroyedID := e.TargetID
+			// Check if it was a top-level page
+			if url, ok := pages[destroyedID]; ok {
+				fmt.Printf("[CHROME] Closed page: %s\n", url)
+				// remove from map
+				delete(pages, destroyedID)
+				// If that was your last page, do something:
+				if len(pages) == 0 {
+					cancelBrowser()
+					cancelAllocator()
+					os.Exit(0)
+				} else {
+					fmt.Printf("num pages left: %d\n", len(pages))
+				}
+			}
+		}
+	})
+
+	// Channels to handle signals & error detection
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+
+	errChan := make(chan bool, 1)
+
+	// 3) Open all URLs in new tabs
+	for i, url := range urls {
+		// Reuse the initial browser tab for the first URL
+		var ctx context.Context
+		if i == 0 {
+			ctx, _ = chromedp.NewContext(browserCtx, chromedp.WithTargetID(initialTargetID))
+		} else {
+			// Create a new tab for each additional URL
+			ctx, _ = chromedp.NewContext(browserCtx)
+		}
+		tabCtx, _ := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+
+		chromedp.ListenTarget(tabCtx, func(ev interface{}) {
+			switch e := ev.(type) {
+			case *chrome_runtime.EventConsoleAPICalled:
+				logType := e.Type.String()
+				for _, arg := range e.Args {
+					val := arg.Value
+					fmt.Printf("[CHROME:%s] %v\n", logType, val)
+					if logType == "error" {
+						fmt.Println("❌ Chrome console error")
+						errChan <- true
+					}
+				}
+			case *chrome_log.EventEntryAdded:
+				fmt.Printf("[CHROME:Log:%s] %s\n", e.Entry.Level, e.Entry.Text)
+			case *chrome_runtime.EventExceptionThrown:
+				fmt.Printf("[CHROME:Exception] %s\n", e.ExceptionDetails.Error())
+				fmt.Println("❌ JavaScript exception")
+				errChan <- true
+			}
+		})
+
+		if err := chromedp.Run(
+			tabCtx,
+			chrome_runtime.Enable(),
+			chrome_log.Enable(),
+			chromedp.Navigate(url),
+			chromedp.WaitReady("body", chromedp.ByQuery),
+		); err != nil {
+			fmt.Printf("Failed to load url %s: %v", url, err)
+			cancelBrowser()
+			cancelAllocator()
+			os.Exit(1)
+		} else {
+			fmt.Printf("Opened (%d/%d): %s\n", i+1, len(urls), url)
+		}
+	}
+
+	fmt.Println("Chrome is running, waiting for error or interrupt...")
+
+	// 4) Wait forever, or until an error or signal
+	select {
+	case <-sigChan:
+		fmt.Println("\n⚠️  Plandex browser process interrupted")
+		return nil
+	case <-rootCtx.Done():
+		fmt.Println("\n⚠️  Plandex browser process closed")
+		return nil
+	case <-errChan:
+		fmt.Println("\n❌ Plandex browser process exited due to JavaScript error")
+		cancelBrowser()
+		cancelAllocator()
+		os.Exit(1)
+	}
+	return nil
+}
+
+func openWithOSDefault(urls []string) error {
+	var openCmd string
+	switch runtime.GOOS {
+	case "darwin":
+		openCmd = "open"
+	case "linux", "freebsd":
+		openCmd = "xdg-open"
+	default:
+		return errors.New("unsupported OS for fallback")
+	}
+
+	for _, url := range urls {
+		cmd := exec.Command(openCmd, url)
+		if err := cmd.Start(); err != nil {
+			log.Printf("Failed to open %s with %s: %v", url, openCmd, err)
+		}
+	}
+	return nil
+}

app/cli/cmd/build.go

@@ -0,0 +1,98 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/plan_exec"
+	"plandex-cli/term"
+	"plandex-cli/types"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+var buildCmd = &cobra.Command{
+	Use:     "build",
+	Aliases: []string{"b"},
+	Short:   "Build pending changes",
+	// Long:  ``,
+	Args: cobra.NoArgs,
+	Run:  build,
+}
+
+func init() {
+	RootCmd.AddCommand(buildCmd)
+
+	initExecFlags(buildCmd, initExecFlagsParams{
+		omitFile:         true,
+		omitNoBuild:      true,
+		omitEditor:       true,
+		omitStop:         true,
+		omitAutoContext:  true,
+		omitSmartContext: true,
+	})
+}
+
+func build(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	mustSetPlanExecFlags(cmd, false)
+
+	didBuild, err := plan_exec.Build(plan_exec.ExecParams{
+		CurrentPlanId: lib.CurrentPlanId,
+		CurrentBranch: lib.CurrentBranch,
+		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
+		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
+			auto := autoConfirm || tellAutoApply || tellAutoContext
+			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
+		},
+	}, types.BuildFlags{
+		BuildBg:   tellBg,
+		AutoApply: tellAutoApply,
+	})
+
+	if err != nil {
+		term.OutputErrorAndExit("Error building plan: %v", err)
+	}
+
+	if !didBuild {
+		fmt.Println()
+		term.PrintCmds("", "log", "tell", "continue")
+		return
+	}
+
+	if tellBg {
+		fmt.Println("🏗️ Building plan in the background")
+		fmt.Println()
+		term.PrintCmds("", "ps", "connect", "stop")
+	} else if tellAutoApply {
+		applyFlags := types.ApplyFlags{
+			AutoConfirm: true,
+			AutoCommit:  autoCommit,
+			NoCommit:    !autoCommit,
+			NoExec:      noExec,
+			AutoExec:    autoExec,
+			AutoDebug:   autoDebug,
+		}
+
+		tellFlags := types.TellFlags{
+			AutoContext: tellAutoContext,
+			ExecEnabled: !noExec,
+			AutoApply:   tellAutoApply,
+		}
+
+		lib.MustApplyPlan(lib.ApplyPlanParams{
+			PlanId:     lib.CurrentPlanId,
+			Branch:     lib.CurrentBranch,
+			ApplyFlags: applyFlags,
+			TellFlags:  tellFlags,
+			OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
+		})
+	} else {
+		fmt.Println()
+		term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")
+	}
+}

app/cli/cmd/cd.go

@@ -0,0 +1,119 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+	"strings"
+	"time"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(cdCmd)
+}
+
+var cdCmd = &cobra.Command{
+	Use:     "cd [name-or-index]",
+	Aliases: []string{"set-plan"},
+	Short:   "Set current plan by name or index",
+	Args:    cobra.MaximumNArgs(1),
+	Run:     cd,
+}
+
+func cd(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	var nameOrIdx string
+	if len(args) > 0 {
+		nameOrIdx = strings.TrimSpace(args[0])
+	}
+
+	var plan *shared.Plan
+
+	term.StartSpinner("")
+	plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
+	}
+
+	if len(plans) == 0 {
+		fmt.Println("🤷‍♂️ No plans")
+		fmt.Println()
+		term.PrintCmds("", "new")
+		return
+	}
+
+	if nameOrIdx == "" {
+
+		opts := make([]string, len(plans))
+		for i, plan := range plans {
+			opts[i] = plan.Name
+		}
+
+		selected, err := term.SelectFromList("Select a plan", opts)
+
+		if err != nil {
+			term.OutputErrorAndExit("Error selecting plan: %v", err)
+		}
+
+		for _, p := range plans {
+			if p.Name == selected {
+				plan = p
+				break
+			}
+		}
+	} else {
+		// see if it's an index
+		idx, err := strconv.Atoi(nameOrIdx)
+
+		if err == nil {
+			if idx > 0 && idx <= len(plans) {
+				plan = plans[idx-1]
+			} else {
+				term.OutputErrorAndExit("Plan index out of range")
+			}
+		} else {
+			for _, p := range plans {
+				if p.Name == nameOrIdx {
+					plan = p
+					break
+				}
+			}
+		}
+	}
+
+	if plan == nil {
+		term.OutputErrorAndExit("Plan not found")
+	}
+
+	err := lib.WriteCurrentPlan(plan.Id)
+	if err != nil {
+		term.OutputErrorAndExit("Error setting current plan: %v", err)
+	}
+
+	// reload current plan, which will also handle setting the right branch
+	lib.MustLoadCurrentPlan()
+
+	// fire and forget SetProjectPlan request (we don't care about the response or errors)
+	// this only matters for setting the current plan on a new device (i.e. when the current plan is not set)
+	go api.Client.SetProjectPlan(lib.CurrentProjectId, shared.SetProjectPlanRequest{PlanId: plan.Id})
+
+	// give the SetProjectPlan request some time to be sent before exiting
+	time.Sleep(50 * time.Millisecond)
+
+	fmt.Println("✅ Changed current plan to " + color.New(term.ColorHiGreen, color.Bold).Sprint(plan.Name))
+
+	fmt.Println()
+	term.PrintCmds("", "current")
+}

app/cli/cmd/chat.go

@@ -0,0 +1,64 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/plan_exec"
+	"plandex-cli/types"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+var chatCmd = &cobra.Command{
+	Use:     "chat [prompt]",
+	Aliases: []string{"c"},
+	Short:   "Chat without making changes",
+	// Long:  ``,
+	Args: cobra.RangeArgs(0, 1),
+	Run:  doChat,
+}
+
+func init() {
+	RootCmd.AddCommand(chatCmd)
+
+	initExecFlags(chatCmd, initExecFlagsParams{
+		omitNoBuild:      true,
+		omitStop:         true,
+		omitBg:           true,
+		omitApply:        true,
+		omitExec:         true,
+		omitSmartContext: true,
+		omitSkipMenu:     true,
+	})
+
+}
+
+func doChat(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+	mustSetPlanExecFlags(cmd, false)
+
+	prompt := getTellPrompt(args)
+
+	if prompt == "" {
+		fmt.Println("🤷‍♂️ No prompt to send")
+		return
+	}
+
+	plan_exec.TellPlan(plan_exec.ExecParams{
+		CurrentPlanId: lib.CurrentPlanId,
+		CurrentBranch: lib.CurrentBranch,
+		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
+		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
+			auto := autoConfirm || tellAutoApply || tellAutoContext
+			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
+		},
+	}, prompt, types.TellFlags{
+		IsChatOnly:      true,
+		AutoContext:     tellAutoContext,
+		SkipChangesMenu: tellSkipMenu,
+	})
+}

app/cli/cmd/checkout.go

@@ -0,0 +1,172 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+	"strings"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+const (
+	OptCreateNewBranch = "Create a new branch"
+)
+
+var confirmCreateBranch bool
+
+var checkoutCmd = &cobra.Command{
+	Use:     "checkout [name-or-index]",
+	Aliases: []string{"co"},
+	Short:   "Checkout an existing plan branch or create a new one",
+	Run:     checkout,
+	Args:    cobra.MaximumNArgs(1),
+}
+
+func init() {
+	RootCmd.AddCommand(checkoutCmd)
+	checkoutCmd.Flags().BoolVarP(&confirmCreateBranch, "yes", "y", false, "Confirm creating a new branch")
+}
+
+func checkout(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	branchName := ""
+	willCreate := false
+
+	var nameOrIdx string
+	if len(args) > 0 {
+		nameOrIdx = strings.TrimSpace(args[0])
+	}
+
+	term.StartSpinner("")
+	branches, apiErr := api.Client.ListBranches(lib.CurrentPlanId)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting branches: %v", apiErr)
+		return
+	}
+
+	if nameOrIdx != "" {
+		idx, err := strconv.Atoi(nameOrIdx)
+
+		if err == nil {
+			if idx > 0 && idx <= len(branches) {
+				branchName = branches[idx-1].Name
+			} else {
+				term.OutputErrorAndExit("Branch %d not found", idx)
+			}
+		} else {
+			for _, b := range branches {
+				if b.Name == nameOrIdx {
+					branchName = b.Name
+					break
+				}
+			}
+		}
+
+		if branchName == "" {
+			fmt.Printf("🌱 Branch %s not found\n", color.New(color.Bold, term.ColorHiCyan).Sprint(nameOrIdx))
+
+			if confirmCreateBranch {
+				fmt.Println("✅ --yes flag set, will create branch")
+				branchName = nameOrIdx
+				willCreate = true
+			} else {
+				res, err := term.ConfirmYesNo("Create it now?")
+
+				if err != nil {
+					term.OutputErrorAndExit("Error getting user input: %v", err)
+				}
+
+				if res {
+					branchName = nameOrIdx
+					willCreate = true
+				} else {
+					return
+				}
+			}
+		}
+
+	}
+
+	if nameOrIdx == "" {
+		opts := make([]string, len(branches))
+		for i, branch := range branches {
+			opts[i] = branch.Name
+		}
+		opts = append(opts, OptCreateNewBranch)
+
+		selected, err := term.SelectFromList("Select a branch", opts)
+
+		if err != nil {
+			term.OutputErrorAndExit("Error selecting branch: %v", err)
+			return
+		}
+
+		if selected == OptCreateNewBranch {
+			branchName, err = term.GetRequiredUserStringInput("Branch name")
+			if err != nil {
+				term.OutputErrorAndExit("Error getting branch name: %v", err)
+				return
+			}
+			willCreate = true
+		} else {
+			branchName = selected
+		}
+	}
+
+	if branchName == "" {
+		term.OutputErrorAndExit("Branch not found")
+	}
+
+	term.StartSpinner("")
+	if willCreate {
+		err := api.Client.CreateBranch(lib.CurrentPlanId, lib.CurrentBranch, shared.CreateBranchRequest{Name: branchName})
+
+		if err != nil {
+			term.OutputErrorAndExit("Error creating branch: %v", err)
+			return
+		}
+
+		// fmt.Printf("✅ Created branch %s\n", color.New(color.Bold, term.ColorHiGreen).Sprint(branchName))
+	}
+
+	err := lib.WriteCurrentBranch(branchName)
+
+	if err != nil {
+		term.OutputErrorAndExit("Error setting current branch: %v", err)
+		return
+	}
+
+	updatedModelSettings, err := lib.SaveLatestPlanModelSettingsIfNeeded()
+	term.StopSpinner()
+	if err != nil {
+		term.OutputErrorAndExit("Error saving model settings: %v", err)
+	}
+
+	term.StopSpinner()
+
+	fmt.Printf("✅ Checked out branch %s\n", color.New(color.Bold, term.ColorHiGreen).Sprint(branchName))
+
+	if updatedModelSettings {
+		fmt.Println()
+		fmt.Println("🧠 Model settings file updated → ", lib.GetPlanModelSettingsPath(lib.CurrentPlanId))
+	}
+
+	fmt.Println()
+	term.PrintCmds("", "load", "tell", "branches", "delete-branch")
+
+}

app/cli/cmd/claude_max.go

@@ -0,0 +1,75 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var connectClaudeCmd = &cobra.Command{
+	Use:   "connect-claude",
+	Short: "Connect your Claude Pro or Max subscription",
+	Run:   connectClaude,
+}
+
+var disconnectClaudeCmd = &cobra.Command{
+	Use:   "disconnect-claude",
+	Short: "Disconnect your Claude Pro or Max subscription",
+	Run:   disconnectClaude,
+}
+
+var claudeStatusCmd = &cobra.Command{
+	Use:   "claude-status",
+	Short: "Check the status of your Claude Pro or Max subscription",
+	Run:   claudeStatus,
+}
+
+func connectClaude(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.ConnectClaudeMax()
+}
+
+func disconnectClaude(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.DisconnectClaudeMax()
+}
+
+func claudeStatus(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	creds, err := lib.GetAccountCredentials()
+	if err != nil {
+		term.OutputErrorAndExit("Error getting account credentials: %v", err)
+	}
+
+	orgUserConfig := lib.MustGetOrgUserConfig()
+
+	connected := creds.ClaudeMax != nil && orgUserConfig.UseClaudeSubscription
+
+	if connected {
+		fmt.Println("✅ Claude Pro or Max subscription is connected")
+
+		// if orgUserConfig.IsClaudeSubscriptionCooldownActive() {
+		if true {
+			fmt.Println()
+			color.New(term.ColorHiYellow, color.Bold).Println("⏳ You've reached your Claude Pro or Max subscription quota")
+			fmt.Println("The next provider with valid credentials will be used for Anthropic models until the quota resets")
+			fmt.Println()
+		}
+
+		term.PrintCmds("", "disconnect-claude")
+	} else {
+		fmt.Println("❌ No Claude Pro or Max subscription is connected")
+		term.PrintCmds("", "connect-claude")
+	}
+}
+
+func init() {
+	RootCmd.AddCommand(connectClaudeCmd)
+	RootCmd.AddCommand(disconnectClaudeCmd)
+	RootCmd.AddCommand(claudeStatusCmd)
+}

app/cli/cmd/clear.go

@@ -0,0 +1,62 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+var clearCmd = &cobra.Command{
+	Use:   "clear",
+	Short: "Clear all context",
+	Long:  `Clear all context.`,
+	Run:   clearAllContext,
+}
+
+func clearAllContext(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error retrieving context: %v", err)
+	}
+
+	deleteIds := map[string]bool{}
+
+	for _, context := range contexts {
+		deleteIds[context.Id] = true
+	}
+
+	if len(deleteIds) > 0 {
+		res, err := api.Client.DeleteContext(lib.CurrentPlanId, lib.CurrentBranch, shared.DeleteContextRequest{
+			Ids: deleteIds,
+		})
+
+		if err != nil {
+			term.OutputErrorAndExit("Error deleting context: %v", err)
+		}
+
+		fmt.Println("✅ " + res.Msg)
+	} else {
+		fmt.Println("🤷‍♂️ No context removed")
+	}
+
+}
+
+func init() {
+	RootCmd.AddCommand(clearCmd)
+}

app/cli/cmd/config.go

@@ -0,0 +1,74 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(configCmd)
+	configCmd.AddCommand(defaultConfigCmd)
+}
+
+var configCmd = &cobra.Command{
+	Use:   "config",
+	Short: "Show plan config",
+	Run:   config,
+}
+
+var defaultConfigCmd = &cobra.Command{
+	Use:   "default",
+	Short: "Show default config for new plans",
+	Run:   defaultConfig,
+}
+
+func config(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+
+	config, apiErr := api.Client.GetPlanConfig(lib.CurrentPlanId)
+	if apiErr != nil {
+		term.StopSpinner()
+		term.OutputErrorAndExit("Error getting config: %v", apiErr.Msg)
+		return
+	}
+
+	term.StopSpinner()
+
+	color.New(color.Bold, term.ColorHiCyan).Println("⚙️  Plan Config")
+	lib.ShowPlanConfig(config, "")
+	fmt.Println()
+
+	term.PrintCmds("", "set-config", "config default", "set-config default")
+}
+
+func defaultConfig(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuth(false)
+
+	term.StartSpinner("")
+	config, err := api.Client.GetDefaultPlanConfig()
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error getting default config: %v", err)
+		return
+	}
+
+	color.New(color.Bold, term.ColorHiCyan).Println("⚙️  Default Config")
+	lib.ShowPlanConfig(config, "")
+	fmt.Println()
+
+	term.PrintCmds("", "set-config default", "config", "set-config")
+}

app/cli/cmd/connect.go

@@ -0,0 +1,67 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/stream"
+	streamtui "plandex-cli/stream_tui"
+	"plandex-cli/term"
+
+	"github.com/spf13/cobra"
+)
+
+var connectCmd = &cobra.Command{
+	Use:     "connect [stream-id-or-plan] [branch]",
+	Aliases: []string{"conn"},
+	Short:   "Connect to an active stream",
+	// Long:  ``,
+	Args: cobra.MaximumNArgs(2),
+	Run:  connect,
+}
+
+func init() {
+	RootCmd.AddCommand(connectCmd)
+
+}
+
+func connect(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	planId, branch, shouldContinue := lib.SelectActiveStream(args)
+
+	if !shouldContinue {
+		return
+	}
+
+	term.StartSpinner("")
+	apiErr := api.Client.ConnectPlan(planId, branch, stream.OnStreamPlan)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error connecting to stream: %v", apiErr)
+	}
+
+	go func() {
+		err := streamtui.StartStreamUI("", false, true)
+
+		if err != nil {
+			term.OutputErrorAndExit("Error starting stream UI", err)
+		}
+
+		fmt.Println()
+		term.PrintCmds("", "diff", "diff --ui", "apply", "reject", "log")
+
+		os.Exit(0)
+	}()
+
+	// Wait for the stream to finish
+	select {}
+}

app/cli/cmd/context_show.go

@@ -0,0 +1,69 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"strconv"
+
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	RootCmd.AddCommand(contextShowCmd)
+}
+
+var contextShowCmd = &cobra.Command{
+	Use:   "show [name-or-index]",
+	Short: "Show the body of a context by name or list index",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		auth.MustResolveAuthWithOrg()
+		lib.MustResolveProject()
+
+		nameOrIndex := args[0]
+
+		// Get list of contexts first
+		contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
+		if err != nil {
+			log.Printf("Error listing contexts: %v\n", err)
+			return fmt.Errorf("error listing contexts: %v", err)
+		}
+
+		var contextId string
+
+		// Try parsing as index first
+		if idx, err := strconv.Atoi(nameOrIndex); err == nil {
+			// Convert to 0-based index
+			idx--
+			if idx < 0 || idx >= len(contexts) {
+				return fmt.Errorf("invalid context index: %s", nameOrIndex)
+			}
+			contextId = contexts[idx].Id
+		} else {
+			// Try finding by name
+			found := false
+			for _, ctx := range contexts {
+				if ctx.Name == nameOrIndex || ctx.FilePath == nameOrIndex {
+					contextId = ctx.Id
+					found = true
+					break
+				}
+			}
+			if !found {
+				return fmt.Errorf("no context found with name: %s", nameOrIndex)
+			}
+		}
+
+		res, apiErr := api.Client.GetContextBody(lib.CurrentPlanId, lib.CurrentBranch, contextId)
+		if apiErr != nil {
+			log.Printf("Error getting context body: %v\n", apiErr)
+			return fmt.Errorf("error getting context body: %v", apiErr)
+		}
+
+		fmt.Println(res.Body)
+		return nil
+	},
+}

app/cli/cmd/continue.go

@@ -0,0 +1,83 @@
+package cmd
+
+import (
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/plan_exec"
+	"plandex-cli/types"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	chatOnly bool
+)
+
+var continueCmd = &cobra.Command{
+	Use:     "continue",
+	Aliases: []string{"c"},
+	Short:   "Continue the plan",
+	Run:     doContinue,
+}
+
+func init() {
+	RootCmd.AddCommand(continueCmd)
+
+	continueCmd.Flags().BoolVar(&chatOnly, "chat", false, "Continue in chat mode (no file changes)")
+
+	initExecFlags(continueCmd, initExecFlagsParams{
+		omitFile:   true,
+		omitEditor: true,
+	})
+}
+
+func doContinue(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+	mustSetPlanExecFlags(cmd, false)
+
+	tellFlags := types.TellFlags{
+		TellBg:          tellBg,
+		TellStop:        tellStop,
+		TellNoBuild:     tellNoBuild,
+		IsUserContinue:  true,
+		ExecEnabled:     !noExec,
+		AutoContext:     tellAutoContext,
+		SmartContext:    tellSmartContext,
+		AutoApply:       tellAutoApply,
+		IsChatOnly:      chatOnly,
+		SkipChangesMenu: tellSkipMenu,
+	}
+
+	plan_exec.TellPlan(plan_exec.ExecParams{
+		CurrentPlanId: lib.CurrentPlanId,
+		CurrentBranch: lib.CurrentBranch,
+		AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
+		CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
+			auto := autoConfirm || tellAutoApply || tellAutoContext
+
+			return lib.CheckOutdatedContextWithOutput(auto, auto, maybeContexts, projectPaths)
+		},
+	}, "", tellFlags)
+
+	if tellAutoApply {
+		applyFlags := types.ApplyFlags{
+			AutoConfirm: true,
+			AutoCommit:  autoCommit,
+			NoCommit:    !autoCommit,
+			AutoExec:    autoExec,
+			NoExec:      noExec,
+			AutoDebug:   autoDebug,
+		}
+
+		lib.MustApplyPlan(lib.ApplyPlanParams{
+			PlanId:     lib.CurrentPlanId,
+			Branch:     lib.CurrentBranch,
+			ApplyFlags: applyFlags,
+			TellFlags:  tellFlags,
+			OnExecFail: plan_exec.GetOnApplyExecFail(applyFlags, tellFlags),
+		})
+	}
+}

app/cli/cmd/convo.go

@@ -0,0 +1,193 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var plainTextOutput bool
+var convoRaw bool
+
+// convoCmd represents the convo command
+var convoCmd = &cobra.Command{
+	Use:   "convo [msg-range]",
+	Short: "Display complete conversation history",
+	Long:  `Display complete conversation history. Optionally specify a message number or range of messages (e.g. '1' or '5' or '1-5' or '5-')`,
+	Run:   convo,
+}
+
+func init() {
+	RootCmd.AddCommand(convoCmd)
+
+	convoCmd.Flags().BoolVarP(&plainTextOutput, "plain", "p", false, "Output conversation in plain text with no ANSI codes")
+
+	// for debugging output
+	convoCmd.Flags().BoolVar(&convoRaw, "raw", false, "Output conversation in raw format")
+	convoCmd.Flags().MarkHidden("raw")
+}
+
+const stoppedEarlyMsg = "You stopped the reply early"
+
+func convo(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	term.StartSpinner("")
+	conversation, apiErr := api.Client.ListConvo(lib.CurrentPlanId, lib.CurrentBranch)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error loading conversation: %v", apiErr.Msg)
+	}
+
+	if len(conversation) == 0 {
+		fmt.Println("🤷‍♂️ No conversation history")
+		return
+	}
+
+	var msgRange string
+	var msgRangeStart, msgRangeEnd int
+	if len(args) > 0 {
+		msgRange = args[0]
+	}
+	if msgRange != "" {
+		// validate either a number or a range of numbers
+		if strings.Contains(msgRange, "-") {
+			_, err := fmt.Sscanf(msgRange, "%d-%d", &msgRangeStart, &msgRangeEnd)
+			if err != nil {
+				_, err := fmt.Sscanf(msgRange, "%d-", &msgRangeStart)
+
+				if err != nil {
+					term.OutputErrorAndExit("Invalid message range: %s", msgRange)
+				}
+
+				msgRangeEnd = len(conversation)
+			}
+		} else {
+			_, err := fmt.Sscanf(msgRange, "%d", &msgRangeStart)
+			if err != nil {
+				term.OutputErrorAndExit("Invalid message number: %s", msgRange)
+			}
+			msgRangeEnd = msgRangeStart
+		}
+	}
+
+	var convo string
+	var totalTokens int
+	var didCut bool
+	for i, msg := range conversation {
+		if msgRangeStart > 0 && msg.Num < msgRangeStart {
+			didCut = true
+			continue
+		}
+		if msgRangeEnd > 0 && msg.Num > msgRangeEnd {
+			didCut = true
+			break
+		}
+
+		var author string
+		if msg.Role == "assistant" {
+			author = "🤖 Plandex"
+		} else if msg.Role == "user" {
+			author = "💬 You"
+		} else {
+			author = msg.Role
+		}
+
+		replyTags := msg.Flags.GetReplyTags()
+
+		// format as above but start with day of week
+		formattedTs := msg.CreatedAt.Local().Format("Mon Jan 2, 2006 | 3:04pm MST")
+
+		// if it's today then use 'Today' instead of the date
+		if msg.CreatedAt.Day() == time.Now().Day() {
+			formattedTs = msg.CreatedAt.Local().Format("Today | 3:04pm MST")
+		}
+
+		// if it's yesterday then use 'Yesterday' instead of the date
+		if msg.CreatedAt.Day() == time.Now().AddDate(0, 0, -1).Day() {
+			formattedTs = msg.CreatedAt.Local().Format("Yesterday | 3:04pm MST")
+		}
+
+		var header string
+		if len(replyTags) > 0 {
+			header = fmt.Sprintf("#### %d | %s | %s | %s | %d 🪙 ", i+1,
+				author, strings.Join(replyTags, " | "), formattedTs, msg.Tokens)
+		} else {
+			header = fmt.Sprintf("#### %d | %s | %s | %d 🪙 ", i+1,
+				author, formattedTs, msg.Tokens)
+		}
+
+		txt := msg.Message
+		if !convoRaw {
+			txt = convertCodeBlocks(msg.Message)
+		}
+
+		if plainTextOutput {
+			convo += header + "\n" + txt + "\n\n"
+		} else {
+			md, err := term.GetMarkdown(header + "\n" + txt + "\n\n")
+			if err != nil {
+				term.OutputErrorAndExit("Error creating markdown representation: %v", err)
+			}
+			convo += md
+		}
+
+		if !didCut && msg.Stopped {
+			if plainTextOutput {
+				convo += fmt.Sprintf(" 🛑 %s\n\n", stoppedEarlyMsg)
+			} else {
+				convo += fmt.Sprintf(" 🛑 %s\n\n", color.New(color.Bold).Sprint(stoppedEarlyMsg))
+			}
+		}
+
+		totalTokens += msg.Tokens
+	}
+
+	if !plainTextOutput {
+		convo = strings.ReplaceAll(convo, stoppedEarlyMsg, color.New(term.ColorHiRed).Sprint(stoppedEarlyMsg))
+	}
+
+	output :=
+		fmt.Sprintf("\n%s", convo)
+
+	if !plainTextOutput && !didCut {
+		output += term.GetDivisionLine() +
+			color.New(color.Bold, term.ColorHiCyan).Sprint("  Conversation size →") + fmt.Sprintf(" %d 🪙", totalTokens) + "\n\n"
+	}
+
+	if plainTextOutput {
+		fmt.Println(output)
+	} else {
+		term.PageOutput(output)
+
+		fmt.Println()
+		term.PrintCmds("", "convo 1", "convo 2-5", "convo --plain", "log")
+	}
+}
+
+var codeBlockPattern = regexp.MustCompile(`<PlandexBlock\s+lang="(.+?)".*?>([\s\S]+?)</PlandexBlock>`)
+
+func convertCodeBlocks(msg string) string {
+	return codeBlockPattern.ReplaceAllStringFunc(msg, func(match string) string {
+		// Extract language and content from the match
+		submatches := codeBlockPattern.FindStringSubmatch(match)
+		lang := submatches[1]
+		content := submatches[2]
+
+		// Escape any backticks in the content
+		content = strings.ReplaceAll(content, "```", "\\`\\`\\`")
+
+		// Return markdown code block format
+		return fmt.Sprintf("```%s%s```", lang, content)
+	})
+}

app/cli/cmd/current.go

@@ -0,0 +1,58 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+var currentCmd = &cobra.Command{
+	Use:     "current",
+	Aliases: []string{"cu"},
+	Short:   "Get the current plan",
+	Run:     current,
+}
+
+func init() {
+	RootCmd.AddCommand(currentCmd)
+}
+
+func current(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MaybeResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+	plan, err := api.Client.GetPlan(lib.CurrentPlanId)
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error getting plan: %v", err)
+		return
+	}
+
+	currentBranchesByPlanId, err := api.Client.GetCurrentBranchByPlanId(lib.CurrentProjectId, shared.GetCurrentBranchByPlanIdRequest{
+		CurrentBranchByPlanId: map[string]string{
+			lib.CurrentPlanId: lib.CurrentBranch,
+		},
+	})
+
+	if err != nil {
+		term.OutputErrorAndExit("Error getting current branches: %v", err)
+	}
+
+	table := lib.GetCurrentPlanTable(plan, currentBranchesByPlanId, nil)
+	fmt.Println(table)
+
+	term.PrintCmds("", "tell", "ls", "plans")
+
+}

app/cli/cmd/debug.go

@@ -0,0 +1,269 @@
+package cmd
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"os/signal"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/plan_exec"
+	"plandex-cli/term"
+	"plandex-cli/types"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"time"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+const DebugDefaultTries = 5
+
+var debugCmd = &cobra.Command{
+	Use:     "debug [tries] <cmd>",
+	Aliases: []string{"db"},
+	Short:   "Debug a failing command with Plandex",
+	Args:    cobra.MinimumNArgs(1),
+	Run:     doDebug,
+}
+
+func init() {
+	RootCmd.AddCommand(debugCmd)
+	debugCmd.Flags().BoolVarP(&autoCommit, "commit", "c", false, "Commit changes after successful execution")
+}
+
+func doDebug(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+	mustSetPlanExecFlags(cmd, false)
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	// Parse tries and command
+	tries := DebugDefaultTries
+	cmdArgs := args
+
+	// Check if first arg is tries count
+	if val, err := strconv.Atoi(args[0]); err == nil {
+		if val <= 0 {
+			term.OutputErrorAndExit("Tries must be greater than 0")
+		}
+		tries = val
+		cmdArgs = args[1:]
+		if len(cmdArgs) == 0 {
+			term.OutputErrorAndExit("No command specified")
+		}
+	}
+
+	// Get current working directory
+	cwd, err := os.Getwd()
+	if err != nil {
+		term.OutputErrorAndExit("Failed to get working directory: %v", err)
+	}
+
+	cmdStr := strings.Join(cmdArgs, " ")
+
+	// Execute command and handle retries
+	for attempt := 0; attempt < tries; attempt++ {
+		// Use shell to handle operators like && and |
+		shellCmdStr := "set -euo pipefail; " + cmdStr
+		execCmd := exec.Command("sh", "-c", shellCmdStr)
+		execCmd.Dir = cwd
+		execCmd.Env = os.Environ()
+		lib.SetPlatformSpecificAttrs(execCmd)
+
+		pipe, err := execCmd.StdoutPipe()
+		if err != nil {
+			term.StopSpinner()
+			term.OutputErrorAndExit("Failed to create pipe: %v", err)
+		}
+		execCmd.Stderr = execCmd.Stdout
+
+		if err := execCmd.Start(); err != nil {
+			term.StopSpinner()
+			term.OutputErrorAndExit("Failed to start command: %v", err)
+		}
+
+		maybeDeleteCgroup := lib.MaybeIsolateCgroup(execCmd)
+
+		ctx, cancel := context.WithCancel(context.Background())
+		var interrupted atomic.Bool
+		var interruptHandled atomic.Bool
+		var interruptWG sync.WaitGroup
+
+		sigChan := make(chan os.Signal, 1)
+		signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM, syscall.SIGHUP, syscall.SIGQUIT)
+
+		interruptWG.Add(1)
+		go func() {
+			defer interruptWG.Done()
+			for {
+				select {
+				case sig := <-sigChan:
+					if interruptHandled.CompareAndSwap(false, true) {
+						fmt.Println()
+						color.New(term.ColorHiYellow, color.Bold).Println("\n👉 Caught interrupt. Exiting gracefully...")
+						interrupted.Store(true)
+
+						var sysSig syscall.Signal
+
+						switch sig {
+						case os.Interrupt:
+							// user pressed Ctrl+C
+							sysSig = syscall.SIGINT
+						case syscall.SIGTERM:
+							// a polite "kill" request
+							sysSig = syscall.SIGTERM
+						case syscall.SIGHUP:
+							sysSig = syscall.SIGHUP
+						case syscall.SIGQUIT:
+							sysSig = syscall.SIGQUIT
+						default:
+							sysSig = syscall.SIGINT
+						}
+
+						if err := lib.KillProcessGroup(execCmd, sysSig); err != nil {
+							log.Printf("Failed to send signal %s to process group: %v", sysSig, err)
+						}
+
+						select {
+						case <-time.After(2 * time.Second):
+							color.New(term.ColorHiYellow, color.Bold).Println("👉 Commands didn't exit after 2 seconds. Sending SIGKILL.")
+							if err := lib.KillProcessGroup(execCmd, syscall.SIGKILL); err != nil {
+								log.Printf("Failed to send SIGKILL to process group: %v", err)
+							}
+							maybeDeleteCgroup()
+						case <-ctx.Done():
+							maybeDeleteCgroup()
+							return
+						}
+					}
+				case <-ctx.Done():
+					maybeDeleteCgroup()
+					return
+				}
+			}
+		}()
+
+		var outputBuilder strings.Builder
+		scanner := bufio.NewScanner(pipe)
+		go func() {
+			for scanner.Scan() {
+				line := scanner.Text()
+				fmt.Println(line)
+				outputBuilder.WriteString(line + "\n")
+			}
+		}()
+
+		waitErr := execCmd.Wait()
+
+		cancel()
+		interruptWG.Wait()
+		signal.Stop(sigChan)
+		close(sigChan)
+
+		if scanErr := scanner.Err(); scanErr != nil {
+			log.Printf("⚠️ Scanner error reading subprocess output: %v", scanErr)
+		}
+
+		term.StopSpinner()
+
+		outputStr := outputBuilder.String()
+		if outputStr == "" && waitErr != nil {
+			outputStr = waitErr.Error()
+		}
+
+		if outputStr != "" {
+			fmt.Println(outputStr)
+		}
+
+		didSucceed := waitErr == nil
+
+		if interrupted.Load() {
+			color.New(term.ColorHiYellow, color.Bold).Println("👉  Execution interrupted")
+
+			res, canceled, err := term.ConfirmYesNoCancel("Did the command succeed?")
+
+			if err != nil {
+				term.OutputErrorAndExit("Failed to get confirmation user input: %s", err)
+			}
+
+			didSucceed = res
+
+			if canceled {
+				os.Exit(0)
+			}
+		}
+
+		if didSucceed {
+			if attempt == 0 {
+				fmt.Printf("✅ Command %s succeeded on first try\n", color.New(color.Bold, term.ColorHiCyan).Sprintf(cmdStr))
+			} else {
+				lbl := "attempts"
+				if attempt == 1 {
+					lbl = "attempt"
+				}
+				fmt.Printf("✅ Command %s succeeded after %d fix %s\n", color.New(color.Bold, term.ColorHiCyan).Sprintf(cmdStr), attempt, lbl)
+			}
+			return
+		}
+
+		if attempt == tries-1 {
+			fmt.Printf("Command failed after %d tries\n", tries)
+			os.Exit(1)
+		}
+
+		// Prepare prompt for TellPlan
+		exitErr, ok := waitErr.(*exec.ExitError)
+		status := -1
+		if ok {
+			status = exitErr.ExitCode()
+		}
+
+		prompt := fmt.Sprintf("'%s' failed with exit status %d. Output:\n\n%s\n\n--\n\n",
+			strings.Join(cmdArgs, " "), status, outputStr)
+
+		tellFlags := types.TellFlags{
+			AutoContext: tellAutoContext,
+			ExecEnabled: false,
+			IsUserDebug: true,
+		}
+
+		plan_exec.TellPlan(plan_exec.ExecParams{
+			CurrentPlanId: lib.CurrentPlanId,
+			CurrentBranch: lib.CurrentBranch,
+			AuthVars:      lib.MustVerifyAuthVars(auth.Current.IntegratedModelsMode),
+			CheckOutdatedContext: func(maybeContexts []*shared.Context, projectPaths *types.ProjectPaths) (bool, bool, error) {
+				return lib.CheckOutdatedContextWithOutput(true, true, maybeContexts, projectPaths)
+			},
+		}, prompt, tellFlags)
+
+		applyFlags := types.ApplyFlags{
+			AutoConfirm: true,
+			AutoCommit:  autoCommit,
+			NoCommit:    !autoCommit,
+			NoExec:      false,
+			AutoExec:    true,
+		}
+
+		lib.MustApplyPlan(lib.ApplyPlanParams{
+			PlanId:      lib.CurrentPlanId,
+			Branch:      lib.CurrentBranch,
+			ApplyFlags:  applyFlags,
+			TellFlags:   tellFlags,
+			OnExecFail:  plan_exec.GetOnApplyExecFailWithCommand(applyFlags, tellFlags, cmdStr),
+			ExecCommand: cmdStr,
+		})
+	}
+}

app/cli/cmd/delete_branch.go

@@ -0,0 +1,129 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var deleteBranchCmd = &cobra.Command{
+	Use:     "delete-branch",
+	Aliases: []string{"dlb"},
+	Short:   "Delete a plan branch by name or index",
+	Run:     deleteBranch,
+	Args:    cobra.MaximumNArgs(1),
+}
+
+func init() {
+	RootCmd.AddCommand(deleteBranchCmd)
+}
+
+func deleteBranch(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	var branch string
+	var nameOrIdx string
+
+	if len(args) > 0 {
+		nameOrIdx = strings.TrimSpace(args[0])
+	}
+
+	if nameOrIdx == "main" {
+		fmt.Println("🚨 Cannot delete main branch")
+		return
+	}
+
+	term.StartSpinner("")
+	branches, apiErr := api.Client.ListBranches(lib.CurrentPlanId)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting branches: %v", apiErr)
+		return
+	}
+
+	if nameOrIdx == "" {
+		opts := make([]string, len(branches))
+		for i, branch := range branches {
+			if branch.Name == "main" {
+				continue
+			}
+			opts[i] = branch.Name
+		}
+
+		if len(opts) == 0 {
+			fmt.Println("🤷‍♂️ No branches to delete")
+			return
+		}
+
+		sel, err := term.SelectFromList("Select a branch to delete", opts)
+
+		if err != nil {
+			term.OutputErrorAndExit("Error selecting branch: %v", err)
+			return
+		}
+
+		branch = sel
+	}
+
+	// see if it's an index
+	idx, err := strconv.Atoi(nameOrIdx)
+
+	if err == nil {
+		if idx > 0 && idx <= len(branches) {
+			branch = branches[idx-1].Name
+		} else {
+			term.OutputErrorAndExit("Branch index out of range")
+		}
+	} else {
+		for _, b := range branches {
+			if b.Name == nameOrIdx {
+				branch = b.Name
+				break
+			}
+		}
+
+		if branch == "" {
+			term.OutputErrorAndExit("Branch not found")
+		}
+	}
+
+	found := false
+	for _, b := range branches {
+		if b.Name == branch {
+			found = true
+			break
+		}
+	}
+
+	if !found {
+		fmt.Printf("🤷‍♂️ Branch %s does not exist\n", color.New(color.Bold, term.ColorHiCyan).Sprint(branch))
+		return
+	}
+
+	term.StartSpinner("")
+	apiErr = api.Client.DeleteBranch(lib.CurrentPlanId, branch)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error deleting branch: %v", apiErr)
+		return
+	}
+
+	fmt.Printf("✅ Deleted branch %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint(branch))
+
+	fmt.Println()
+	term.PrintCmds("", "branches")
+}

app/cli/cmd/delete_plan.go

@@ -0,0 +1,182 @@
+package cmd
+
+import (
+	"fmt"
+	"path"
+	"strconv"
+	"strings"
+
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var all bool
+
+func init() {
+	rmCmd.Flags().BoolVar(&all, "all", false, "Delete all plans")
+	RootCmd.AddCommand(rmCmd)
+}
+
+// rmCmd represents the rm command
+var rmCmd = &cobra.Command{
+	Use:     "delete-plan [name-or-index]",
+	Aliases: []string{"dp"},
+	Short:   "Delete a plan by name, index, range, or pattern, or select from a list. Delete all plans with --all flag.",
+	Args:    cobra.RangeArgs(0, 1),
+	Run:     del,
+}
+
+func matchPlansByPattern(pattern string, plans []*shared.Plan) []*shared.Plan {
+	var matched []*shared.Plan
+	for _, plan := range plans {
+		if isMatched, err := path.Match(pattern, plan.Name); err == nil && isMatched {
+			matched = append(matched, plan)
+		}
+	}
+	return matched
+}
+
+func del(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if all {
+		delAll()
+		return
+	}
+
+	term.StartSpinner("")
+	plans, apiErr := api.Client.ListPlans([]string{lib.CurrentProjectId})
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting plans: %v", apiErr)
+	}
+
+	if len(plans) == 0 {
+		fmt.Println("🤷‍♂️ No plans")
+		fmt.Println()
+		term.PrintCmds("", "new")
+		return
+	}
+
+	var plansToDelete []*shared.Plan
+
+	if len(args) == 0 {
+		// Interactive selection
+		opts := make([]string, len(plans))
+		for i, plan := range plans {
+			opts[i] = plan.Name
+		}
+
+		selected, err := term.SelectFromList("Select a plan:", opts)
+		if err != nil {
+			term.OutputErrorAndExit("Error selecting plan: %v", err)
+		}
+
+		for _, p := range plans {
+			if p.Name == selected {
+				plansToDelete = append(plansToDelete, p)
+				break
+			}
+		}
+	} else {
+		nameOrPattern := strings.TrimSpace(args[0])
+
+		// Check if it's a range of indices
+		if strings.Contains(nameOrPattern, "-") {
+			// Create single-element slice with the range pattern
+			rangeArgs := []string{nameOrPattern}
+			indices := parseIndices(rangeArgs)
+			for idx := range indices {
+				if idx >= 0 && idx < len(plans) {
+					plansToDelete = append(plansToDelete, plans[idx])
+				}
+			}
+		} else if strings.Contains(nameOrPattern, "*") {
+			// Wildcard pattern matching
+			plansToDelete = matchPlansByPattern(nameOrPattern, plans)
+		} else {
+			// Try as index first
+			idx, err := strconv.Atoi(nameOrPattern)
+			if err == nil {
+				if idx > 0 && idx <= len(plans) {
+					plansToDelete = append(plansToDelete, plans[idx-1])
+				} else {
+					term.OutputErrorAndExit("Plan index out of range")
+				}
+			} else {
+				// Try exact name match
+				for _, p := range plans {
+					if p.Name == nameOrPattern {
+						plansToDelete = append(plansToDelete, p)
+						break
+					}
+				}
+			}
+		}
+	}
+
+	if len(plansToDelete) == 0 {
+		term.OutputErrorAndExit("No matching plans found")
+	}
+
+	// Show confirmation with list of plans to be deleted
+	fmt.Printf("\nThe following %d plan(s) will be deleted:\n", len(plansToDelete))
+	for _, p := range plansToDelete {
+		fmt.Printf("  - %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint(p.Name))
+	}
+	fmt.Println()
+
+	confirmed, err := term.ConfirmYesNo("Are you sure you want to delete these plans?")
+	if err != nil {
+		term.OutputErrorAndExit("Error getting confirmation: %v", err)
+	}
+	if !confirmed {
+		fmt.Println("Operation cancelled")
+		return
+	}
+
+	// Delete the plans
+	term.StartSpinner("")
+	for _, p := range plansToDelete {
+		apiErr = api.Client.DeletePlan(p.Id)
+		if apiErr != nil {
+			term.StopSpinner()
+			term.OutputErrorAndExit("Error deleting plan %s: %s", p.Name, apiErr.Msg)
+		}
+
+		if lib.CurrentPlanId == p.Id {
+			err := lib.ClearCurrentPlan()
+			if err != nil {
+				term.OutputErrorAndExit("Error clearing current plan: %v", err)
+			}
+		}
+	}
+	term.StopSpinner()
+
+	if len(plansToDelete) == 1 {
+		fmt.Printf("✅ Deleted plan '%s'\n", plansToDelete[0].Name)
+	} else {
+		fmt.Printf("✅ Deleted %d plans\n", len(plansToDelete))
+	}
+}
+
+func delAll() {
+	term.StartSpinner("")
+	err := api.Client.DeleteAllPlans(lib.CurrentProjectId)
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error deleting all  plans: %v", err)
+	}
+
+	fmt.Println("✅ Deleted all plans")
+}

app/cli/cmd/diffs.go

@@ -0,0 +1,288 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"net"
+	"net/http"
+	"os"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"plandex-cli/ui"
+
+	"github.com/eiannone/keyboard"
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var showDiffUi bool = true
+var diffUiSideBySide = true
+var diffUiLineByLine bool
+var diffGit bool
+
+var fromTellMenu bool
+
+var diffsCmd = &cobra.Command{
+	Use:     "diff",
+	Aliases: []string{"diffs"},
+	Short:   "Review pending changes",
+	Run:     diffs,
+}
+
+func init() {
+	RootCmd.AddCommand(diffsCmd)
+
+	diffsCmd.Flags().BoolVarP(&plainTextOutput, "plain", "p", false, "Output diffs in plain text with no ANSI codes")
+	diffsCmd.Flags().BoolVar(&showDiffUi, "ui", false, "Show diffs in a browser UI")
+	diffsCmd.Flags().BoolVar(&diffGit, "git", true, "Show diffs in git diff format")
+	diffsCmd.Flags().BoolVarP(&diffUiSideBySide, "side", "s", true, "Show diffs UI in side-by-side view")
+	diffsCmd.Flags().BoolVarP(&diffUiLineByLine, "line", "l", false, "Show diffs UI in line-by-line view")
+
+	diffsCmd.Flags().BoolVar(&fromTellMenu, "from-tell-menu", false, "Show diffs from the tell menu")
+	diffsCmd.Flags().MarkHidden("from-tell-menu")
+
+}
+
+func diffs(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MaybeResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+
+	if showDiffUi {
+		diffGit = false
+	} else if diffGit || plainTextOutput {
+		showDiffUi = false
+	} else {
+		diffGit = true
+	}
+
+	diffs, err := api.Client.GetPlanDiffs(lib.CurrentPlanId, lib.CurrentBranch, plainTextOutput || showDiffUi)
+	term.StopSpinner()
+	if err != nil {
+		term.OutputErrorAndExit("Error getting plan diffs: %v", err)
+		return
+	}
+
+	if len(diffs) == 0 {
+		fmt.Println("🤷‍♂️ No pending changes")
+		return
+	}
+
+	if showDiffUi {
+		getNewListener := func() net.Listener {
+			outputFormat := "line-by-line"
+			if diffUiSideBySide {
+				outputFormat = "side-by-side"
+			} else if diffUiLineByLine {
+				outputFormat = "line-by-line"
+			}
+
+			// Properly escape the diff content for JavaScript
+			diffJSON, err := json.Marshal(diffs)
+			if err != nil {
+				term.OutputErrorAndExit("Error encoding diff content: %v", err)
+			}
+
+			// Create template data
+			data := struct {
+				DiffContent  template.JS
+				OutputFormat string
+			}{
+				DiffContent:  template.JS(diffJSON),
+				OutputFormat: outputFormat,
+			}
+
+			// Parse and execute the template
+			tmpl, err := template.New("diff").Parse(htmlTemplate)
+			if err != nil {
+				term.OutputErrorAndExit("Error parsing template: %v", err)
+			}
+
+			// Use :0 to let the OS pick an available port
+			listener, err := net.Listen("tcp", ":0")
+			if err != nil {
+				term.OutputErrorAndExit("Error starting server: %v", err)
+			}
+
+			// Get the actual port chosen
+			port := listener.Addr().(*net.TCPAddr).Port
+
+			// Start web server
+			go func() {
+				http.HandleFunc("/"+outputFormat, func(w http.ResponseWriter, r *http.Request) {
+					w.Header().Set("Content-Type", "text/html; charset=utf-8")
+					err := tmpl.Execute(w, data)
+					if err != nil {
+						http.Error(w, err.Error(), http.StatusInternalServerError)
+					}
+				})
+				http.Serve(listener, nil)
+			}()
+
+			ui.OpenURL("Showing "+outputFormat+" diffs in your default browser...", fmt.Sprintf("http://localhost:%d/%s", port, outputFormat))
+
+			fmt.Println()
+
+			return listener
+		}
+
+		listener := getNewListener()
+		defer listener.Close()
+
+		var relaunch bool
+
+		for {
+			if relaunch {
+				listener.Close()
+				listener = getNewListener()
+				defer listener.Close()
+				relaunch = false
+			}
+
+			if diffUiLineByLine {
+				fmt.Printf("%s for side-by-side view\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(s)"))
+			} else {
+				fmt.Printf("%s for line-by-line view\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(l)"))
+			}
+
+			fmt.Printf("%s for git diff format\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(g)"))
+			// fmt.Printf("%s to quit\n", color.New(color.Bold, term.ColorHiGreen).Sprintf("(q)"))
+
+			s := "to exit menu/continue"
+			if fromTellMenu {
+				s = "to go back"
+			}
+
+			fmt.Printf("%s %s %s %s %s",
+				color.New(term.ColorHiMagenta, color.Bold).Sprint("Press a hotkey,"),
+				color.New(color.FgHiWhite, color.Bold).Sprintf("↓"),
+				color.New(term.ColorHiMagenta, color.Bold).Sprintf("to select, or"),
+				color.New(color.FgHiWhite, color.Bold).Sprintf("enter"),
+				color.New(term.ColorHiMagenta, color.Bold).Sprintf("%s>", s),
+			)
+
+			char, key, err := term.GetUserKeyInput()
+			if err != nil {
+				term.OutputErrorAndExit("Error getting key: %v", err)
+				return
+			}
+			fmt.Println()
+
+			if key == keyboard.KeyArrowDown {
+				options := []string{}
+				if diffUiLineByLine {
+					options = append(options, "side-by-side")
+				} else {
+					options = append(options, "line-by-line")
+				}
+
+				options = append(options, "git diff")
+				options = append(options, "exit menu")
+
+				selected, err := term.SelectFromList(
+					"Select an action",
+					options,
+				)
+				if err != nil {
+					term.OutputErrorAndExit("Error selecting action: %v", err)
+					return
+				}
+
+				if selected == "side-by-side" {
+					diffUiSideBySide = true
+					diffUiLineByLine = false
+					relaunch = true
+				} else if selected == "line-by-line" {
+					diffUiSideBySide = false
+					diffUiLineByLine = true
+					relaunch = true
+				} else if selected == "git diff" {
+					showGitDiff()
+				} else if selected == "exit menu" {
+					fmt.Println()
+					break
+				}
+			} else if string(char) == "g" {
+				showGitDiff()
+			} else if string(char) == "s" {
+				diffUiSideBySide = true
+				diffUiLineByLine = false
+				relaunch = true
+			} else if string(char) == "l" {
+				diffUiSideBySide = false
+				diffUiLineByLine = true
+				relaunch = true
+			} else if key == 13 || key == 10 || string(char) == "q" { // Check raw key codes for Enter/Return
+				if term.IsRepl {
+					fmt.Println()
+					break
+				} else {
+					fmt.Println()
+					break
+				}
+			} else if string(char) == "\x03" { // Ctrl+C
+				os.Exit(0)
+			} else {
+				fmt.Println()
+				term.OutputSimpleError("Invalid hotkey")
+				fmt.Println()
+			}
+		}
+	} else {
+		if plainTextOutput {
+			fmt.Println(diffs)
+		} else {
+			term.PageOutput(diffs)
+		}
+		fmt.Println()
+	}
+}
+
+func showGitDiff() {
+	_, err := lib.ExecPlandexCommandWithParams([]string{"diff", "--git"}, lib.ExecPlandexCommandParams{
+		DisableSuggestions: true,
+	})
+	if err != nil {
+		term.OutputErrorAndExit("Error showing git diff: %v", err)
+	}
+}
+
+var htmlTemplate = `<!doctype html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8" />
+    <!-- Make sure to load the highlight.js CSS file before the Diff2Html CSS file -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/vs.min.css" />
+    <link
+      rel="stylesheet"
+      type="text/css"
+      href="https://cdn.jsdelivr.net/npm/diff2html/bundles/css/diff2html.min.css"
+    />
+    <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/diff2html/bundles/js/diff2html-ui.min.js"></script>
+  </head>
+  <script>
+    // Parse the JSON-encoded diff content
+    const diffString = {{.DiffContent}};
+
+    document.addEventListener('DOMContentLoaded', function () {
+      var targetElement = document.getElementById('myDiffElement');
+      var configuration = {
+        outputFormat: '{{.OutputFormat}}'
+      };
+      var diff2htmlUi = new Diff2HtmlUI(targetElement, diffString, configuration);
+      diff2htmlUi.draw();
+      diff2htmlUi.highlightCode();
+    });
+  </script>
+  <body>
+    <div id="myDiffElement"></div>
+  </body>
+</html>`

app/cli/cmd/invite.go

@@ -0,0 +1,102 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+var inviteCmd = &cobra.Command{
+	Use:   "invite [email] [name] [org-role]",
+	Short: "Invite a new user to the org",
+	Run:   invite,
+	Args:  cobra.MaximumNArgs(3),
+}
+
+func init() {
+	RootCmd.AddCommand(inviteCmd)
+}
+
+func invite(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	email, name, orgRoleName := "", "", ""
+	if len(args) >= 1 {
+		email = args[0]
+	}
+	if len(args) >= 2 {
+		name = args[1]
+	}
+	if len(args) == 3 {
+		orgRoleName = args[2]
+	}
+
+	term.StartSpinner("")
+	orgRoles, err := api.Client.ListOrgRoles()
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Failed to list org roles: %v", err)
+	}
+
+	if email == "" {
+		var err error
+		email, err = term.GetRequiredUserStringInput("Email:")
+		if err != nil {
+			term.OutputErrorAndExit("Failed to get email: %v", err)
+		}
+	}
+	if name == "" {
+		var err error
+		name, err = term.GetRequiredUserStringInput("Name:")
+		if err != nil {
+			term.OutputErrorAndExit("Failed to get name: %v", err)
+		}
+	}
+
+	if orgRoleName == "" {
+		var orgRoleNames []string
+		for _, orgRole := range orgRoles {
+			orgRoleNames = append(orgRoleNames, orgRole.Label)
+		}
+
+		var err error
+		orgRoleName, err = term.SelectFromList("Org role:", orgRoleNames)
+
+		if err != nil {
+			term.OutputErrorAndExit("Failed to select org role: %v", err)
+		}
+	}
+
+	var orgRoleId string
+	for _, orgRole := range orgRoles {
+		if orgRole.Label == orgRoleName {
+			orgRoleId = orgRole.Id
+			break
+		}
+	}
+
+	if orgRoleId == "" {
+		term.OutputErrorAndExit("Org role '%s' not found", orgRoleName)
+	}
+
+	inviteRequest := shared.InviteRequest{
+		Email:     email,
+		Name:      name,
+		OrgRoleId: orgRoleId,
+	}
+
+	term.StartSpinner("")
+	apiErr := api.Client.InviteUser(inviteRequest)
+	term.StopSpinner()
+	if apiErr != nil {
+		term.OutputErrorAndExit("Failed to invite user: %s", apiErr.Msg)
+	}
+
+	fmt.Println("✅ Invite sent")
+}

app/cli/cmd/load.go

@@ -0,0 +1,63 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"plandex-cli/types"
+
+	"github.com/sashabaranov/go-openai"
+	"github.com/spf13/cobra"
+)
+
+var (
+	recursive       bool
+	namesOnly       bool
+	note            string
+	forceSkipIgnore bool
+	imageDetail     string
+	defsOnly        bool
+)
+
+var contextLoadCmd = &cobra.Command{
+	Use:     "load [files-or-urls...]",
+	Aliases: []string{"l", "add"},
+	Short:   "Load context from various inputs",
+	Long:    `Load context from a file path, a directory, a URL, an image, a note, or piped data.`,
+	Run:     contextLoad,
+}
+
+func init() {
+	contextLoadCmd.Flags().StringVarP(&note, "note", "n", "", "Add a note to the context")
+	contextLoadCmd.Flags().BoolVarP(&recursive, "recursive", "r", false, "Search directories recursively")
+	contextLoadCmd.Flags().BoolVar(&namesOnly, "tree", false, "Load directory tree with file names only")
+	contextLoadCmd.Flags().BoolVarP(&forceSkipIgnore, "force", "f", false, "Load files even when ignored by .gitignore or .plandexignore")
+	contextLoadCmd.Flags().StringVarP(&imageDetail, "detail", "d", "high", "Image detail level (high or low)")
+	contextLoadCmd.Flags().BoolVar(&defsOnly, "map", false, "Load file maps (function/method/class signatures, variable names, types, etc.)")
+	RootCmd.AddCommand(contextLoadCmd)
+}
+
+func contextLoad(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+		return
+	}
+
+	lib.MustLoadContext(args, &types.LoadContextParams{
+		Note:            note,
+		Recursive:       recursive,
+		NamesOnly:       namesOnly,
+		ForceSkipIgnore: forceSkipIgnore,
+		ImageDetail:     openai.ImageURLDetail(imageDetail),
+		DefsOnly:        defsOnly,
+		SessionId:       os.Getenv("PLANDEX_REPL_SESSION_ID"),
+	})
+
+	fmt.Println()
+	term.PrintCmds("", "ls", "tell", "debug")
+}

app/cli/cmd/log.go

@@ -0,0 +1,88 @@
+package cmd
+
+import (
+	"fmt"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+// logCmd represents the log command
+var logCmd = &cobra.Command{
+	Use:     "log",
+	Aliases: []string{"history", "logs"},
+	Short:   "Show plan history",
+	Long:    `Show plan history`,
+	Args:    cobra.NoArgs,
+	Run:     runLog,
+}
+
+func init() {
+	// Add log command
+	RootCmd.AddCommand(logCmd)
+}
+
+func runLog(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+	res, apiErr := api.Client.ListLogs(lib.CurrentPlanId, lib.CurrentBranch)
+	term.StopSpinner()
+
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error getting logs: %v", apiErr)
+	}
+
+	withLocalTimestamps, err := convertTimestampsToLocal(res.Body)
+
+	if err != nil {
+		term.OutputErrorAndExit("Error converting timestamps: %v", err)
+	}
+
+	term.PageOutput(withLocalTimestamps)
+
+	fmt.Println()
+	term.PrintCmds("", "rewind", "continue", "convo", "convo 1", "convo 2-5")
+
+}
+
+func convertTimestampsToLocal(input string) (string, error) {
+	t := time.Now()
+	zone, _ := t.Zone()
+	re := lib.GitLogTimestampRegex
+
+	// Function to convert matched timestamps assuming they are in UTC to local time.
+	replaceFunc := func(match string) string {
+		t, err := time.Parse(lib.GitLogTimestampFormat, match)
+		if err != nil {
+			// In case of an error, return the original match.
+			return match
+		}
+
+		localDt := t.Local()
+		formattedTs := localDt.Format("Mon Jan 2, 2006 | 3:04:05pm")
+
+		if localDt.Day() == time.Now().Day() {
+			formattedTs = localDt.Format("Today | 3:04:05pm")
+		} else if localDt.Day() == time.Now().AddDate(0, 0, -1).Day() {
+			formattedTs = localDt.Format("Yesterday | 3:04:05pm")
+		}
+
+		// Convert to local time and format back to a string without the timezone to match the original format.
+		return formattedTs + " " + zone
+	}
+
+	// Find all matches and replace them.
+	result := re.ReplaceAllStringFunc(input, replaceFunc)
+
+	return result, nil
+}

app/cli/cmd/ls.go

@@ -0,0 +1,115 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/format"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+)
+
+var contextCmd = &cobra.Command{
+	Use:     "ls",
+	Aliases: []string{"list-context"},
+	Short:   "List everything in context",
+	Run:     listContext,
+}
+
+func listContext(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	term.StartSpinner("")
+	contexts, err := api.Client.ListContext(lib.CurrentPlanId, lib.CurrentBranch)
+
+	if err != nil {
+		term.OutputErrorAndExit("Error listing context: %v", err)
+	}
+
+	planConfig, err := api.Client.GetPlanConfig(lib.CurrentPlanId)
+	if err != nil {
+		term.OutputErrorAndExit("Error getting plan config: %v", err)
+	}
+	term.StopSpinner()
+
+	totalTokens := 0
+	totalPlannerTokens := 0
+	totalMapTokens := 0
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetHeader([]string{"#", "Name", "Type", "🪙", "Added", "Updated"})
+	table.SetAutoWrapText(false)
+
+	if len(contexts) == 0 {
+		fmt.Println("🤷‍♂️ No context")
+		fmt.Println()
+		term.PrintCmds("", "load")
+		return
+	}
+
+	for i, context := range contexts {
+		totalTokens += context.NumTokens
+
+		if context.ContextType == shared.ContextMapType {
+			totalMapTokens += context.NumTokens
+		} else {
+			totalPlannerTokens += context.NumTokens
+		}
+
+		t, icon := context.TypeAndIcon()
+
+		name := context.Name
+		if name == "" {
+			name = context.FilePath
+		}
+		if len(name) > 40 {
+			name = name[:20] + "⋯" + name[len(name)-20:]
+		}
+
+		row := []string{
+			strconv.Itoa(i + 1),
+			" " + icon + " " + name,
+			t,
+			strconv.Itoa(context.NumTokens), //+ " 🪙",
+			format.Time(context.CreatedAt),
+			format.Time(context.UpdatedAt),
+		}
+		table.Rich(row, []tablewriter.Colors{
+			{tablewriter.Bold},
+			{tablewriter.FgHiGreenColor, tablewriter.Bold},
+		})
+	}
+
+	table.Render()
+
+	tokensTbl := tablewriter.NewWriter(os.Stdout)
+	tokensTbl.SetAutoWrapText(false)
+
+	if planConfig.AutoLoadContext {
+		tokensTbl.Append([]string{
+			color.New(term.ColorHiCyan, color.Bold).Sprintf("Map tokens →") + color.New(color.Bold).Sprintf(" %d 🪙", totalMapTokens),
+			color.New(term.ColorHiCyan, color.Bold).Sprintf("Context tokens →") + color.New(color.Bold).Sprintf(" %d 🪙", totalPlannerTokens),
+		})
+	} else {
+
+		tokensTbl.Append([]string{color.New(term.ColorHiCyan, color.Bold).Sprintf("Total tokens →") + color.New(color.Bold).Sprintf(" %d 🪙", totalTokens)})
+	}
+	tokensTbl.Render()
+
+	fmt.Println()
+	term.PrintCmds("", "load", "rm", "clear")
+
+}
+
+func init() {
+	RootCmd.AddCommand(contextCmd)
+
+}

app/cli/cmd/model_helpers.go

@@ -0,0 +1,88 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+)
+
+func warnModelsFileLocalChanges(path, cmd string) (bool, error) {
+	cmdPrefix := "\\"
+	if !term.IsRepl {
+		cmdPrefix = "plandex "
+	}
+
+	color.New(color.Bold, term.ColorHiYellow).Println("⚠️  The models file has local changes")
+
+	fmt.Println()
+	fmt.Println("Path → " + path)
+	fmt.Println()
+
+	fmt.Println("If you continue, local changes will be dropped in favor of the latest server state")
+
+	fmt.Println()
+	fmt.Printf("To keep the local version instead, quit and run %s\n", color.New(color.Bold, color.BgCyan, color.FgHiWhite).
+		Sprintf(" %s%s --save ", cmdPrefix, cmd))
+	fmt.Println()
+	return term.ConfirmYesNo("Drop local changes and continue?")
+
+}
+
+type maybePromptAndOpenModelsFileResult struct {
+	shouldReturn bool
+	jsonData     []byte
+}
+
+func maybePromptAndOpenModelsFile(filePath, pathArg, cmd string, defaultConfig *shared.PlanConfig, planConfig *shared.PlanConfig) maybePromptAndOpenModelsFileResult {
+
+	printManual := func() {
+		cmdPrefix := "\\"
+		if !term.IsRepl {
+			cmdPrefix = "plandex "
+		}
+		fmt.Println("To save changes, run " +
+			fmt.Sprintf(" %s ", color.New(color.Bold, color.BgCyan, color.FgHiWhite).
+				Sprintf(" %s%s --save%s ", cmdPrefix, cmd, pathArg)))
+	}
+
+	selectedEditor := lib.MaybePromptAndOpen(filePath, defaultConfig, planConfig)
+
+	if selectedEditor {
+		fmt.Println("📝 Opened in editor")
+		fmt.Println()
+
+		confirmed, err := term.ConfirmYesNo("Ready to save?")
+		if err != nil {
+			term.OutputErrorAndExit("Error confirming: %v", err)
+			return maybePromptAndOpenModelsFileResult{shouldReturn: true}
+		}
+
+		if !confirmed {
+			fmt.Println("🙅‍♂️ Update canceled")
+			fmt.Println()
+
+			printManual()
+			return maybePromptAndOpenModelsFileResult{shouldReturn: true}
+		}
+
+		// get updated file state
+		jsonData, err := os.ReadFile(filePath)
+		if err != nil {
+			term.OutputErrorAndExit("Error reading JSON file: %v", err)
+			return maybePromptAndOpenModelsFileResult{shouldReturn: true}
+		}
+
+		return maybePromptAndOpenModelsFileResult{shouldReturn: false, jsonData: jsonData}
+	} else {
+		// No editor available or user chose manual
+		fmt.Println("👨‍💻 Edit the file in your JSON editor of choice")
+		fmt.Println()
+
+		printManual()
+		return maybePromptAndOpenModelsFileResult{shouldReturn: true}
+	}
+}

app/cli/cmd/model_packs.go

@@ -0,0 +1,267 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+)
+
+var customModelPacksOnly bool
+
+var modelPacksCmd = &cobra.Command{
+	Use:   "model-packs",
+	Short: "List all model packs",
+	Run:   listModelPacks,
+}
+
+var createModelPackCmd = &cobra.Command{
+	Use:   "create",
+	Short: "Create a model pack",
+	Run:   customModelsNotImplemented,
+}
+
+var deleteModelPackCmd = &cobra.Command{
+	Use:     "delete",
+	Aliases: []string{"rm"},
+	Short:   "Delete a model pack by name or index",
+	Run:     customModelsNotImplemented,
+}
+
+var updateModelPackCmd = &cobra.Command{
+	Use:   "update",
+	Short: "Update a model pack by name",
+	Run:   customModelsNotImplemented,
+}
+
+var showModelPackCmd = &cobra.Command{
+	Use:   "show [name]",
+	Short: "Show a model pack by name",
+	Args:  cobra.MaximumNArgs(1),
+	Run:   showModelPack,
+}
+
+func init() {
+	RootCmd.AddCommand(modelPacksCmd)
+	modelPacksCmd.AddCommand(createModelPackCmd)
+	modelPacksCmd.AddCommand(deleteModelPackCmd)
+	modelPacksCmd.AddCommand(updateModelPackCmd)
+	modelPacksCmd.AddCommand(showModelPackCmd)
+	modelPacksCmd.Flags().BoolVarP(&customModelPacksOnly, "custom", "c", false, "Only show custom model packs")
+	modelPacksCmd.Flags().BoolVarP(&allProperties, "all", "a", false, "Show all properties")
+}
+
+func listModelPacks(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	term.StartSpinner("")
+	builtInModelPacks := shared.BuiltInModelPacks
+
+	if auth.Current.IsCloud {
+		filtered := []*shared.ModelPack{}
+		for _, mp := range builtInModelPacks {
+			if mp.LocalProvider == "" {
+				filtered = append(filtered, mp)
+			}
+		}
+		builtInModelPacks = filtered
+	}
+
+	customModelPacks, err := api.Client.ListModelPacks()
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error fetching model packs: %v", err)
+		return
+	}
+
+	if !customModelPacksOnly {
+		color.New(color.Bold, term.ColorHiCyan).Println("🏠 Built-in Model Packs")
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(true)
+		table.SetRowLine(true)
+		table.SetHeader([]string{"Name", "Description"})
+		for _, set := range builtInModelPacks {
+			table.Append([]string{set.Name, set.Description})
+		}
+		table.Render()
+		fmt.Println()
+	}
+
+	if len(customModelPacks) > 0 {
+		color.New(color.Bold, term.ColorHiCyan).Println("🛠️  Custom Model Packs")
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(true)
+		table.SetRowLine(true)
+		table.SetHeader([]string{"#", "Name", "Description"})
+		for i, set := range customModelPacks {
+			table.Append([]string{fmt.Sprintf("%d", i+1), set.Name, set.Description})
+		}
+		table.Render()
+
+		fmt.Println()
+	} else if customModelPacksOnly {
+		fmt.Println("🤷‍♂️ No custom model packs")
+		fmt.Println()
+	}
+
+	if customModelPacksOnly && len(customModelPacks) > 0 {
+		term.PrintCmds("", "model-packs show", "models custom")
+	} else if len(customModelPacks) > 0 {
+		term.PrintCmds("", "model-packs --custom", "model-packs show", "models custom")
+	} else {
+		term.PrintCmds("", "model-packs show", "models custom")
+	}
+
+}
+
+func showModelPack(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	term.StartSpinner("")
+	customModelPacks, apiErr := api.Client.ListModelPacks()
+	if apiErr != nil {
+		term.OutputErrorAndExit("Error fetching models: %v", apiErr)
+	}
+	customModels, err := api.Client.ListCustomModels()
+	if err != nil {
+		term.OutputErrorAndExit("Error fetching custom models: %v", err)
+	}
+	customModelsById := make(map[shared.ModelId]*shared.CustomModel)
+	for _, m := range customModels {
+		customModelsById[m.ModelId] = m
+	}
+
+	term.StopSpinner()
+
+	modelPacks := []*shared.ModelPack{}
+	modelPacks = append(modelPacks, customModelPacks...)
+
+	builtInModelPacks := shared.BuiltInModelPacks
+	if auth.Current.IsCloud {
+		filtered := []*shared.ModelPack{}
+		for _, mp := range builtInModelPacks {
+			if mp.LocalProvider == "" {
+				filtered = append(filtered, mp)
+			}
+		}
+		builtInModelPacks = filtered
+	}
+	modelPacks = append(modelPacks, builtInModelPacks...)
+
+	var name string
+	if len(args) > 0 {
+		name = args[0]
+	}
+
+	var modelPack *shared.ModelPack
+
+	if name == "" {
+		opts := make([]string, len(modelPacks))
+		for i, mp := range modelPacks {
+			opts[i] = mp.Name
+		}
+
+		selected, err := term.SelectFromList("Select a model pack:", opts)
+		if err != nil {
+			term.OutputErrorAndExit("Error selecting model pack: %v", err)
+		}
+
+		for _, mp := range modelPacks {
+			if mp.Name == selected {
+				modelPack = mp
+				break
+			}
+		}
+	} else {
+		for _, mp := range modelPacks {
+			if mp.Name == name {
+				modelPack = mp
+				break
+			}
+		}
+	}
+
+	if modelPack == nil {
+		term.OutputErrorAndExit("Model pack not found")
+		return
+	}
+
+	renderModelPack(modelPack, customModelsById, allProperties)
+
+	fmt.Println()
+
+	term.PrintCmds("", "set-model", "set-model default", "models custom")
+}
+
+// func getModelRoleConfig(customModels []*shared.CustomModel, modelRole shared.ModelRole) shared.ModelRoleConfig {
+// 	_, modelConfig := getModelWithRoleConfig(customModels, modelRole)
+// 	return modelConfig
+// }
+
+// func getModelWithRoleConfig(customModels []*shared.CustomModel, modelRole shared.ModelRole) (*shared.CustomModel, shared.ModelRoleConfig) {
+// 	role := string(modelRole)
+
+// 	modelId := getModelIdForRole(customModels, modelRole)
+
+// 	temperatureStr, err := term.GetUserStringInputWithDefault("Temperature for "+role+":", fmt.Sprintf("%.1f", shared.DefaultConfigByRole[modelRole].Temperature))
+// 	if err != nil {
+// 		term.OutputErrorAndExit("Error reading temperature: %v", err)
+// 	}
+// 	temperature, err := strconv.ParseFloat(temperatureStr, 32)
+// 	if err != nil {
+// 		term.OutputErrorAndExit("Invalid number for temperature: %v", err)
+// 	}
+
+// 	topPStr, err := term.GetUserStringInputWithDefault("Top P for "+role+":", fmt.Sprintf("%.1f", shared.DefaultConfigByRole[modelRole].TopP))
+// 	if err != nil {
+// 		term.OutputErrorAndExit("Error reading top P: %v", err)
+// 	}
+// 	topP, err := strconv.ParseFloat(topPStr, 32)
+// 	if err != nil {
+// 		term.OutputErrorAndExit("Invalid number for top P: %v", err)
+// 	}
+
+// 	var reservedOutputTokens int
+// 	if modelRole == shared.ModelRoleBuilder || modelRole == shared.ModelRolePlanner || modelRole == shared.ModelRoleWholeFileBuilder {
+// 		reservedOutputTokensStr, err := term.GetUserStringInputWithDefault("Reserved output tokens for "+role+":", fmt.Sprintf("%d", model.ReservedOutputTokens))
+// 		if err != nil {
+// 			term.OutputErrorAndExit("Error reading reserved output tokens: %v", err)
+// 		}
+// 		reservedOutputTokens, err = strconv.Atoi(reservedOutputTokensStr)
+// 		if err != nil {
+// 			term.OutputErrorAndExit("Invalid number for reserved output tokens: %v", err)
+// 		}
+// 	}
+
+// 	return model, shared.ModelRoleConfig{
+// 		ModelId:              model.ModelId,
+// 		Role:                 modelRole,
+// 		Temperature:          float32(temperature),
+// 		TopP:                 float32(topP),
+// 		ReservedOutputTokens: reservedOutputTokens,
+// 	}
+// }
+
+// func getPlannerRoleConfig(customModels []*shared.CustomModel) shared.PlannerRoleConfig {
+// 	model, modelConfig := getModelWithRoleConfig(customModels, shared.ModelRolePlanner)
+
+// 	return shared.PlannerRoleConfig{
+// 		ModelRoleConfig: modelConfig,
+// 		PlannerModelConfig: shared.PlannerModelConfig{
+// 			MaxConvoTokens: model.DefaultMaxConvoTokens,
+// 		},
+// 	}
+// }
+
+// func getModelIdForRole(customModels []*shared.CustomModel, role shared.ModelRole) shared.ModelId {
+// 	color.New(color.Bold).Printf("Select a model for the %s role 👇\n", role)
+// 	return lib.SelectModelIdForRole(customModels, role)
+// }

app/cli/cmd/model_providers.go

@@ -0,0 +1,163 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/term"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+)
+
+var customProvidersOnly bool
+
+var providersCmd = &cobra.Command{
+	Use:   "providers",
+	Short: "List built-in and custom model providers",
+	Run:   listProviders,
+}
+
+var addProviderCmd = &cobra.Command{
+	Use:     "add",
+	Aliases: []string{"create"},
+	Short:   "Add a custom model provider",
+	Run:     customModelsNotImplemented,
+}
+
+var updateProviderCmd = &cobra.Command{
+	Use:     "update",
+	Aliases: []string{"edit"},
+	Short:   "Update a custom model provider",
+	Run:     customModelsNotImplemented,
+}
+
+func init() {
+	RootCmd.AddCommand(providersCmd)
+	providersCmd.Flags().BoolVarP(&customProvidersOnly, "custom", "c", false, "List custom providers only")
+	providersCmd.AddCommand(addProviderCmd)
+	providersCmd.AddCommand(updateProviderCmd)
+}
+
+func listProviders(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	var customProviders []*shared.CustomProvider
+	var apiErr *shared.ApiError
+
+	if customProvidersOnly && auth.Current.IsCloud {
+		term.OutputErrorAndExit("Custom providers are not supported on Plandex Cloud")
+		return
+	}
+
+	if !auth.Current.IsCloud {
+		term.StartSpinner("")
+		customProviders, apiErr = api.Client.ListCustomProviders()
+		term.StopSpinner()
+		if apiErr != nil {
+			term.OutputErrorAndExit("Error fetching providers: %v", apiErr.Msg)
+			return
+		}
+	}
+
+	if customProvidersOnly && len(customProviders) == 0 {
+		fmt.Println("🤷‍♂️  No custom providers")
+		fmt.Println()
+		term.PrintCmds("", "models custom")
+		return
+	}
+
+	color.New(color.Bold, term.ColorHiCyan).Println("🏠 Built-in Providers")
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetAutoWrapText(true)
+
+	var header []string
+	if auth.Current.IsCloud {
+		header = []string{"ID", "API Key", "Other Vars"}
+	} else {
+		header = []string{"ID", "Base URL", "API Key", "Other Vars"}
+	}
+	table.SetHeader(header)
+	for _, p := range shared.AllModelProviders {
+		if p == shared.ModelProviderCustom {
+			continue
+		}
+		config := shared.BuiltInModelProviderConfigs[p]
+		if config.LocalOnly && auth.Current.IsCloud {
+			continue
+		}
+		var apiKey string
+		if config.ApiKeyEnvVar != "" {
+			apiKey = config.ApiKeyEnvVar
+		} else if config.SkipAuth {
+			apiKey = "No Auth"
+		} else if config.HasClaudeMaxAuth {
+			apiKey = "Claude Max Oauth"
+		}
+
+		extraVars := []string{}
+		if config.Provider == shared.ModelProviderAmazonBedrock {
+			extraVars = append(extraVars, "PLANDEX_AWS_PROFILE")
+		}
+		for _, v := range config.ExtraAuthVars {
+			extraVars = append(extraVars, v.Var)
+		}
+
+		if auth.Current.IsCloud {
+			table.Append([]string{
+				string(p),
+				apiKey,
+				strings.Join(extraVars, "\n"),
+			})
+		} else {
+			table.Append([]string{
+				string(p),
+				config.BaseUrl,
+				apiKey,
+				strings.Join(extraVars, "\n"),
+			})
+		}
+	}
+	table.Render()
+	fmt.Println()
+
+	if len(customProviders) > 0 {
+		color.New(color.Bold, term.ColorHiCyan).Println("🛠️  Custom Providers")
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(false)
+		table.SetHeader([]string{"#", "Name", "Base URL", "API Key", "Other Vars"})
+		for i, p := range customProviders {
+			extraVars := []string{}
+			for _, v := range p.ExtraAuthVars {
+				extraVars = append(extraVars, v.Var)
+			}
+			apiKey := p.ApiKeyEnvVar
+			if apiKey == "" && p.SkipAuth {
+				apiKey = "No Auth"
+			}
+
+			table.Append([]string{
+				strconv.Itoa(i + 1),
+				p.Name,
+				p.BaseUrl,
+				apiKey,
+				strings.Join(extraVars, "\n"),
+			})
+		}
+		table.Render()
+		fmt.Println()
+	}
+
+	fmt.Println(color.New(color.Bold, term.ColorHiCyan).Sprint("\n📖 Per-provider instructions"))
+	fmt.Println("Go to → " + color.New(color.Bold).Sprint("https://docs.plandex.ai/models/model-providers"))
+	fmt.Println()
+
+	term.PrintCmds("", "models custom")
+}

app/cli/cmd/models.go

@@ -0,0 +1,612 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/fs"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/olekukonko/tablewriter"
+	"github.com/spf13/cobra"
+)
+
+var customModelsOnly bool
+var allProperties bool
+var saveCustomModels bool
+var customModelsPath string
+
+func init() {
+	RootCmd.AddCommand(modelsCmd)
+
+	modelsCmd.Flags().BoolVarP(&allProperties, "all", "a", false, "Show all properties")
+
+	modelsCmd.AddCommand(listAvailableModelsCmd)
+	modelsCmd.AddCommand(addCustomModelCmd)
+	modelsCmd.AddCommand(updateCustomModelCmd)
+	modelsCmd.AddCommand(manageCustomModelsCmd)
+	modelsCmd.AddCommand(deleteCustomModelCmd)
+	modelsCmd.AddCommand(defaultModelsCmd)
+
+	manageCustomModelsCmd.Flags().BoolVar(&saveCustomModels, "save", false, "Save custom models")
+	manageCustomModelsCmd.Flags().StringVarP(&customModelsPath, "file", "f", "", "Path to custom models file")
+
+	listAvailableModelsCmd.Flags().BoolVarP(&customModelsOnly, "custom", "c", false, "List custom models only")
+}
+
+var modelsCmd = &cobra.Command{
+	Use:   "models",
+	Short: "Show plan model settings",
+	Run:   models,
+}
+
+var defaultModelsCmd = &cobra.Command{
+	Use:   "default",
+	Short: "Show default model settings for new plans",
+	Run:   defaultModels,
+}
+
+var listAvailableModelsCmd = &cobra.Command{
+	Use:     "available",
+	Aliases: []string{"avail"},
+	Short:   "List all available models",
+	Run:     listAvailableModels,
+}
+
+var manageCustomModelsCmd = &cobra.Command{
+	Use:   "custom",
+	Short: "Manage custom models, providers, and model packs",
+	Run:   manageCustomModels,
+}
+
+var addCustomModelCmd = &cobra.Command{
+	Use:     "add",
+	Aliases: []string{"create"},
+	Short:   "Add a custom model",
+	Run:     customModelsNotImplemented,
+}
+
+var updateCustomModelCmd = &cobra.Command{
+	Use:     "update",
+	Aliases: []string{"edit"},
+	Short:   "Update a custom model",
+	Run:     customModelsNotImplemented,
+}
+
+var deleteCustomModelCmd = &cobra.Command{
+	Use:     "rm",
+	Aliases: []string{"remove", "delete"},
+	Short:   "Remove a custom model",
+	Args:    cobra.MaximumNArgs(1),
+	Run:     customModelsNotImplemented,
+}
+
+func manageCustomModels(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	term.StartSpinner("")
+
+	var serverModelsInput *shared.ModelsInput
+	var defaultConfig *shared.PlanConfig
+
+	errCh := make(chan error, 2)
+
+	go func() {
+		var err error
+		serverModelsInput, err = lib.GetServerModelsInput()
+		if err != nil {
+			errCh <- fmt.Errorf("error getting server models input: %v", err)
+			return
+		}
+		errCh <- nil
+	}()
+
+	go func() {
+		var apiErr *shared.ApiError
+		defaultConfig, apiErr = api.Client.GetDefaultPlanConfig()
+		if apiErr != nil {
+			errCh <- fmt.Errorf("error getting default config: %v", apiErr.Msg)
+			return
+		}
+		errCh <- nil
+	}()
+
+	for i := 0; i < 2; i++ {
+		err := <-errCh
+		if err != nil {
+			term.OutputErrorAndExit(err.Error())
+			return
+		}
+	}
+
+	usingDefaultPath := false
+	if customModelsPath == "" {
+		usingDefaultPath = true
+		customModelsPath = lib.GetCustomModelsPath(auth.Current.UserId)
+	}
+
+	exists, err := fs.FileExists(customModelsPath)
+	if err != nil {
+		term.OutputErrorAndExit("Error checking custom models file: %v", err)
+		return
+	}
+
+	if saveCustomModels {
+		if !exists {
+			term.OutputErrorAndExit("File not found: %s", customModelsPath)
+			return
+		}
+	} else {
+		if serverModelsInput.IsEmpty() {
+			jsonData, err := json.MarshalIndent(getExampleTemplate(auth.Current.IsCloud, auth.Current.IntegratedModelsMode), "", "  ")
+			if err != nil {
+				term.OutputErrorAndExit("Error marshalling template: %v", err)
+				return
+			}
+
+			err = os.MkdirAll(filepath.Dir(customModelsPath), 0755)
+			if err != nil {
+				term.OutputErrorAndExit("Error creating directory: %v", err)
+				return
+			}
+
+			err = os.WriteFile(customModelsPath, jsonData, 0644)
+			if err != nil {
+				term.OutputErrorAndExit("Error writing template file: %v", err)
+				return
+			}
+
+			term.StopSpinner()
+
+			fmt.Printf("🧠 Example models file → %s\n", customModelsPath)
+			fmt.Println("👨‍💻 Edit it, then come back here to save")
+			fmt.Println()
+		} else {
+			serverClientModelsInput := serverModelsInput.ToClientModelsInput()
+			serverClientModelsInput.PrepareUpdate()
+
+			var localModelsInput shared.ModelsInput
+
+			if exists {
+				// we only do a conflict check on the default path in the home dir
+				// if user specifies the path and the file exists, just open the file without checking for conflicts
+				if usingDefaultPath {
+					res, err := lib.CustomModelsCheckLocalChanges(customModelsPath)
+					if err != nil {
+						term.OutputErrorAndExit("Error checking local changes: %v", err)
+						return
+					}
+
+					localModelsInput = res.LocalModelsInput
+					if res.HasLocalChanges {
+						term.StopSpinner()
+
+						res, err := warnModelsFileLocalChanges(customModelsPath, "models custom")
+						if err != nil {
+							term.OutputErrorAndExit("Error confirming: %v", err)
+							return
+						}
+						if !res {
+							return
+						}
+						fmt.Println()
+						term.StartSpinner("")
+					}
+				}
+			}
+
+			if !serverModelsInput.Equals(localModelsInput) {
+				err := lib.WriteCustomModelsFile(customModelsPath, serverModelsInput)
+				if err != nil {
+					term.OutputErrorAndExit("Error saving custom models file: %v", err)
+					return
+				}
+			}
+
+			term.StopSpinner()
+
+			fmt.Printf("🧠 %s → %s\n", color.New(color.Bold, term.ColorHiCyan).Sprint("Models file"), customModelsPath)
+			fmt.Println("👨‍💻 Edit it, then come back here to save")
+			fmt.Println()
+		}
+
+		pathArg := ""
+		if !usingDefaultPath {
+			pathArg = fmt.Sprintf(" --file %s", customModelsPath)
+		}
+
+		res := maybePromptAndOpenModelsFile(customModelsPath, pathArg, "models custom", defaultConfig, nil)
+		if res.shouldReturn {
+			return
+		}
+	}
+
+	didUpdate := lib.MustSyncCustomModels(customModelsPath, serverModelsInput)
+
+	if !didUpdate {
+		fmt.Println("🤷‍♂️ No changes to custom models/providers/model packs")
+	}
+}
+
+func models(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveProject()
+
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	term.StartSpinner("")
+
+	plan, err := api.Client.GetPlan(lib.CurrentPlanId)
+
+	if err != nil {
+		term.StopSpinner()
+		term.OutputErrorAndExit("Error getting plan: %v", err)
+		return
+	}
+
+	settings, err := api.Client.GetSettings(lib.CurrentPlanId, lib.CurrentBranch)
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error getting settings: %v", err)
+		return
+	}
+
+	title := fmt.Sprintf("%s Model Settings", color.New(color.Bold, term.ColorHiGreen).Sprint(plan.Name))
+
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetAutoWrapText(false)
+	table.Append([]string{title})
+	table.Render()
+	fmt.Println()
+
+	renderSettings(settings, allProperties)
+
+	term.PrintCmds("", "set-model", "models available", "models default", "models custom")
+}
+
+func defaultModels(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	term.StartSpinner("")
+	settings, err := api.Client.GetOrgDefaultSettings()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error getting default model settings: %v", err)
+		return
+	}
+
+	term.StopSpinner()
+
+	title := fmt.Sprintf("%s Model Settings", color.New(color.Bold, term.ColorHiGreen).Sprint("Org-Wide Default"))
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetAutoWrapText(false)
+	table.Append([]string{title})
+	table.Render()
+	fmt.Println()
+
+	renderSettings(settings, allProperties)
+
+	term.PrintCmds("", "set-model default", "models available", "models")
+}
+
+func listAvailableModels(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+
+	if customModelsOnly && auth.Current.IntegratedModelsMode {
+		term.OutputErrorAndExit("Custom models are not supported in Integrated Models mode on Plandex Cloud")
+		return
+	}
+
+	term.StartSpinner("")
+
+	customModels, err := api.Client.ListCustomModels()
+
+	term.StopSpinner()
+
+	if err != nil {
+		term.OutputErrorAndExit("Error fetching custom models: %v", err)
+		return
+	}
+
+	if !customModelsOnly {
+		color.New(color.Bold, term.ColorHiCyan).Println("🏠 Built-in Models")
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(false)
+		table.SetHeader([]string{"Model", "Input", "Output", "Reserved"})
+		for _, model := range shared.BuiltInBaseModels {
+			if auth.Current.IsCloud && model.IsLocalOnly() {
+				continue
+			}
+
+			table.Append([]string{string(model.ModelId), fmt.Sprintf("%d 🪙", model.MaxTokens), fmt.Sprintf("%d 🪙", model.MaxOutputTokens), fmt.Sprintf("%d 🪙", model.ReservedOutputTokens)})
+		}
+		table.Render()
+		fmt.Println()
+	}
+
+	if len(customModels) > 0 {
+		color.New(color.Bold, term.ColorHiCyan).Println("🛠️  Custom Models")
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(false)
+		table.SetHeader([]string{"#", "ID", "🪙"})
+		for i, model := range customModels {
+			table.Append([]string{fmt.Sprintf("%d", i+1), string(model.ModelId), strconv.Itoa(model.MaxTokens)})
+		}
+		table.Render()
+	} else if customModelsOnly {
+		fmt.Println("🤷‍♂️ No custom models")
+	}
+	fmt.Println()
+
+	if customModelsOnly {
+		if len(customModels) > 0 {
+			term.PrintCmds("", "models", "set-model", "models custom")
+		} else {
+			term.PrintCmds("", "models custom")
+		}
+	} else {
+		term.PrintCmds("", "models available --custom", "models", "set-model", "models custom")
+	}
+}
+
+func renderSettings(settings *shared.PlanSettings, allProperties bool) {
+	modelPack := settings.GetModelPack()
+
+	color.New(color.Bold, term.ColorHiCyan).Println("🎛️  Current Model Pack")
+	renderModelPack(modelPack, settings.CustomModelsById, allProperties)
+
+	if allProperties {
+		color.New(color.Bold, term.ColorHiCyan).Println("🧠 Planner Defaults")
+		table := tablewriter.NewWriter(os.Stdout)
+		table.SetAutoWrapText(false)
+		table.SetHeader([]string{"Max Tokens", "Max Convo Tokens"})
+		table.Append([]string{
+			fmt.Sprintf("%d", modelPack.Planner.GetFinalLargeContextFallback().GetSharedBaseConfig(settings).MaxTokens),
+			fmt.Sprintf("%d", modelPack.Planner.GetMaxConvoTokens(settings)),
+		})
+		table.Render()
+		fmt.Println()
+	}
+}
+
+func renderModelPack(modelPack *shared.ModelPack, customModelsById map[shared.ModelId]*shared.CustomModel, allProperties bool) {
+	table := tablewriter.NewWriter(os.Stdout)
+	table.SetAutoFormatHeaders(false)
+	table.SetAutoWrapText(true)
+	table.SetColWidth(64)
+	table.SetHeader([]string{modelPack.Name})
+	table.Append([]string{modelPack.Description})
+	table.Render()
+	fmt.Println()
+
+	color.New(color.Bold, term.ColorHiCyan).Println("🤖 Models")
+	table = tablewriter.NewWriter(os.Stdout)
+	table.SetAutoWrapText(false)
+	cols := []string{
+		"Role",
+		"Model",
+	}
+	align := []int{
+		tablewriter.ALIGN_LEFT, // Role
+		tablewriter.ALIGN_LEFT, // Model
+	}
+	if allProperties {
+		cols = append(cols, []string{
+			"Temperature",
+			"Top P",
+			"Max Input",
+		}...)
+		align = append(align, []int{
+			tablewriter.ALIGN_RIGHT, // Temperature
+			tablewriter.ALIGN_RIGHT, // Top P
+			tablewriter.ALIGN_RIGHT, // Max Input
+		}...)
+	}
+	table.SetHeader(cols)
+	table.SetColumnAlignment(align)
+
+	anyRoleParamsDisabled := false
+
+	var addModelRow func(role string, config shared.ModelRoleConfig, indent int)
+	addModelRow = func(role string, config shared.ModelRoleConfig, indent int) {
+		if indent > 0 {
+			role = "└─ " + role
+			for i := 0; i < indent-1; i++ {
+				role = " " + role
+			}
+		}
+
+		var temp float32
+		var topP float32
+		var disabled bool
+
+		sharedBaseConfig := config.GetSharedBaseConfigWithCustomModels(customModelsById)
+
+		if sharedBaseConfig.RoleParamsDisabled {
+			temp = 1
+			topP = 1
+			disabled = true
+			anyRoleParamsDisabled = true
+		} else {
+			temp = config.Temperature
+			topP = config.TopP
+		}
+
+		tempStr := fmt.Sprintf("%.1f", temp)
+		if disabled {
+			tempStr = "*" + tempStr
+		}
+
+		topPStr := fmt.Sprintf("%.1f", topP)
+		if disabled {
+			topPStr = "*" + topPStr
+		}
+
+		row := []string{
+			role,
+			string(config.GetModelId()),
+		}
+
+		if allProperties {
+			row = append(row, []string{
+				tempStr,
+				topPStr,
+				fmt.Sprintf("%d 🪙", sharedBaseConfig.MaxTokens-config.GetReservedOutputTokens(customModelsById)),
+			}...)
+		}
+		table.Append(row)
+
+		// Add large context and large output fallback(s) if present
+		if config.LargeContextFallback != nil {
+			addModelRow("large-context", *config.LargeContextFallback, indent+1)
+		}
+
+		if config.LargeOutputFallback != nil {
+			addModelRow("large-output", *config.LargeOutputFallback, indent+1)
+		}
+
+		if config.StrongModel != nil {
+			addModelRow("strong", *config.StrongModel, indent+1)
+		}
+
+		if config.ErrorFallback != nil {
+			addModelRow("error", *config.ErrorFallback, indent+1)
+		}
+	}
+
+	addModelRow(string(shared.ModelRolePlanner), modelPack.Planner.ModelRoleConfig, 0)
+
+	addModelRow(string(shared.ModelRoleArchitect), modelPack.GetArchitect(), 0)
+	addModelRow(string(shared.ModelRoleCoder), modelPack.GetCoder(), 0)
+	addModelRow(string(shared.ModelRolePlanSummary), modelPack.PlanSummary, 0)
+	addModelRow(string(shared.ModelRoleBuilder), modelPack.Builder, 0)
+	addModelRow(string(shared.ModelRoleWholeFileBuilder), modelPack.GetWholeFileBuilder(), 0)
+	addModelRow(string(shared.ModelRoleName), modelPack.Namer, 0)
+	addModelRow(string(shared.ModelRoleCommitMsg), modelPack.CommitMsg, 0)
+	addModelRow(string(shared.ModelRoleExecStatus), modelPack.ExecStatus, 0)
+	table.Render()
+
+	if anyRoleParamsDisabled && allProperties {
+		fmt.Println("* these models do not support changing temperature or top p")
+	}
+
+	fmt.Println()
+
+}
+
+func customModelsNotImplemented(cmd *cobra.Command, args []string) {
+	color.New(color.Bold, color.FgHiRed).Println("⛔️ Not implemented")
+	fmt.Println()
+	fmt.Println("Use " + color.New(color.BgCyan, color.FgHiWhite).Sprint(" plandex models custom ") + " to manage custom models, providers, and model packs")
+	os.Exit(1)
+}
+
+func getExampleTemplate(isCloud, isCloudIntegratedModels bool) shared.ClientModelsInput {
+	exampleProviderName := "togetherai"
+
+	var customProviders []*shared.CustomProvider
+	usesProviders := []shared.BaseModelUsesProvider{}
+	if !isCloud {
+		customProviders = append(customProviders, &shared.CustomProvider{
+			Name:         exampleProviderName,
+			BaseUrl:      "https://api.together.xyz/v1",
+			ApiKeyEnvVar: "TOGETHER_API_KEY",
+		})
+
+		usesProviders = append(usesProviders, shared.BaseModelUsesProvider{
+			Provider:       shared.ModelProviderCustom,
+			CustomProvider: &exampleProviderName,
+			ModelName:      "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
+		})
+	}
+	usesProviders = append(usesProviders, shared.BaseModelUsesProvider{
+		Provider:  shared.ModelProviderOpenRouter,
+		ModelName: "meta-llama/llama-4-maverick",
+	})
+
+	var customModels []*shared.CustomModel
+	if !isCloudIntegratedModels {
+		customModels = []*shared.CustomModel{
+			{
+				ModelId:     shared.ModelId("meta-llama/llama-4-maverick"),
+				Publisher:   shared.ModelPublisher("meta-llama"),
+				Description: "Meta Llama 4 Maverick",
+
+				BaseModelShared: shared.BaseModelShared{
+					DefaultMaxConvoTokens: 75000,
+					MaxTokens:             1048576,
+					MaxOutputTokens:       16000,
+					ReservedOutputTokens:  16000,
+					ModelCompatibility:    shared.FullCompatibility,
+					PreferredOutputFormat: shared.ModelOutputFormatXml,
+				},
+
+				Providers: usesProviders,
+			},
+		}
+	}
+
+	lightModelId := "meta-llama/llama-4-maverick"
+	if len(customModels) == 0 {
+		lightModelId = "mistral/devstral-small"
+	}
+
+	return shared.ClientModelsInput{
+		SchemaUrl:       shared.SchemaUrlInputConfig,
+		CustomProviders: customProviders,
+		CustomModels:    customModels,
+		CustomModelPacks: []*shared.ClientModelPackSchema{
+			{
+				Name:        "example-model-pack",
+				Description: "Example model pack",
+				ClientModelPackSchemaRoles: shared.ClientModelPackSchemaRoles{
+					Planner:   "deepseek/r1",
+					Architect: "deepseek/r1",
+					Coder: &shared.ModelRoleConfigSchema{
+						ModelId: "deepseek/v3",
+						LargeContextFallback: &shared.ModelRoleConfigSchema{
+							ModelId: "google/gemini-2.5-pro",
+						},
+						ErrorFallback: &shared.ModelRoleConfigSchema{
+							ModelId: "deepseek/r1-hidden",
+						},
+					},
+					PlanSummary: lightModelId,
+					Builder: shared.ModelRoleConfigSchema{
+						ModelId: "deepseek/r1-hidden",
+						StrongModel: &shared.ModelRoleConfigSchema{
+							ModelId: "openai/o3-medium",
+						},
+					},
+					WholeFileBuilder: shared.ModelRoleConfigSchema{
+						ModelId: "deepseek/r1-hidden",
+						LargeContextFallback: &shared.ModelRoleConfigSchema{
+							ModelId: "google/gemini-2.5-pro",
+							LargeOutputFallback: &shared.ModelRoleConfigSchema{
+								ModelId: "openai/o3-low",
+							},
+						},
+						LargeOutputFallback: &shared.ModelRoleConfigSchema{
+							ModelId: "openai/o3-low",
+						},
+					},
+					ExecStatus: "deepseek/r1-hidden",
+					Namer:      lightModelId,
+					CommitMsg:  lightModelId,
+				},
+			},
+		},
+	}
+}

app/cli/cmd/new.go

@@ -0,0 +1,134 @@
+package cmd
+
+import (
+	"fmt"
+
+	"plandex-cli/api"
+	"plandex-cli/auth"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"plandex-cli/types"
+
+	shared "plandex-shared"
+
+	"github.com/fatih/color"
+	"github.com/spf13/cobra"
+)
+
+var name string
+var contextBaseDir string
+
+// newCmd represents the new command
+var newCmd = &cobra.Command{
+	Use:     "new",
+	Aliases: []string{"n"},
+	Short:   "Start a new plan",
+	// Long:  ``,
+	Args: cobra.ExactArgs(0),
+	Run:  new,
+}
+
+func init() {
+	RootCmd.AddCommand(newCmd)
+	newCmd.Flags().StringVarP(&name, "name", "n", "", "Name of the new plan")
+	newCmd.Flags().StringVar(&contextBaseDir, "context-dir", ".", "Base directory to auto-load context from")
+
+	AddNewPlanFlags(newCmd)
+}
+
+func new(cmd *cobra.Command, args []string) {
+	auth.MustResolveAuthWithOrg()
+	lib.MustResolveOrCreateProject()
+
+	term.StartSpinner("")
+
+	errCh := make(chan error, 2)
+
+	var planId string
+	var config *shared.PlanConfig
+
+	go func() {
+		res, apiErr := api.Client.CreatePlan(lib.CurrentProjectId, shared.CreatePlanRequest{Name: name})
+		if apiErr != nil {
+			errCh <- fmt.Errorf("error creating plan: %v", apiErr.Msg)
+			return
+		}
+		planId = res.Id
+		errCh <- nil
+	}()
+
+	go func() {
+		var apiErr *shared.ApiError
+		config, apiErr = api.Client.GetDefaultPlanConfig()
+		if apiErr != nil {
+			errCh <- fmt.Errorf("error getting plan config: %v", apiErr.Msg)
+			return
+		}
+		errCh <- nil
+	}()
+
+	for i := 0; i < 2; i++ {
+		err := <-errCh
+		if err != nil {
+			term.OutputErrorAndExit("Error: %v", err)
+		}
+	}
+
+	err := lib.WriteCurrentPlan(planId)
+
+	if err != nil {
+		term.OutputErrorAndExit("Error setting current plan: %v", err)
+	}
+
+	err = lib.WriteCurrentBranch("main")
+	if err != nil {
+		term.OutputErrorAndExit("Error setting current branch: %v", err)
+	}
+
+	if name == "" {
+		name = "draft"
+	}
+
+	term.StopSpinner()
+
+	fmt.Printf("✅ Started new plan %s and set it to current plan\n", color.New(color.Bold, term.ColorHiGreen).Sprint(name))
+	fmt.Printf("⚙️  Using default config\n")
+
+	resolveAutoMode(config)
+
+	resolveModelPack()
+
+	// autoModeLabel := shared.ConfigSettingsByKey["automode"].KeyToLabel(string(config.AutoMode))
+	// fmt.Println("⚡️ Auto-mode:", autoModeLabel)
+
+	if config.AutoLoadContext {
+		fmt.Println("📥 Automatic context loading is enabled")
+
+		baseDir := contextBaseDir
+		if baseDir == "" {
+			baseDir = "."
+		}
+
+		lib.MustLoadContext([]string{baseDir}, &types.LoadContextParams{
+			DefsOnly:          true,
+			SkipIgnoreWarning: true,
+			AutoLoaded:        true,
+		})
+	} else {
+		fmt.Println()
+	}
+
+	var cmds []string
+	if term.IsRepl {
+		cmds = []string{"config", "plans", "cd", "models"}
+	} else {
+		cmds = []string{"tell", "chat", "config"}
+	}
+
+	if !config.AutoLoadContext {
+		cmds = append([]string{"load"}, cmds...)
+	}
+
+	fmt.Println()
+	term.PrintCmds("", cmds...)
+}

app/cli/cmd/plan_exec_helpers.go

@@ -0,0 +1,287 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"plandex-cli/lib"
+	"plandex-cli/term"
+	"strconv"
+
+	shared "plandex-shared"
+
+	"github.com/spf13/cobra"
+)
+
+const (
+	EditorTypeVim  string = "vim"
+	EditorTypeNano string = "nano"
+)
+
+var defaultEditor = EditorTypeVim
+
+const defaultAutoDebugTries = 5
+
+var autoConfirm bool
+
+var tellPromptFile string
+var tellBg bool
+var tellStop bool
+var tellNoBuild bool
+var tellAutoApply bool
+var tellAutoContext bool
+var tellSmartContext bool
+var tellSkipMenu bool
+var noExec bool
+var autoDebug int
+
+var editor = EditorTypeVim // default to vim
+var editorSetByFlag bool
+
+func init() {
+	envEditor := os.Getenv("EDITOR")
+	if envEditor == "" {
+		envEditor = os.Getenv("VISUAL")
+	}
+
+	if envEditor != "" {
+		defaultEditor = envEditor
+	}
+}
+
+type initExecFlagsParams struct {
+	omitFile         bool
+	omitNoBuild      bool
+	omitEditor       bool
+	omitStop         bool
+	omitBg           bool
+	omitApply        bool
+	omitExec         bool
+	omitAutoContext  bool
+	omitSmartContext bool
+	omitSkipMenu     bool
+}
+
+func initExecFlags(cmd *cobra.Command, params initExecFlagsParams) {
+	if !params.omitFile {
+		cmd.Flags().StringVarP(&tellPromptFile, "file", "f", "", "File containing prompt")
+	}
+
+	if !params.omitBg {
+		cmd.Flags().BoolVar(&tellBg, "bg", false, "Execute autonomously in the background")
+	}
+
+	if !params.omitStop {
+		cmd.Flags().BoolVarP(&tellStop, "stop", "s", false, "Stop after a single reply")
+	}
+
+	if !params.omitNoBuild {
+		cmd.Flags().BoolVarP(&tellNoBuild, "no-build", "n", false, "Don't build files")
+	}
+
+	cmd.Flags().BoolVar(&autoConfirm, "auto-update-context", false, shared.ConfigSettingsByKey["auto-update-context"].Desc)
+
+	if !params.omitAutoContext {
+		cmd.Flags().BoolVar(&tellAutoContext, "auto-load-context", false, shared.ConfigSettingsByKey["auto-load-context"].Desc)
+	}
+
+	if !params.omitSmartContext {
+		cmd.Flags().BoolVar(&tellSmartContext, "smart-context", false, shared.ConfigSettingsByKey["smart-context"].Desc)
+	}
+
+	if !params.omitApply {
+		cmd.Flags().BoolVar(&tellAutoApply, "apply", false, "Automatically apply changes")
+		initApplyFlags(cmd, true)
+	}
+
+	if !params.omitExec {
+		initExecScriptFlags(cmd)
+	}
+
+	if !params.omitEditor {
+		cmd.Flags().Var(newEditorValue(&editor), "editor", "Write prompt in system editor")
+		cmd.Flag("editor").NoOptDefVal = defaultEditor
+	}
+
+	if !params.omitSkipMenu {
+		cmd.Flags().BoolVar(&tellSkipMenu, "skip-menu", false, shared.ConfigSettingsByKey["skip-changes-menu"].Desc)
+	}
+}
+
+func initApplyFlags(cmd *cobra.Command, applyFlag bool) {
+	commitDesc := "Commit changes to git"
+	if applyFlag {
+		commitDesc += " when --apply is passed"
+	}
+
+	skipCommitDesc := "Skip committing changes to git"
+	if applyFlag {
+		skipCommitDesc += " when --apply is passed"
+	}
+	cmd.Flags().BoolVarP(&autoCommit, "commit", "c", false, commitDesc)
+	cmd.Flags().BoolVar(&skipCommit, "skip-commit", false, skipCommitDesc)
+}
+
+func initExecScriptFlags(cmd *cobra.Command) {
+	cmd.Flags().BoolVar(&noExec, "no-exec", false, "Disable command execution")
+	cmd.Flags().BoolVar(&autoExec, "auto-exec", false, "Automatically execute commands without confirmation")
+	cmd.Flags().Var(newAutoDebugValue(&autoDebug), "debug", "Automatically execute and debug failing commands (optionally specify number of tries—default is 5)")
+	cmd.Flag("debug").NoOptDefVal = strconv.Itoa(defaultAutoDebugTries)
+}
+
+func validatePlanExecFlags(isApply bool) {
+	if autoDebug > 0 && noExec {
+		term.OutputErrorAndExit("--debug can't be used with --no-exec")
+	}
+
+	if tellAutoContext && tellBg {
+		term.OutputErrorAndExit("--auto-context/-c can't be used with --bg")
+	}
+
+	if !isApply {
+		if autoDebug > 0 && !tellAutoApply {
+			term.OutputErrorAndExit("--debug can only be used with --apply")
+		}
+
+		if autoExec && !tellAutoApply {
+			term.OutputErrorAndExit("--auto-exec can only be used with --apply")
+		}
+
+		if tellAutoApply && tellNoBuild {
+			term.OutputErrorAndExit("--apply can't be used with --no-build/-n")
+		}
+		if tellAutoApply && tellBg {
+			term.OutputErrorAndExit("--apply can't be used with --bg")
+		}
+	}
+}
+
+func mustSetPlanExecFlags(cmd *cobra.Command, isApply bool) {
+	if lib.CurrentPlanId == "" {
+		term.OutputNoCurrentPlanErrorAndExit()
+	}
+
+	config := lib.MustGetCurrentPlanConfig()
+
+	// Set flag vars from config when flags aren't explicitly set
+	if !cmd.Flags().Changed("stop") {
+		tellStop = !config.AutoContinue
+	}
+
+	if !cmd.Flags().Changed("no-build") {
+		tellNoBuild = !config.AutoBuild
+	}
+
+	if !cmd.Flags().Changed("auto-update-context") {
+		autoConfirm = config.AutoUpdateContext
+	}
+	if !cmd.Flags().Changed("apply") {
+		tellAutoApply = config.AutoApply
+	}
+	if !cmd.Flags().Changed("skip-commit") {
+		skipCommit = config.SkipCommit
+	}
+	if !cmd.Flags().Changed("commit") {
+		autoCommit = config.AutoCommit
+	}
+	if !cmd.Flags().Changed("auto-load-context") {
+		tellAutoContext = config.AutoLoadContext
+	}
+	if !cmd.Flags().Changed("smart-context") {
+		tellSmartContext = config.SmartContext
+	}
+	if !cmd.Flags().Changed("no-exec") {
+		noExec = !config.CanExec
+	}
+	if !cmd.Flags().Changed("auto-exec") {
+		autoExec = config.AutoExec
+	}
+	if !cmd.Flags().Changed("debug") {
+		autoDebug = config.AutoDebugTries
+		// Only set autoDebug if AutoDebug is enabled in config
+		if !config.AutoDebug {
+			autoDebug = 0
+		}
+	}
+
+	if !cmd.Flags().Changed("skip-menu") {
+		tellSkipMenu = config.SkipChangesMenu
+	}
+
+	// tell command editor is no longer tied to config *unless* it's set to vim or nano
+	// otherwise, the flag or EDITOR env var are used
+	// config.Editor is now used for mainly for JSON editing (and perhaps other purposes)
+	// this is because it's pretty rare to use the editor for writing prompts now rather than the REPL
+	if !editorSetByFlag && (config.Editor == shared.EditorTypeVim || config.Editor == shared.EditorTypeNano) {
+		editor = config.Editor
+	}
+
+	validatePlanExecFlags(isApply)
+}
+
+// AutoDebugValue implements the flag.Value interface
+type autoDebugValue struct {
+	value *int
+}
+
+func newAutoDebugValue(p *int) *autoDebugValue {
+	*p = 0 // Default to 0 (disabled)
+	return &autoDebugValue{p}
+}
+
+func (f *autoDebugValue) Set(s string) error {
+	if s == "" {
+		*f.value = defaultAutoDebugTries
+		return nil
+	}
+	v, err := strconv.Atoi(s)
+	if err != nil {
+		return fmt.Errorf("invalid value for --debug: %v", err)
+	}
+	if v <= 0 {
+		return fmt.Errorf("--debug value must be greater than 0")
+	}
+	*f.value = v
+	return nil
+}
+
+func (f *autoDebugValue) String() string {
+	if f.value == nil {
+		return "0"
+	}
+	return strconv.Itoa(*f.value)
+}
+
+func (f *autoDebugValue) Type() string {
+	return "int"
+}
+
+// EditorValue implements the flag.Value interface
+type editorValue struct {
+	value *string
+}
+
+func newEditorValue(p *string) *editorValue {
+	*p = defaultEditor
+	return &editorValue{p}
+}
+
+func (f *editorValue) Set(s string) error {
+	if s == "" {
+		*f.value = defaultEditor
+		return nil
+	}
+	*f.value = s
+	editorSetByFlag = true
+	return nil
+}
+
+func (f *editorValue) String() string {
+	if f.value == nil {
+		return ""
+	}
+	return *f.value
+}
+
+func (f *editorValue) Type() string {
+	return "string"
+}