add tests

Replace all npm commands with bun equivalents across the entire codebase including:
- CI/CD workflows (GitHub Actions)
- Setup scripts and hooks
- Documentation and guidelines
- Test scripts and coverage checks
- Package.json scripts
- Pull request templates

This migration improves installation speed and reduces dependency resolution time while maintaining compatibility with existing workflows.

.changeset/cli-stdin-hang.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+fix(cli): prevent hang when spawned without TTY

.changeset/decimal-price-crash-fix.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fix decimal input crash in OpenAI Compatible price fields (#8129)

.changeset/famous-poems-smell.md

@@ -0,0 +1,5 @@
+---
+"cline": patch
+---
+
+Supports rendering markdown table in chat view.

.changeset/great-hornets-nail.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+fix: build complete handlers when upadting the api config

.changeset/hungry-ants-pump.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Updating script documentation and removing unnecessary continue on error

.changeset/silver-oranges-nail.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fixed missing provider from list

.changeset/skills-always-enabled.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+feat(skills): Make skills always enabled and remove feature toggle setting

.changeset/ten-coats-rule.md

@@ -0,0 +1,5 @@
+---
+"claude-dev": patch
+---
+
+Fixed Favorite Icon / Star from getting clipped in the task history view

.claude/hooks/claude-code-for-web-setup.sh

@@ -41,11 +41,11 @@ fi
 
 # Install project dependencies
 echo "Installing dependencies..."
-npm run install:all
+bun run install:all
 
 # Generate gRPC/protobuf types (required for TypeScript)
 echo "Generating proto types..."
-npm run protos
+bun run protos
 
 echo ""
 echo "Session setup complete!"

.cline/skills/create-pull-request/SKILL.md

@@ -147,29 +147,14 @@ When filling out the template:
 
 ### Create PR with gh CLI
 
-**Use a temporary file for the PR body** to avoid shell escaping issues, newline problems, and other command-line flakiness:
-
-1. Write the PR body to a temporary file:
-   ```
-   /tmp/pr-body.md
-   ```
-
-2. Create the PR using the file:
-   ```bash
-   gh pr create --title "PR_TITLE" --body-file /tmp/pr-body.md --base main
-   ```
-
-3. Clean up the temporary file:
-   ```bash
-   rm /tmp/pr-body.md
-   ```
-
-For draft PRs:
 ```bash
-gh pr create --title "PR_TITLE" --body-file /tmp/pr-body.md --base main --draft
+gh pr create --title "PR_TITLE" --body "PR_BODY" --base main
 ```
 
-**Why use a file?** Passing complex markdown with newlines, special characters, and checkboxes directly via `--body` is error-prone. The `--body-file` flag handles all content reliably.
+Alternatively, create as draft if the user wants review before marking ready:
+```bash
+gh pr create --title "PR_TITLE" --body "PR_BODY" --base main --draft
+```
 
 ## Post-Creation
 

.clinerules/general.md

@@ -147,17 +147,6 @@ Required steps:
 
 Common mistake: Adding only the return value without the `context.globalState.get()` call. This compiles but the value is always `undefined` on load.
 
-Settings plumbing gotcha: if a key is user-toggleable from settings, wire both controller update paths:
-- `src/core/controller/state/updateSettings.ts` for webview `updateSetting(...)`
-- `src/core/controller/state/updateSettingsCli.ts` for CLI/ACP settings updates
-Missing one path causes a toggle to appear to change in one surface while the backend state stays unchanged.
-
-Webview toggle gotcha: settings changes must also round-trip back in state payloads.
-- Add the field to `UpdateSettingsRequest` in `proto/cline/state.proto` (for webview update requests), then run `npm run protos`
-- Include the key in `Controller.getStateToPostToWebview()` (`src/core/controller/index.ts`)
-- Ensure `ExtensionState` and webview defaults include the key (`src/shared/ExtensionMessage.ts`, `webview-ui/src/context/ExtensionStateContext.tsx`)
-If this round-trip wiring is missing, the backend value can update but the toggle in webview appears stuck or reverts.
-
 ## StateManager Cache vs Direct globalState Access
 StateManager uses an in-memory cache populated during `StateManager.initialize(context)` in `common.ts`. For most state, use `controller.stateManager.setGlobalState()`/`getGlobalStateKey()`.
 

.clinerules/protobuf-development.md

@@ -42,7 +42,7 @@ Here, we use the common `StringRequest` and `KeyValuePair` types.
 
 After editing a `.proto` file, regenerate the TypeScript code. From the project root, run:
 ```bash
-npm run protos
+bun run protos
 ```
 This command compiles all `.proto` files and outputs the generated code to `src/generated/` and `src/shared/`. Do not edit these generated files manually.
 

.clinerules/workflows/hotfix-release.md

@@ -98,7 +98,7 @@ On the main branch, create a commit that updates:
 
    Each changeset file in `.changeset/` corresponds to a PR. Read them to identify which ones belong to the commits you're hotfixing, then delete those files.
 
-**Skip running `npm run install:all`** - the automation handles outdated lockfiles.
+**Skip running `bun run install:all`** - the automation handles outdated lockfiles.
 
 Commit with message format: `v{VERSION} Release Notes (hotfix)`
 

.codex/environments/environment.toml

@@ -1,49 +0,0 @@
-# THIS IS AUTOGENERATED. DO NOT EDIT MANUALLY
-version = 1
-name = "cline"
-
-[setup]
-script = '''
-if [ ! -d "node_modules" ]; then
-  MAIN_WORKTREE="$(git worktree list | head -n1 | awk '{print $1}')"
-  ln -s "$MAIN_WORKTREE/node_modules" node_modules
-  ln -s "$MAIN_WORKTREE/webview-ui/node_modules" webview-ui/node_modules
-fi
-'''
-
-[[actions]]
-name = "VS Code"
-icon = "run"
-command = "chmod +x ./scripts/run-extension-host.sh && ./scripts/run-extension-host.sh production"
-
-[[actions]]
-name = "CLI"
-icon = "run"
-command = '''
-npm run cli:build
-npm run cli:run
-'''
-
-[[actions]]
-name = "npm install"
-icon = "tool"
-command = '''
-rm node_modules
-rm webview-ui/node_modules
-npm run install:all
-'''
-
-[[actions]]
-name = "pull main"
-icon = "tool"
-command = '''
-git fetch origin main                                                                                                                                                             
-                                                                                                                                                                                
-if ! git merge-base --is-ancestor main origin/main; then                                                                                                                          
-  echo "Local main has commits not on origin/main. Aborting..."                                                                                                                     
-  exit 1                                                                                                                                                                          
-fi
-
-git update-ref refs/heads/main refs/remotes/origin/main
-echo "main updated to $(git rev-parse --short main)"
-'''

.github/CODEOWNERS

@@ -1,2 +1,3 @@
-/.github/   @saoudrizwan @arafatkatze @maxpaulus43 @candieduniverse
-/README.md  @saoudrizwan @juanpflores
+/docs/
+/.github/   @saoudrizwan @garoth @sjf
+/README.md  @saoudrizwan @nickbaumann98

.github/pull_request_template.md

@@ -59,8 +59,8 @@ We're not looking for exhaustive documentation - just evidence that you've thoug
 <!-- Put an 'x' in all boxes that apply -->
 
 -   [ ] Changes are limited to a single feature, bugfix or chore (split larger changes into separate PRs)
--   [ ] Tests are passing (`npm test`) and code is formatted and linted (`npm run format && npm run lint`)
--   [ ] I have created a changeset using `npm run changeset` (required for user-facing changes)
+-   [ ] Tests are passing (`bun test`) and code is formatted and linted (`bun run format && bun run lint`)
+-   [ ] I have created a changeset using `bun run changeset` (required for user-facing changes)
 -   [ ] I have reviewed [contributor guidelines](https://github.com/cline/cline/blob/main/CONTRIBUTING.md)
 
 ### Screenshots

.github/scripts/tests/coverage_check_test.py

@@ -62,9 +62,9 @@ class TestCoverage(unittest.TestCase):
             
             # Use xvfb-run on Linux
             if sys.platform.startswith('linux'):
-                cmd = f"cd {root_dir} && xvfb-run -a npm run test:coverage > {cls.extension_coverage_file} 2>&1"
+                cmd = f"cd {root_dir} && xvfb-run -a bun run test:coverage > {cls.extension_coverage_file} 2>&1"
             else:
-                cmd = f"cd {root_dir} && npm run test:coverage > {cls.extension_coverage_file} 2>&1"
+                cmd = f"cd {root_dir} && bun run test:coverage > {cls.extension_coverage_file} 2>&1"
             
             log("Running extension tests...")
             log(f"Command: {cmd}")
@@ -73,7 +73,7 @@ class TestCoverage(unittest.TestCase):
             
             # Run webview tests with coverage
             log("Running webview tests...")
-            cmd = f"cd {webview_dir} && npm run test:coverage > {cls.webview_coverage_file} 2>&1"
+            cmd = f"cd {webview_dir} && bun run test:coverage > {cls.webview_coverage_file} 2>&1"
             log(f"Command: {cmd}")
             result = subprocess.run(cmd, shell=True, check=False, capture_output=True, text=True)
             log(f"Webview tests exit code: {result.returncode}")

.github/workflows/claude-issue-triage.yml

@@ -0,0 +1,173 @@
+name: Claude Issue Triage
+
+on:
+  issues:
+    types: [opened]
+  # Manual trigger for backfilling existing issues. Run from terminal:
+  #   gh workflow run claude-issue-triage.yml -f issue_number=1234
+  # Or batch process:
+  #   gh issue list --state open --limit 10 --json number --jq '.[].number' | while read num; do
+  #     gh workflow run claude-issue-triage.yml -f issue_number=$num
+  #     sleep 60
+  #   done
+  workflow_dispatch:
+    inputs:
+      issue_number:
+        description: 'Issue number to triage'
+        required: true
+        type: string
+
+jobs:
+  claude-issue-triage:
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    # SECURITY: These permissions are intentionally restrictive.
+    # - contents: read  -> Claude can read the codebase but CANNOT write/push any code
+    # - issues: write   -> Claude can comment and add labels (the only write access needed)
+    # - pull-requests: read -> Claude can view PR context but CANNOT create PRs
+    # This ensures that even if a malicious user attempts prompt injection via issue content,
+    # Claude cannot modify repository code, create branches, or open PRs.
+    permissions:
+      contents: read
+      issues: write
+      pull-requests: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Run Issue Response & Triage
+        id: triage
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          allowed_non_write_users: "*"
+          # Allow all tools - security is enforced by GitHub permissions above (contents: read, issues: write)
+          claude_args: --model claude-opus-4-5-20251101 --allowedTools "Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch"
+          prompt: |
+            You're a GitHub issue first responder for the open source Cline repository.
+
+            **Issue:** #${{ github.event.issue.number || inputs.issue_number }}
+            **Title:** ${{ github.event.issue.title || 'See issue details below' }}
+            **Author:** @${{ github.event.issue.user.login || 'See issue details below' }}
+
+            ## Your job
+
+            Investigate this issue thoroughly, then post a single helpful comment that helps the user and gives maintainers the context they need.
+
+            ## Investigation
+
+            Start by reading the full issue:
+            gh issue view ${{ github.event.issue.number || inputs.issue_number }}
+
+            ### Search for duplicates and related issues
+
+            Search thoroughly for existing issues that match this one:
+            gh issue list --search "<keywords from the issue>" --state all --limit 30
+            gh issue list --search "<error messages>" --state all --limit 20
+            gh issue list --search "<affected feature/component>" --state all --limit 20
+
+            For each relevant issue you find, read it including its comments:
+            gh issue view <number> --comments
+
+            You're looking for:
+            - **Duplicates**: Issues describing the same problem. Link to them and explain why you think they're duplicates. If closed, check how they were resolved - the solution might apply here.
+            - **Related issues**: Similar problems or context that could help. Pull useful information from their comments (workarounds others found, debugging steps that helped, maintainer explanations). Link to them and explain the connection.
+
+            If there are closed issues with solutions, surface those solutions prominently - this might immediately solve the user's problem.
+
+            ### Analyze recent changes (ALWAYS DO THIS)
+
+            Many issues are regressions from recent releases. **Always** check what changed recently:
+            gh release list --limit 10
+            gh pr list --state merged --limit 50 --json number,title,mergedAt,author,body
+
+            Look for PRs merged in the last few weeks that might correlate with the issue. If you find a likely connection:
+            gh pr view <number>
+            gh pr diff <number>
+            git log --since="1 month ago" --oneline -- <relevant paths>
+            git show <commit>
+
+            **Always include your findings in your comment:**
+            - If you find a regression, call it out explicitly: which PR/commit likely caused it, who authored it, what changed, and suggest a fix direction if you can see one.
+            - If you don't find anything related, still mention it: "I analyzed recent PRs and releases but didn't find any changes that seem related to this issue."
+
+            ### Search the codebase
+
+            Find the relevant code:
+            - Use grep/find to locate code related to the issue
+            - Key areas: `src/api/` (providers/models), `src/core/prompts/` (tools/prompts), platform-specific code for VS Code vs JetBrains
+
+            ### Find documentation
+
+            Cline docs are at **https://docs.cline.bot/** and built with Mintlify from the `docs/` directory.
+
+            The URL structure maps directly to the file structure:
+            - `docs/getting-started/selecting-your-model.mdx` → https://docs.cline.bot/getting-started/selecting-your-model
+            - `docs/troubleshooting.mdx` → https://docs.cline.bot/troubleshooting
+            - Headings become anchors: `## Which Model` → `#which-model`
+
+            Search the `docs/` directory to find relevant documentation, then construct URLs to link users to:
+            ```bash
+            ls docs/
+            grep -r "keyword" docs/ --include="*.mdx" -l
+            ```
+
+            ### Identify subject matter experts
+
+            For issues that clearly need engineering attention:
+            git log --since="6 months ago" --format="%an" -- <relevant paths> | sort | uniq -c | sort -rn | head -5
+
+            Cross-reference with GitHub usernames. Include in your response (@mention, do NOT assign):
+
+            | SME | Reason |
+            |-----|--------|
+            | @username1 | Authored PR #X which modified this area |
+            | @username2 | Primary contributor to affected file |
+
+            ## Weak model detection
+
+            Many issues are caused by users running small or non-frontier models that don't tool-call reliably. Signs include:
+            - Model failing to use tools correctly
+            - Nonsensical or malformed responses
+            - User is running a small/local model or older model version
+
+            If this looks like a weak model issue, kindly suggest they try reproducing with Claude Sonnet and report back if it persists. Link to https://docs.cline.bot/getting-started/selecting-your-model if helpful. Still label and triage normally.
+
+            ## Your comment
+
+            Write a single comment as a helpful community member. Be conversational, not robotic. Include what's relevant:
+
+            - **Helpful response** - Answer their question, suggest a fix, provide a workaround. If you found solutions in related closed issues, surface those prominently.
+            - **Duplicates and related issues** - Link to any you found and explain why they're duplicates/related. Summarize useful context from their comments.
+            - **Regression analysis** - If this looks like a regression, explain what change likely caused it, link to the PR/commit, and tag the author.
+            - **Clarifying questions** - If you need more info, ask specific questions. Don't ask for things already provided.
+            - **SME table** - Include the table above if this needs engineering attention. Don't tag people for questions with obvious answers or weak-model issues.
+            - **Context for maintainers** - Relevant code paths, what you found. Keep it concise.
+            - **Docs links** - If there's relevant documentation, link to it naturally in your response as a recommendation (e.g., "For more details, check out [the Ollama setup guide](url)"). Do NOT add a "Sources" section at the end - integrate doc links into your response where they're helpful.
+            - **Possible Duplicates section** - ALWAYS include a "Possible Duplicates" section at the end of your comment listing issues that might be duplicates so maintainers can quickly close if appropriate. If none found, say "No obvious duplicates found."
+
+            ## Labels
+            First, retrieve all available labels and read their descriptions to understand what each is for:
+            gh label list --json name,description --limit 100
+
+            Then apply the appropriate labels based on your analysis. Only use labels from the list above—do not create new labels.
+            gh issue edit ${{ github.event.issue.number || inputs.issue_number }} --add-label "label1,label2"
+
+            If your regression analysis found a likely culprit (a recent PR/commit that probably caused this issue), add the "Regression" label:
+            gh issue edit ${{ github.event.issue.number || inputs.issue_number }} --add-label "Regression"
+
+            IMPORTANT: After posting your comment, add the "Bot Responded" label to indicate this issue has received an automated response:
+            gh issue edit ${{ github.event.issue.number || inputs.issue_number }} --add-label "Bot Responded"
+
+            ## Remember
+
+            - **This is a one-time automated response** - you will NOT see their reply or respond again. Never say things like "I can help you", "let me know", "once I have that info", or "I can give you more targeted help" - you won't be there to follow up. If you ask clarifying questions, frame them for the maintainers who will follow up, e.g., "If you can share X, that would help the maintainers diagnose this."
+            - Don't be formulaic. Respond to what the issue actually needs.
+            - Surface solutions from past issues - often the fastest path to helping.
+            - Connecting regressions to specific changes is extremely valuable.
+            - Link issues with #number so they're clickable.

.github/workflows/claude-pr-review.yml

@@ -0,0 +1,284 @@
+name: Claude PR Review
+
+on:
+  pull_request:
+    types: [opened, ready_for_review]
+  # Manual trigger for backfilling existing PRs. Run from terminal:
+  #   gh workflow run claude-pr-review.yml -f pr_number=1234
+  # Or batch process open PRs:
+  #   gh pr list --state open --limit 10 --json number --jq '.[].number' | while read num; do
+  #     gh workflow run claude-pr-review.yml -f pr_number=$num
+  #     sleep 60
+  #   done
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: 'PR number to review'
+        required: true
+        type: string
+
+jobs:
+  claude-pr-review:
+    # Runs on PR opened/ready_for_review (skips drafts) or manual trigger for backfilling
+    if: |
+      (github.event_name == 'pull_request' && github.event.pull_request.draft == false) ||
+      github.event_name == 'workflow_dispatch'
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+
+    # SECURITY: These permissions are intentionally restrictive.
+    # - contents: read  -> Claude can read the codebase but CANNOT write/push any code
+    # - pull-requests: write -> Claude can post reviews and inline suggestions
+    # - issues: read -> Claude can search for related issues
+    # NOTE: Even with pull-requests: write, Claude CANNOT merge PRs because branch protection
+    # requires 1 approval from a Code Owner. The GITHUB_TOKEN cannot bypass this.
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Print HEAD commit
+        run: |
+          echo "HEAD is at: $(git rev-parse HEAD)"
+          echo "Short: $(git rev-parse --short HEAD)"
+          git log -1 --format="Commit: %H%nAuthor: %an <%ae>%nDate: %ad%nMessage: %s"
+
+      - name: Get PR number
+        id: pr
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "number=${{ inputs.pr_number }}" >> $GITHUB_OUTPUT
+          else
+            echo "number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Run PR Review
+        id: review
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          allowed_non_write_users: "*"
+          claude_args: --model claude-opus-4-5-20251101 --allowedTools "Bash,Read,Write,Edit,Glob,Grep,WebFetch,WebSearch"
+          prompt: |
+            You're a GitHub PR reviewer for the open source Cline repository. Your goal is to give the PR author helpful feedback and give maintainers the context they need to review efficiently.
+
+            PR: #${{ steps.pr.outputs.number }}
+
+            ## Gather context
+
+            ```bash
+            # Get full PR details
+            gh pr view ${{ steps.pr.outputs.number }} --json number,title,body,author,createdAt,updatedAt,isDraft,labels,commits,files,additions,deletions,changedFiles,baseRefName,headRefName,mergeable,reviewDecision
+
+            # Get the diff
+            gh pr diff ${{ steps.pr.outputs.number }}
+
+            # Check CI status
+            gh pr checks ${{ steps.pr.outputs.number }}
+
+            # Get existing review comments (to understand context and your previous feedback)
+            gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/comments --jq '.[] | {user: .user.login, body: .body, path: .path, created_at: .created_at}'
+
+            # Get conversation comments
+            gh pr view ${{ steps.pr.outputs.number }} --comments
+            ```
+
+            If this is a re-review (workflow_dispatch event):
+            Read your previous comments carefully. Understand what you asked for before.
+            Check if new commits or comments address your previous feedback.
+
+            ## Check contributing guidelines
+
+            Flag (but don't block) if:
+            - Missing changeset - For user-facing changes, check if there's a `.changeset/` file:
+              ```bash
+              gh pr diff ${{ steps.pr.outputs.number }} --name-only | grep '.changeset/' || echo "No changeset found"
+              ```
+              If missing, ask them to run `npm run changeset`
+            - Missing tests - New features should have tests
+
+            ## Find related issues and PRs
+
+            Search thoroughly for context that might help with the review:
+
+            ```bash
+            # Find related issues for context
+            gh issue list --search "<keywords from the PR>" --state all --limit 30
+            gh issue list --search "<error messages or feature names>" --state all --limit 20
+
+            # Find similar PRs for reference
+            gh pr list --search "<keywords>" --state all --limit 30
+            ```
+
+            For each relevant issue or PR you find, read it including comments:
+            ```bash
+            gh issue view <number> --comments
+            gh pr view <number> --comments
+            ```
+
+            Look for:
+            - Open issues this PR might fix that weren't linked in the description
+            - Similar PRs that went through review - what feedback did they get? What patterns did they follow?
+            - Context from maintainer discussions that could inform your review
+
+            ## Find subject matter experts
+
+            For files changed in this PR, find who knows the code best:
+            ```bash
+            # Get files changed
+            gh pr diff ${{ steps.pr.outputs.number }} --name-only
+
+            # For each relevant path, find contributors
+            git log --since="6 months ago" --format="%an" -- <path> | sort | uniq -c | sort -rn | head -5
+            ```
+
+            Cross-reference git authors with GitHub usernames. Include an SME table in your response:
+
+            | SME | Reason |
+            |-----|--------|
+            | @username1 | Authored PR #X which modified this area |
+            | @username2 | Primary contributor to affected file (15 commits in 6 months) |
+            | @username3 | Reviewed similar PR #Y with extensive feedback |
+
+            ## Deep code review
+
+            This is the most important part. Don't just look for syntax issues - understand what the PR is trying to achieve and whether the implementation is the right approach.
+
+            Step 1: Understand the intent
+            Read the PR description and understand what the author is trying to accomplish. What problem are they solving? What feature are they adding?
+
+            Step 2: Form your own opinion first
+            Before analyzing their code, think about how YOU would implement this feature or fix. What files would you touch? What patterns would you follow? What edge cases would you handle?
+
+            Step 3: Compare approaches
+            Now look at their implementation. How does it compare to what you would have done?
+            - Is their approach better in some ways? Note what they did well.
+            - Is their approach missing something? Be specific about what and why.
+            - Are there edge cases they haven't considered?
+            - Does it follow the patterns established in similar parts of the codebase?
+
+            Step 4: Look at the bigger picture
+            - What other files or systems does this change interact with?
+            - Could this break anything else?
+            - Is there additional work needed beyond this PR to complete the feature?
+            - Does this fit well with the overall architecture?
+
+            Step 5: Find reference implementations
+            Look for similar changes in the codebase:
+            ```bash
+            git log --oneline --all --grep="<relevant keywords>" | head -20
+            git log --oneline -- <similar files> | head -20
+            ```
+
+            If this is adding a new API provider, look at how other providers are implemented.
+            If this is adding a new feature, look at how similar features were added.
+            Note where their implementation aligns with or diverges from established patterns.
+
+            Step 6: Standard code review checks
+            - DRY: Is there duplicated code that could be extracted?
+            - Error handling: Are errors handled appropriately?
+            - Security: Any injection risks, credential exposure, unsafe dependencies?
+            - Performance: Any obvious inefficiencies, memory leaks, N+1 patterns?
+            - Types: Is TypeScript used correctly? Any unsafe type assertions?
+            - Naming: Are variables and functions named clearly?
+            - Comments: Is complex logic explained? Are there outdated comments?
+
+            ## Inline code suggestions
+
+            For specific code improvements, use GitHub's suggestion syntax via `gh api`.
+            This creates suggestions the author can commit with one click.
+
+            Single-line suggestion:
+            ```bash
+            gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/reviews \
+              -X POST \
+              -f commit_id="$(gh pr view ${{ steps.pr.outputs.number }} --json headRefOid -q .headRefOid)" \
+              -f event="COMMENT" \
+              -f body="" \
+              -F comments='[
+                {
+                  "path": "src/example.ts",
+                  "line": 42,
+                  "body": "Consider simplifying:\n\n```suggestion\nconst result = items.filter(Boolean);\n```"
+                }
+              ]'
+            ```
+
+            Multi-line suggestion (replacing lines 40-45):
+            ```bash
+            gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/reviews \
+              -X POST \
+              -f commit_id="$(gh pr view ${{ steps.pr.outputs.number }} --json headRefOid -q .headRefOid)" \
+              -f event="COMMENT" \
+              -f body="" \
+              -F comments='[
+                {
+                  "path": "src/example.ts",
+                  "start_line": 40,
+                  "line": 45,
+                  "body": "This can be simplified:\n\n```suggestion\nconst simplified = doThing();\n```"
+                }
+              ]'
+            ```
+
+            Use inline suggestions for concrete improvements. Use regular comments for questions or broader feedback.
+
+            ## Post your review
+
+            After your investigation, post a single helpful comment that helps the author and gives maintainers context.
+
+            Start by noting the commit hash you reviewed:
+            ```bash
+            git rev-parse --short HEAD
+            ```
+            Include this at the top of your comment: "Reviewed at commit: <short hash>"
+
+            Then thank them for their contribution. Be conversational, not robotic.
+
+            Include what's relevant:
+            - In-depth explanation of what the PR does - Be comprehensive. A maintainer should be able to read this section and fully understand the author's intent, why they made the changes, how they implemented it, and what files/systems are affected. Don't just summarize - explain.
+            - Related issues/PRs you found that provide useful context (link to them)
+            - Your review findings (issues to address, suggestions, etc.)
+            - Clear next steps for the author
+
+            Include a "For Maintainers" section with:
+            - Anything else useful to help the maintainer resolve this PR
+            - Related issues/PRs with context on why they're relevant
+            - Open issues this PR might fix that weren't linked in the description
+            - Your recommendation: merge as-is, needs changes, needs discussion, close, etc.
+            - SME table - who should review this and why
+
+            For the SME table:
+            | SME | Reason |
+            |-----|--------|
+            | @username | Primary contributor to affected files |
+
+            ## Update labels
+
+            Add appropriate labels based on your analysis:
+            ```bash
+            gh label list --json name,description --limit 100
+            gh pr edit ${{ steps.pr.outputs.number }} --add-label "label1,label2"
+            ```
+
+            When done, add the reviewed label:
+            ```bash
+            gh pr edit ${{ steps.pr.outputs.number }} --add-label "Bot Reviewed"
+            ```
+
+            ## Remember
+
+            - This is a one-time automated response - you will NOT see their reply or respond again. Never say things like "let me know if you have questions", "I can help you with", or "feel free to ask" - you won't be there to follow up. Frame any questions for the maintainers who will follow up.
+            - Be helpful and welcoming - Many contributors are new to the project
+            - Be specific - Point to exact lines and suggest fixes, don't give vague feedback
+            - Think deeply - Don't just surface-level review, understand the intent and evaluate the approach
+            - Use inline suggestions - Make it easy for authors to accept changes
+            - You're a first-pass reviewer - A human maintainer will do final approval

.github/workflows/cline-evals-regression.yml

@@ -1,70 +0,0 @@
-name: Smoke Tests
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - 'src/core/**'
-      - 'src/shared/**'
-      - 'proto/**'
-      - 'evals/**'
-      - '.github/workflows/cline-evals-regression.yml'
-  pull_request:
-    paths:
-      - 'src/core/**'
-      - 'src/shared/**'
-      - 'proto/**'
-      - 'evals/**'
-      - '.github/workflows/cline-evals-regression.yml'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: smoke-tests-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  smoke-tests:
-    name: Smoke Tests
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-          cache: 'npm'
-
-      - name: Install dependencies
-        run: npm ci
-
-      - name: Build and install CLI
-        run: |
-          npm run protos
-          cd cli && npm install && npm run build && npm link
-          echo "$(npm config get prefix)/bin" >> $GITHUB_PATH
-
-      - name: Verify CLI
-        run: cline --version
-
-      - name: Run smoke tests
-        env:
-          CLINE_API_KEY: ${{ secrets.CLINE_API_KEY }}
-        run: |
-          cline auth -p cline -k "$CLINE_API_KEY" -m "anthropic/claude-sonnet-4.5"
-          npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1 --parallel
-
-      - name: Generate summary
-        if: always()
-        run: cat evals/smoke-tests/results/latest/summary.md >> $GITHUB_STEP_SUMMARY
-
-      - name: Upload results
-        uses: actions/upload-artifact@v4
-        if: always()
-        with:
-          name: smoke-test-results-${{ github.run_id }}
-          path: evals/smoke-tests/results/latest/
-          retention-days: 30

.github/workflows/cline-pr-review.yml

@@ -0,0 +1,325 @@
+name: Cline PR Code Review
+
+on:
+  pull_request:
+    types:
+      [opened, ready_for_review]
+      # Manual trigger for backfilling existing PRs. Run from terminal:
+      #   gh workflow run cline-pr-review.yml -f pr_number=1234
+      # Or batch process open PRs:
+      #   gh pr list --state open --limit 10 --json number --jq '.[].number' | while read num; do
+      #     gh workflow run cline-pr-review.yml -f pr_number=$num
+      #     sleep 60
+      #   done
+  workflow_dispatch:
+    inputs:
+      pr_number:
+        description: "PR number to review"
+        required: true
+        type: string
+
+concurrency:
+  group: pr-review-${{ github.event.pull_request.number || inputs.pr_number }}
+  cancel-in-progress: true
+
+jobs:
+  cline-pr-review:
+    # Runs on PR opened/ready_for_review (skips drafts) or manual trigger for backfilling
+    if: |
+      (github.event_name == 'pull_request' && github.event.pull_request.draft == false) ||
+      github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+
+    # SECURITY: These permissions are intentionally restrictive.
+    # - contents: read  -> cline can read the codebase but CANNOT write/push any code
+    # - pull-requests: write -> cline can post reviews and inline suggestions
+    # - issues: read -> cline can search for related issues
+    # NOTE: Even with pull-requests: write, cline CANNOT merge PRs because branch protection
+    # requires 1 approval from a Code Owner. The GITHUB_TOKEN cannot bypass this.
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Print HEAD commit
+        run: |
+          echo "HEAD is at: $(git rev-parse HEAD)"
+          echo "Short: $(git rev-parse --short HEAD)"
+          git log -1 --format="Commit: %H%nAuthor: %an <%ae>%nDate: %ad%nMessage: %s"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: "npm"
+
+      - name: Install and Verify Cline CLI
+        run: |
+          npm install -g cline
+          cline version # verify installation
+
+      - name: Configure Cline with Anthropic
+        run: |
+          npx cline auth --provider anthropic \
+            --apikey "${{ secrets.ANTHROPIC_API_KEY }}" \
+            --modelid claude-opus-4-5-20251101
+
+      - name: Get PR number
+        id: pr
+        run: |
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "number=${{ inputs.pr_number }}" >> $GITHUB_OUTPUT
+          else
+            echo "number=${{ github.event.pull_request.number }}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Review PR with Cline
+        env:
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+          GITHUB_REPO: ${{ github.repository }}
+          GH_TOKEN: ${{ github.token }}
+          CLINE_COMMAND_PERMISSIONS: |
+            {
+              "allow": [
+                "gh pr diff *",
+                "gh pr view *",
+                "gh pr checks *",
+                "gh pr list *",
+                "gh label list *",
+                "gh issue list *",
+                "gh issue view *",
+                "git log *",
+                "gh pr comment ${{ steps.pr.outputs.number }} *",
+                "gh pr edit ${{ steps.pr.outputs.number }} *",
+                "gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/comments *",
+                "gh api repos/${{ github.repository }}/pulls/${{ steps.pr.outputs.number }}/reviews *"
+              ]
+            }
+        run: |
+          npx cline --yolo 'You'\''re a GitHub PR reviewer for the open source Cline repository. Your goal is to give the PR author helpful feedback and give maintainers the context they need to review efficiently.
+
+          PR: #'"${PR_NUMBER}"'
+
+          ## Gather context
+
+          ```bash
+          # Get full PR details
+          gh pr view '"${PR_NUMBER}"' --json number,title,body,author,createdAt,updatedAt,isDraft,labels,commits,files,additions,deletions,changedFiles,baseRefName,headRefName,mergeable,reviewDecision
+
+          # Get the diff
+          gh pr diff '"${PR_NUMBER}"'
+
+          # Check CI status
+          gh pr checks '"${PR_NUMBER}"'
+
+          # Get existing review comments (to understand context and your previous feedback)
+          gh api repos/'"${GITHUB_REPO}"'/pulls/'"${PR_NUMBER}"'/comments --jq '\''.[] | {user: .user.login, body: .body, path: .path, created_at: .created_at}'\''
+
+          # Get conversation comments
+          gh pr view '"${PR_NUMBER}"' --comments
+          ```
+
+          If this is a re-review (workflow_dispatch event):
+          Read your previous comments carefully. Understand what you asked for before.
+          Check if new commits or comments address your previous feedback.
+
+          ## Check contributing guidelines
+
+          Flag (but don'\''t block) if:
+          - Missing changeset - For user-facing changes, check if there'\''s a `.changeset/` file:
+            ```bash
+            gh pr diff '"${PR_NUMBER}"' --name-only | grep '\''.changeset/'\'' || echo '\''No changeset found'\''
+            ```
+            If missing, ask them to run `npm run changeset`
+          - Missing tests - New features should have tests
+
+          ## Find related issues and PRs
+
+          Search thoroughly for context that might help with the review:
+
+          ```bash
+          # Find related issues for context
+          gh issue list --search '\''<keywords from the PR>'\'' --state all --limit 30
+          gh issue list --search '\''<error messages or feature names>'\'' --state all --limit 20
+
+          # Find similar PRs for reference
+          gh pr list --search '\''<keywords>'\'' --state all --limit 30
+          ```
+
+          For each relevant issue or PR you find, read it including comments:
+          ```bash
+          gh issue view <number> --comments
+          gh pr view <number> --comments
+          ```
+
+          Look for:
+          - Open issues this PR might fix that weren'\''t linked in the description
+          - Similar PRs that went through review - what feedback did they get? What patterns did they follow?
+          - Context from maintainer discussions that could inform your review
+
+          ## Find subject matter experts
+
+          For files changed in this PR, find who knows the code best:
+          ```bash
+          # Get files changed
+          gh pr diff '"${PR_NUMBER}"' --name-only
+
+          # For each relevant path, find contributors
+          git log --since='\''6 months ago'\'' --format='\''%an'\'' -- <path> | sort | uniq -c | sort -rn | head -5
+          ```
+
+          Cross-reference git authors with GitHub usernames. Include an SME table in your response:
+
+          | SME | Reason |
+          |-----|--------|
+          | @username1 | Authored PR #X which modified this area |
+          | @username2 | Primary contributor to affected file (15 commits in 6 months) |
+          | @username3 | Reviewed similar PR #Y with extensive feedback |
+
+          ## Bash command usage
+
+          Don'\''t use operators like `|`, `&&`, or `;` - run each command separately and analyze the output.
+
+          When referencing command outputs, quote them properly to avoid formatting issues.
+
+          ## Deep code review
+
+          This is the most important part. Don'\''t just look for syntax issues - understand what the PR is trying to achieve and whether the implementation is the right approach.
+
+          Step 1: Understand the intent
+          Read the PR description and understand what the author is trying to accomplish. What problem are they solving? What feature are they adding?
+
+          Step 2: Form your own opinion first
+          Before analyzing their code, think about how YOU would implement this feature or fix. What files would you touch? What patterns would you follow? What edge cases would you handle?
+
+          Step 3: Compare approaches
+          Now look at their implementation. How does it compare to what you would have done?
+          - Is their approach better in some ways? Note what they did well.
+          - Is their approach missing something? Be specific about what and why.
+          - Are there edge cases they haven'\''t considered?
+          - Does it follow the patterns established in similar parts of the codebase?
+
+          Step 4: Look at the bigger picture
+          - What other files or systems does this change interact with?
+          - Could this break anything else?
+          - Is there additional work needed beyond this PR to complete the feature?
+          - Does this fit well with the overall architecture?
+
+          Step 5: Find reference implementations
+          Look for similar changes in the codebase:
+          ```bash
+          git log --oneline --all --grep='\''<relevant keywords>'\'' | head -20
+          git log --oneline -- <similar files> | head -20
+          ```
+
+          If this is adding a new API provider, look at how other providers are implemented.
+          If this is adding a new feature, look at how similar features were added.
+          Note where their implementation aligns with or diverges from established patterns.
+
+          Step 6: Standard code review checks
+          - DRY: Is there duplicated code that could be extracted?
+          - Error handling: Are errors handled appropriately?
+          - Security: Any injection risks, credential exposure, unsafe dependencies?
+          - Performance: Any obvious inefficiencies, memory leaks, N+1 patterns?
+          - Types: Is TypeScript used correctly? Any unsafe type assertions?
+          - Naming: Are variables and functions named clearly?
+          - Comments: Is complex logic explained? Are there outdated comments?
+
+          ## Inline code suggestions
+
+          For specific code improvements, use GitHub'\''s suggestion syntax via `gh api`.
+          This creates suggestions the author can commit with one click.
+
+          Single-line suggestion:
+          ```bash
+          gh api repos/'"${GITHUB_REPO}"'/pulls/'"${PR_NUMBER}"'/reviews \
+            -X POST \
+            -f commit_id="$(gh pr view '"${PR_NUMBER}"' --json headRefOid -q .headRefOid)" \
+            -f event='\''COMMENT'\'' \
+            -f body='\'''\'' \
+            -F comments='\''[
+              {
+                "path": "src/example.ts",
+                "line": 42,
+                "body": "Consider simplifying:\n\n```suggestion\nconst result = items.filter(Boolean);\n```"
+              }
+            ]'\''
+          ```
+
+          Multi-line suggestion (replacing lines 40-45):
+          ```bash
+          gh api repos/'"${GITHUB_REPO}"'/pulls/'"${PR_NUMBER}"'/reviews \
+            -X POST \
+            -f commit_id="$(gh pr view '"${PR_NUMBER}"' --json headRefOid -q .headRefOid)" \
+            -f event='\''COMMENT'\'' \
+            -f body='\'''\'' \
+            -F comments='\''[
+              {
+                "path": "src/example.ts",
+                "start_line": 40,
+                "line": 45,
+                "body": "This can be simplified:\n\n```suggestion\nconst simplified = doThing();\n```"
+              }
+            ]'\''
+          ```
+
+          Use inline suggestions for concrete improvements. Use regular comments for questions or broader feedback.
+
+          ## Post your review
+
+          After your investigation, post a single helpful comment that helps the author and gives maintainers context.
+
+          Start by noting the commit hash you reviewed:
+          ```bash
+          git rev-parse --short HEAD
+          ```
+          Include this at the top of your comment: "Reviewed at commit: <short hash>"
+
+          Then thank them for their contribution. Be conversational, not robotic.
+
+          Include what'\''s relevant:
+          - In-depth explanation of what the PR does - Be comprehensive. A maintainer should be able to read this section and fully understand the author'\''s intent, why they made the changes, how they implemented it, and what files/systems are affected. Don'\''t just summarize - explain.
+          - Related issues/PRs you found that provide useful context (link to them)
+          - Your review findings (issues to address, suggestions, etc.)
+          - Clear next steps for the author
+
+          Include a '\''For Maintainers'\'' section with:
+          - Anything else useful to help the maintainer resolve this PR
+          - Related issues/PRs with context on why they'\''re relevant
+          - Open issues this PR might fix that weren'\''t linked in the description
+          - Your recommendation: merge as-is, needs changes, needs discussion, close, etc.
+          - SME table - who should review this and why
+
+          For the SME table:
+          | SME | Reason |
+          |-----|--------|
+          | @username | Primary contributor to affected files |
+
+          ## Update labels
+
+          Add appropriate labels based on your analysis:
+          ```bash
+          gh label list --json name,description --limit 100
+          gh pr edit '"${PR_NUMBER}"' --add-label '\''label1,label2'\''
+          ```
+
+          When done, add the reviewed label:
+          ```bash
+          gh pr edit '"${PR_NUMBER}"' --add-label '\''Bot Reviewed'\''
+          ```
+
+          ## Remember
+
+          - This is a one-time automated response - you will NOT see their reply or respond again. Never say things like '\''let me know if you have questions'\'', '\''I can help you with'\'', or '\''feel free to ask'\'' - you won'\''t be there to follow up. Frame any questions for the maintainers who will follow up.
+          - Be helpful and welcoming - Many contributors are new to the project
+          - Be specific - Point to exact lines and suggest fixes, don'\''t give vague feedback
+          - Think deeply - Don'\''t just surface-level review, understand the intent and evaluate the approach
+          - Use inline suggestions - Make it easy for authors to accept changes
+          - You'\''re a first-pass reviewer - A human maintainer will do final approval'

.github/workflows/e2e.yml

@@ -35,26 +35,10 @@ jobs:
             contents: read
         steps:
             - uses: actions/checkout@v4
-            - name: Setup Node.js environment
-              uses: actions/setup-node@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
               with:
-                  node-version: 22
-
-            # Cache root dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache root dependencies
-              uses: actions/cache@v4
-              id: root-cache
-              with:
-                  path: node_modules
-                  key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
-
-            # Cache webview-ui dependencies - only reuse if package-lock.json exactly matches
-            - name: Cache webview-ui dependencies
-              uses: actions/cache@v4
-              id: webview-cache
-              with:
-                  path: webview-ui/node_modules
-                  key: ${{ runner.os }}-npm-webview-${{ hashFiles('webview-ui/package-lock.json') }}
+                  bun-version: latest
 
             # Cache VS Code installation
             - name: Cache VS Code
@@ -75,20 +59,17 @@ jobs:
                       ~/.cache/ms-playwright
                       ~/Library/Caches/ms-playwright
                       ~/AppData/Local/ms-playwright
-                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+                  key: playwright-browsers-${{ runner.os }}-${{ hashFiles('bun.lockb') }}
                   restore-keys: |
                       playwright-browsers-${{ runner.os }}-
 
-            - name: Install root dependencies
-              run: npm ci
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            - name: Install webview-ui dependencies
-              run: cd webview-ui && npm ci
-
             - name: Install vsce
-              run: npm install -g @vscode/vsce
+              run: bun add -g @vscode/vsce
 
             - name: Install xvfb on Linux
               if: matrix.runner == 'ubuntu'
@@ -97,11 +78,11 @@ jobs:
             # Run optimized E2E tests (eliminates redundant builds)
             - name: Run E2E tests - Linux
               if: matrix.runner == 'ubuntu'
-              run: xvfb-run -a npm run test:e2e:optimal
+              run: xvfb-run -a bun run test:e2e:optimal
 
             - name: Run E2E tests - Non-Linux
               if: matrix.runner != 'ubuntu'
-              run: npm run test:e2e:optimal
+              run: bun run test:e2e:optimal
 
             - uses: actions/upload-artifact@v4
               if: ${{ failure() }}

.github/workflows/npm-main.yaml

@@ -1,7 +1,7 @@
 name: Publish NPM Release
 
 on:
-  workflow_call:
+  workflow_dispatch:
     inputs:
       confirm_publish:
         description: 'Type "publish" to confirm you want to publish to NPM'
@@ -9,8 +9,7 @@ on:
         type: string
 
 permissions:
-  contents: write # Required for pushing tags
-  id-token: write # Required for npm trusted publishing (OIDC)
+  contents: read
   checks: write # Required by test workflow
   pull-requests: write # Required by test workflow
 
@@ -21,7 +20,7 @@ jobs:
   publish-npm-release:
     needs: test
     name: Publish Cline CLI to NPM
-    if: github.repository == 'cline/cline' && github.ref == 'refs/heads/main' && inputs.confirm_publish == 'publish'
+    if: github.repository == 'cline/cline' && github.ref == 'refs/heads/main' && github.event.inputs.confirm_publish == 'publish'
     runs-on: ubuntu-latest
 
     steps:
@@ -31,10 +30,19 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "24.x"
+          node-version: "20.x"
           registry-url: "https://registry.npmjs.org"
 
+      # Cache root dependencies - only reuse if package-lock.json exactly matches
+      - name: Cache root dependencies
+        uses: actions/cache@v4
+        id: root-cache
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
+
       - name: Install root dependencies and CLI dependencies
+        if: steps.check_commits.outputs.skip != 'true'
         run: npm ci --include=optional # this will also install cli deps because "cli" in included in root package.json workspaces field
 
       - name: Generate Protos
@@ -73,18 +81,13 @@ jobs:
           cat dist-standalone/package.json | grep version
 
       - name: Publish to NPM with latest tag
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_RELEASE_TOKEN }}
         run: |
           echo "Publishing version ${{ steps.version.outputs.version }} to NPM with tag 'latest'..."
           cd dist-standalone
           npm publish --tag latest --access public
 
-      - name: Tag release
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git tag "v${{ steps.version.outputs.version }}-cli"
-          git push origin "v${{ steps.version.outputs.version }}-cli"
-
       - name: Summary
         run: |
           echo "✅ Successfully published cline@${{ steps.version.outputs.version }} to NPM with tag 'latest'"

.github/workflows/npm-nightly.yaml

@@ -1,17 +1,12 @@
 name: Publish NPM Nightly
 
 on:
-  workflow_call:
-    inputs:
-      force_publish:
-        description: "Force publish even if there are no commits in the last 24 hours"
-        required: false
-        type: boolean
-        default: false
+  schedule:
+    - cron: "0 12 * * *" # 4 AM PST (UTC-8) = 12 UTC
+  workflow_dispatch:
 
 permissions:
   contents: read
-  id-token: write # Required for npm trusted publishing (OIDC)
   checks: write # Required by test workflow
   pull-requests: write # Required by test workflow
 
@@ -32,12 +27,6 @@ jobs:
       - name: Check for recent commits
         id: check_commits
         run: |
-          if [ "${{ inputs.force_publish }}" = "true" ]; then
-            echo "force_publish enabled, proceeding with publish"
-            echo "skip=false" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
           if [ $(git rev-list --count HEAD --since="24 hours ago") -eq 0 ]; then
             echo "No commits in last 24 hours, skipping publish"
             echo "skip=true" >> $GITHUB_OUTPUT
@@ -50,9 +39,18 @@ jobs:
         if: steps.check_commits.outputs.skip != 'true'
         uses: actions/setup-node@v4
         with:
-          node-version: "24.x"
+          node-version: "20.x"
           registry-url: "https://registry.npmjs.org"
 
+      # Cache root dependencies - only reuse if package-lock.json exactly matches
+      - name: Cache root dependencies
+        if: steps.check_commits.outputs.skip != 'true'
+        uses: actions/cache@v4
+        id: root-cache
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-npm-${{ hashFiles('package-lock.json') }}
+
       - name: Install root dependencies and CLI dependencies
         if: steps.check_commits.outputs.skip != 'true'
         run: npm ci --include=optional # this will also install cli deps because "cli" in included in root package.json workspaces field
@@ -120,6 +118,8 @@ jobs:
 
       - name: Publish to NPM with nightly tag
         if: steps.check_commits.outputs.skip != 'true'
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_RELEASE_TOKEN }}
         run: |
           echo "Publishing version ${{ steps.version.outputs.version }} to NPM with tag 'nightly'..."
           cd dist-standalone

.github/workflows/pack-cli.yml

@@ -1,215 +0,0 @@
-# Build and Pack CLI
-#
-# Builds a CLI tarball from any branch/commit and publishes it as a GitHub Release.
-# Requires write access to the repository (maintainers/collaborators only).
-#
-# Security: Split into two jobs to isolate untrusted build code from write tokens.
-# The build job runs arbitrary ref code with zero permissions. The release job
-# only runs trusted GitHub Actions with write scope.
-#
-# Usage (helper script, auto-detects current branch):
-#   ./scripts/build-cli-artifact.sh
-#   ./scripts/build-cli-artifact.sh feature/my-changes
-#   ./scripts/build-cli-artifact.sh feature/my-changes 1234  # comments on PR
-#
-# Usage (gh CLI directly):
-#   gh workflow run pack-cli.yml -f ref=main
-#   gh workflow run pack-cli.yml -f ref=abc123 -f pr_number=1234
-#
-# Install the built CLI (no auth required):
-#   npm install -g https://github.com/cline/cline/releases/download/cli-build-<sha>/cline-<ver>.tgz
-#
-# Find releases:
-#   gh release list --limit 10
-
-name: Build and Pack CLI
-
-permissions:
-  contents: read
-
-on:
-  workflow_dispatch:
-    inputs:
-      ref:
-        description: 'Branch, tag, or commit SHA to build (leave empty for default branch)'
-        required: false
-        type: string
-      pr_number:
-        description: 'PR number to comment on with install instructions (optional)'
-        required: false
-        type: number
-
-jobs:
-  # ── Build job: runs untrusted ref code with ZERO permissions ──
-  build:
-    name: Build CLI
-    runs-on: ubuntu-latest
-    permissions: {}
-    outputs:
-      commit_sha: ${{ steps.commit.outputs.sha }}
-      tarball: ${{ steps.pack.outputs.tarball }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref || github.ref }}
-          persist-credentials: false
-
-      - name: Get commit SHA
-        id: commit
-        run: |
-          COMMIT_SHA=$(git rev-parse --short HEAD)
-          echo "sha=$COMMIT_SHA" >> $GITHUB_OUTPUT
-          echo "Building from commit: $COMMIT_SHA"
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20.x"
-
-      - name: Install dependencies
-        run: npm ci --include=optional
-
-      - name: Generate Protos
-        run: npm run protos
-
-      - name: Build standalone package
-        run: node scripts/package-npm.mjs
-
-      - name: Create Tarball
-        id: pack
-        run: |
-          cd dist-standalone
-          TARBALL=$(npm pack)
-          echo "tarball=$TARBALL" >> $GITHUB_OUTPUT
-          echo "Created tarball: $TARBALL"
-
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: cli-tarball
-          path: dist-standalone/*.tgz
-
-  # ── Release job: only trusted Actions code, with write permissions ──
-  release:
-    name: Release CLI
-    needs: build
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-      issues: write
-    steps:
-      - name: Download artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: cli-tarball
-          path: dist-standalone
-
-      - name: Create GitHub Release
-        id: create_release
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const fs = require('fs');
-            const path = require('path');
-            const commit = '${{ needs.build.outputs.commit_sha }}';
-            const tarball = '${{ needs.build.outputs.tarball }}';
-
-            // Delete existing release/tag if re-running for the same commit
-            const tagName = `cli-build-${commit}`;
-            try {
-              const existing = await github.rest.repos.getReleaseByTag({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                tag: tagName
-              });
-              await github.rest.repos.deleteRelease({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                release_id: existing.data.id
-              });
-              await github.rest.git.deleteRef({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                ref: `tags/${tagName}`
-              });
-              core.info(`Deleted existing release for ${tagName}`);
-            } catch (e) {
-              // Release doesn't exist yet, that's fine
-            }
-
-            // Create a release
-            const release = await github.rest.repos.createRelease({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              tag_name: tagName,
-              name: `CLI Build (${commit})`,
-              body: `Automated CLI build from commit ${commit}\n\nInstall with:\n\`\`\`bash\nnpm install -g https://github.com/${context.repo.owner}/${context.repo.repo}/releases/download/${tagName}/${tarball}\n\`\`\``,
-              draft: false,
-              prerelease: true
-            });
-
-            // Upload the tarball as a release asset
-            const tarballPath = path.join('dist-standalone', tarball);
-            const tarballData = fs.readFileSync(tarballPath);
-
-            await github.rest.repos.uploadReleaseAsset({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              release_id: release.data.id,
-              name: tarball,
-              data: tarballData
-            });
-
-            const downloadUrl = `https://github.com/${context.repo.owner}/${context.repo.repo}/releases/download/${tagName}/${tarball}`;
-            core.setOutput('release_url', release.data.html_url);
-            core.setOutput('download_url', downloadUrl);
-
-      - name: Comment on PR with download instructions
-        if: inputs.pr_number != ''
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const commit = '${{ needs.build.outputs.commit_sha }}';
-            const releaseUrl = '${{ steps.create_release.outputs.release_url }}';
-            const downloadUrl = '${{ steps.create_release.outputs.download_url }}';
-            const prNumber = ${{ inputs.pr_number || 0 }};
-            if (!prNumber) return;
-
-            const comment = `## 📦 CLI Build Ready
-
-            A CLI build has been created for commit \`${commit}\`.
-
-            ### Install Directly from URL (No Authentication Required!)
-
-            \`\`\`bash
-            npm install -g ${downloadUrl}
-            \`\`\`
-
-            ### Alternative: Download and Install
-
-            \`\`\`bash
-            curl -L ${downloadUrl} -o cline.tgz
-            npm install -g ./cline.tgz
-            \`\`\`
-
-            📦 [View Release](${releaseUrl})
-            `;
-
-            await github.rest.issues.createComment({
-              issue_number: prNumber,
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              body: comment
-            });
-
-      - name: Summary
-        run: |
-          echo "✅ CLI build complete!"
-          echo ""
-          echo "📦 Release: ${{ steps.create_release.outputs.release_url }}"
-          echo "🔗 Download URL: ${{ steps.create_release.outputs.download_url }}"
-          echo ""
-          echo "Install from anywhere (no authentication required):"
-          echo "  npm install -g ${{ steps.create_release.outputs.download_url }}"

.github/workflows/publish-cli-trusted.yaml

@@ -1,53 +0,0 @@
-name: Publish CLI (Trusted)
-
-on:
-  schedule:
-    - cron: "0 12 * * *" # 4 AM PST (UTC-8) = 12 UTC
-  workflow_dispatch:
-    inputs:
-      publish_target:
-        description: "Which publish flow to run"
-        required: true
-        default: "main"
-        type: choice
-        options:
-          - main
-          - nightly
-      confirm_publish:
-        description: 'Required when publish_target=main. Type "publish" to confirm release publish.'
-        required: false
-        type: string
-      force_nightly_publish:
-        description: "Force nightly publish even with no commits in last 24h"
-        required: false
-        type: boolean
-        default: false
-
-permissions:
-  id-token: write # Required for npm trusted publishing (OIDC)
-  contents: write # Required because npm-main creates/pushes git tags
-  checks: write # Required by nested reusable test workflow
-  pull-requests: write # Required by nested reusable test workflow
-
-jobs:
-  publish-main:
-    if: |
-      github.repository == 'cline/cline' && (
-        github.event_name == 'workflow_dispatch' &&
-        github.event.inputs.publish_target == 'main' &&
-        github.event.inputs.confirm_publish == 'publish' &&
-        !endsWith(github.actor, '[bot]')
-      )
-    uses: ./.github/workflows/npm-main.yaml
-    with:
-      confirm_publish: ${{ github.event.inputs.confirm_publish }}
-
-  publish-nightly:
-    if: |
-      github.repository == 'cline/cline' && (
-        github.event_name == 'schedule' ||
-        (github.event_name == 'workflow_dispatch' && github.event.inputs.publish_target == 'nightly')
-      )
-    uses: ./.github/workflows/npm-nightly.yaml
-    with:
-      force_publish: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.force_nightly_publish == 'true' }}

.github/workflows/publish-nightly.yml

@@ -33,19 +33,16 @@ jobs:
                 fi
                 echo "Found recent commits, proceeding with build"
                 
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
               with:
-                  node-version: "lts/*"
+                  bun-version: latest
 
-            - name: Install root dependencies
-              run: npm ci --include=optional
-
-            - name: Install webview-ui dependencies
-              run: cd webview-ui && npm ci --include=optional
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
 
             - name: Install Publishing Tools
-              run: npm install -g @vscode/vsce ovsx
+              run: bun add -g @vscode/vsce ovsx
 
             - name: Publish Extension as Pre-release
               env:
@@ -61,4 +58,4 @@ jobs:
                   OTEL_EXPORTER_OTLP_PROTOCOL: ${{ secrets.OTEL_EXPORTER_OTLP_PROTOCOL }}
                   OTEL_EXPORTER_OTLP_ENDPOINT: ${{ secrets.OTEL_EXPORTER_OTLP_ENDPOINT }}
                   OTEL_EXPORTER_OTLP_HEADERS: ${{ secrets.OTEL_EXPORTER_OTLP_HEADERS }}
-              run: npm run publish:marketplace:nightly
+              run: bun run publish:marketplace:nightly

.github/workflows/publish.yml

@@ -39,19 +39,16 @@ jobs:
                   fetch-depth: 0
                   fetch-tags: true
 
-            - name: Setup Node.js
-              uses: actions/setup-node@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
               with:
-                  node-version: "lts/*"
+                  bun-version: latest
 
-            - name: Install root dependencies
-              run: npm install --include=optional
-
-            - name: Install webview-ui dependencies
-              run: cd webview-ui && npm install --include=optional
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
 
             - name: Install Publishing Tools
-              run: npm install -g @vscode/vsce ovsx
+              run: bun add -g @vscode/vsce ovsx
 
             - name: Get Version
               id: get_version
@@ -93,10 +90,10 @@ jobs:
                   vsce package  --allow-package-secrets sendgrid --out "cline-${{ steps.get_version.outputs.version }}.vsix"
 
                   if [ "${{ github.event.inputs.release-type }}" = "pre-release" ]; then
-                    npm run publish:marketplace:prerelease
+                    bun run publish:marketplace:prerelease
                     echo "Successfully published pre-release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   else
-                    npm run publish:marketplace
+                    bun run publish:marketplace
                     echo "Successfully published release version ${{ steps.get_version.outputs.version }} to VS Code Marketplace and Open VSX Registry"
                   fi
 

.github/workflows/test.yml

@@ -24,25 +24,18 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Node.js environment
-              uses: actions/setup-node@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
               with:
-                  node-version: 22
-                  cache: 'npm'
-                  cache-dependency-path: |
-                      package-lock.json
-                      webview-ui/package-lock.json
+                  bun-version: latest
 
-            - name: Install root dependencies
-              run: npm ci
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            - name: Install webview-ui dependencies
-              run: cd webview-ui && npm ci
-
             - name: Run Quality Checks (Parallel)
-              run: npm run ci:check-all
+              run: bun run ci:check-all
 
     test:
         needs: quality-checks
@@ -59,66 +52,54 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Node.js environment
-              uses: actions/setup-node@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
               with:
-                  node-version: 22
-                  cache: 'npm'
-                  cache-dependency-path: |
-                      package-lock.json
-                      webview-ui/package-lock.json
+                  bun-version: latest
 
-            - name: Install root dependencies
-              run: npm ci
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            - name: Install webview-ui dependencies
-              run: cd webview-ui && npm ci
-
-            - name: Set up NPM on Windows
-              if: runner.os == 'Windows'
-              run: |
-                  npm config set script-shell "C:\\Program Files\\Git\\bin\\bash.exe"
-
             # Build the extension and tests (without redundant checks)
             - name: Build Tests and Extension
               id: build_step
-              run: npm run ci:build
+              run: bun run ci:build
 
             - name: Unit Tests with coverage - Linux
               id: unit_tests_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
               run: |
-                  npx nyc --nycrc-path .nycrc.unit.json --reporter=lcov npm run test:unit
+                  bunx nyc --nycrc-path .nycrc.unit.json --reporter=lcov bun run test:unit
 
             - name: Unit Tests - Non-Linux
               id: unit_tests_non_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
               run: |
-                  npm run test:unit
+                  bun run test:unit
 
             - name: Extension Integration Tests - Linux
               id: integration_tests_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os == 'Linux' }}
-              run: xvfb-run -a npm run test:coverage
+              run: xvfb-run -a bun run test:coverage
 
             - name: Extension Integration Tests - Non-Linux
               id: integration_tests_non_linux
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' && runner.os != 'Linux' }}
-              run: npm run test:integration
+              run: bun run test:integration
 
             - name: Webview Tests with Coverage
               id: webview_tests
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
               run: |
                   cd webview-ui
-                  npm run test:coverage
+                  bun run test:coverage
 
             - name: CLI Tests
               id: cli_tests
               if: ${{ !cancelled() && steps.build_step.outcome == 'success' }}
-              run: cd cli && npm run test:run
+              run: cd cli && bun run test:run
 
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4
@@ -137,36 +118,28 @@ jobs:
             - name: Checkout code
               uses: actions/checkout@v4
 
-            - name: Setup Node.js environment
-              uses: actions/setup-node@v4
+            - name: Setup Bun
+              uses: oven-sh/setup-bun@v2
               with:
-                  node-version: 22
-                  cache: 'npm'
-                  cache-dependency-path: |
-                      package-lock.json
-                      webview-ui/package-lock.json
-                      testing-platform/package-lock.json
+                  bun-version: latest
 
-            - name: Install root dependencies
-              run: npm ci
+            - name: Install dependencies
+              run: bun install --frozen-lockfile
               env:
                   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-            - name: Install webview-ui dependencies
-              run: cd webview-ui && npm ci
-
             - name: Download ripgrep binaries
-              run: npm run download-ripgrep
+              run: bun run download-ripgrep
 
             - name: Compile Standalone
-              run: npm run compile-standalone
+              run: bun run compile-standalone
 
             - name: Install testing platform dependencies
-              run: cd testing-platform && npm ci
+              run: cd testing-platform && bun install
 
             - name: Running testing platform integration spec tests
               timeout-minutes: 7
-              run: npm run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
+              run: bun run test:tp-orchestrator -- tests/specs/ --count=1 --coverage
 
             - name: Save Coverage Reports
               uses: actions/upload-artifact@v4

.gitignore

@@ -10,7 +10,10 @@ tmp
 .idea
 .husky/_/
 
+# Package manager lock files (we use Bun, so bun.lockb is NOT ignored)
 pnpm-lock.yaml
+package-lock.json
+yarn.lock
 
 .clineignore
 .venv
@@ -48,6 +51,3 @@ test-results
 .secrets
 
 *.tsbuildinfo
-
-# Smoke test results (generated)
-evals/smoke-tests/results/

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "evals/cline-bench"]
-	path = evals/cline-bench
-	url = https://github.com/cline/cline-bench.git

.vscode/tasks.json

@@ -5,8 +5,12 @@
 	"tasks": [
 		{
 			"label": "compile-standalone",
-			"type": "npm",
-			"script": "compile-standalone",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"compile-standalone"
+			],
 			"group": "build",
 			"problemMatcher": [],
 			"presentation": {
@@ -14,9 +18,13 @@
 			}
 		},
 		{
-			"label": "npm: protos",
-			"type": "npm",
-			"script": "protos",
+			"label": "bun:protos",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"protos"
+			],
 			"problemMatcher": [],
 			"isBackground": false,
 			"presentation": {
@@ -31,11 +39,11 @@
 		{
 			"label": "watch",
 			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview",
-				"npm: dev:webview",
-				"npm: watch:tsc",
-				"npm: watch:esbuild"
+				"bun:protos",
+				"bun:build:webview",
+				"bun:dev:webview",
+				"bun:watch:tsc",
+				"bun:watch:esbuild"
 			],
 			"presentation": {
 				"reveal": "always"
@@ -48,11 +56,11 @@
 		{
 			"label": "watch:test",
 			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview:test",
-				"npm: dev:webview",
-				"npm: watch:tsc",
-				"npm: watch:esbuild:test"
+				"bun:protos",
+				"bun:build:webview:test",
+				"bun:dev:webview",
+				"bun:watch:tsc",
+				"bun:watch:esbuild:test"
 			],
 			"presentation": {
 				"reveal": "always"
@@ -60,14 +68,18 @@
 			"group": "build"
 		},
 		{
-			"type": "npm",
-			"script": "build:webview",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"build:webview"
+			],
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": true,
-			"label": "npm: build:webview",
+			"label": "bun:build:webview",
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -80,14 +92,18 @@
 			}
 		},
 		{
-			"type": "npm",
-			"script": "build:webview:test",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"build:webview:test"
+			],
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": true,
-			"label": "npm: build:webview:test",
+			"label": "bun:build:webview:test",
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -101,8 +117,12 @@
 			}
 		},
 		{
-			"type": "npm",
-			"script": "dev:webview",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"dev:webview"
+			],
 			"group": "build",
 			"problemMatcher": [
 				{
@@ -122,9 +142,9 @@
 				}
 			],
 			"isBackground": true,
-			"label": "npm: dev:webview",
+			"label": "bun:dev:webview",
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -137,8 +157,12 @@
 			}
 		},
 		{
-			"type": "npm",
-			"script": "watch:esbuild",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"watch:esbuild"
+			],
 			"group": "build",
 			"problemMatcher": {
 				"pattern": [
@@ -160,9 +184,9 @@
 				}
 			},
 			"isBackground": true,
-			"label": "npm: watch:esbuild",
+			"label": "bun:watch:esbuild",
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -175,8 +199,12 @@
 			}
 		},
 		{
-			"type": "npm",
-			"script": "watch:esbuild:test",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"watch:esbuild:test"
+			],
 			"group": "build",
 			"problemMatcher": {
 				"pattern": [
@@ -198,9 +226,9 @@
 				}
 			},
 			"isBackground": true,
-			"label": "npm: watch:esbuild:test",
+			"label": "bun:watch:esbuild:test",
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -214,14 +242,18 @@
 			}
 		},
 		{
-			"type": "npm",
-			"script": "watch:tsc",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"watch:tsc"
+			],
 			"group": "build",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
-			"label": "npm: watch:tsc",
+			"label": "bun:watch:tsc",
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"group": "watch",
@@ -229,12 +261,17 @@
 			}
 		},
 		{
-			"type": "npm",
-			"script": "watch-tests",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"watch-tests"
+			],
+			"label": "bun:watch-tests",
 			"problemMatcher": "$tsc-watch",
 			"isBackground": true,
 			"dependsOn": [
-				"npm: protos"
+				"bun:protos"
 			],
 			"presentation": {
 				"reveal": "always",
@@ -245,9 +282,9 @@
 		{
 			"label": "tasks: watch-tests",
 			"dependsOn": [
-				"npm: protos",
-				"npm: watch",
-				"npm: watch-tests"
+				"bun:protos",
+				"bun:watch",
+				"bun:watch-tests"
 			],
 			"problemMatcher": []
 		},
@@ -265,15 +302,19 @@
 			"command": "rm -rf ${workspaceFolder}/dist/tmp/user && mkdir -p ${workspaceFolder}/dist/tmp/user"
 		},
 		{
-			"type": "npm",
-			"script": "storybook",
+			"type": "shell",
+			"command": "bun",
+			"args": [
+				"run",
+				"storybook"
+			],
 			"group": "build",
 			"problemMatcher": [],
 			"isBackground": false,
-			"label": "npm: storybook",
+			"label": "bun:storybook",
 			"dependsOn": [
-				"npm: protos",
-				"npm: build:webview"
+				"bun:protos",
+				"bun:build:webview"
 			],
 			"presentation": {
 				"reveal": "always"

CHANGELOG.md

@@ -1,82 +1,5 @@
 # Changelog
 
-## [3.62.0]
-
-### Fixed
-- Banners now display immediately when opening the extension instead of requiring user interaction first
-- Resolved 17 security vulnerabilities including high-severity DoS issues in dependencies (body-parser, axios, qs, tar, and others)
-
-
-## [3.61.0]
-
-- UI/UX fixes with minimax model family
-
-## [3.60.0]
-
-- Fixes for Minimax model family
-
-## [3.59.0]
-
-- Added Minimax 2.5 Free Promo
-- Fixed Response chaining for OpenAI's Responses API 
-
-## [3.58.0]
-
-### Added
-- Subagent: replace legacy subagents with the native `use_subagents` tool
-- Bundle `endpoints.json` support so packaged distributions can ship required endpoints out-of-the-box
-- Amazon Bedrock: support parallel tool calling
-- New "double-check completion" experimental feature to verify work before marking tasks complete
-- CLI: new task controls/flags including custom `--thinking` token budget and `--max-consecutive-mistakes` for yolo runs
-- Remote config: new UI/options (including connection/test buttons) and support for syncing deletion of remotely configured MCP servers
-- Vertex / Claude Code: add 1M context model options for Claude Opus 4.6
-- ZAI/GLM: add GLM-5
-
-### Fixed
-- CLI: handle stdin redirection correctly in CI/headless environments
-- CLI: preserve OAuth callback paths during auth redirects
-- VS Code Web: generate auth callback URLs via `vscode.env.asExternalUri` (OAuth callback reliability)
-- Terminal: surface command exit codes in results and improve long-running `execute_command` timeout behavior
-- UI: add loading indicator and fix `api_req_started` rendering
-- Task streaming: prevent duplicate streamed text rows after completion
-- API: preserve selected Vercel model when model metadata is missing
-- Telemetry: route PostHog networking through proxy-aware shared fetch and ensure telemetry flushes on shutdown
-- CI: increase Windows E2E test timeout to reduce flakiness
-
-### Changed
-- Settings/model UX: move "reasoning effort" into model configuration and expose it in settings
-- CLI provider selection: limit provider list to those remotely configured
-- UI: consolidate ViewHeader component/styling across views
-- Tools: add auto-approval support for `attempt_completion` commands
-- Remotely configured MCP server schema now supports custom headers
-
-## [3.57.1]
-
-### Fixed
-
-- Fixed Opus 4.6 for bedrock provider
-
-## [3.57.0]
-
-### Added
-
-- Cline CLI 2.0 now available. Install with `npm install -g cline`
-- Anthopic Opus 4.6 
-- Minimax-2.1 and Kimi-k2.5 now available for free for a limited time promo
-- Codex-5.3 through ChatGPT subscription
-
-### Fixed
-
-- Fix read file tool to support reading large files
-- Fix decimal input crash in OpenAI Compatible price fields (#8129)
-- Fix build complete handlers when updating the api config
-- Fixed missing provider from list
-- Fixed Favorite Icon / Star from getting clipped in the task history view
-
-### Changed
-
-- Make skills always enabled and remove feature toggle setting
-
 ## [3.56.0]
 
 ### Added

CONTRIBUTING.md

@@ -34,23 +34,38 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 ### Local Development Instructions
 
-1. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
+> **Note**: This project uses [Bun](https://bun.sh) as the package manager.
+
+1. Install Bun (if you haven't already):
+    ```bash
+    # macOS/Linux
+    curl -fsSL https://bun.sh/install | bash
+
+    # Windows
+    powershell -c "irm bun.sh/install.ps1 | iex"
+    ```
+
+2. Clone the repository _(Requires [git-lfs](https://git-lfs.com/))_:
     ```bash
     git clone https://github.com/cline/cline.git
     ```
-2. Open the project in VSCode:
+
+3. Open the project in VSCode:
     ```bash
     code cline
     ```
-3. Install the necessary dependencies for the extension and webview-gui:
+
+4. Install dependencies (installs for all workspaces):
     ```bash
-    npm run install:all
+    bun install
     ```
-4. Generate Protocol Buffer files (required before first build):
+
+5. Generate Protocol Buffer files (required before first build):
     ```bash
-    npm run protos
+    bun run protos
     ```
-5. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
+
+6. Launch by pressing `F5` (or `Run`->`Start Debugging`) to open a new VSCode window with the extension loaded. (You may need to install the [esbuild problem matchers extension](https://marketplace.visualstudio.com/items?itemName=connor4312.esbuild-problem-matchers) if you run into issues building the project.)
 
 
 
@@ -59,7 +74,7 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
 
 1. Before creating a PR, generate a changeset entry:
     ```bash
-    npm run changeset
+    bun run changeset
     ```
    This will prompt you for:
    - Type of change (major, minor, patch)
@@ -75,9 +90,10 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
    - Changesetbot will create a comment showing the version impact
    - When merged to main, changesetbot will create a Version Packages PR
    - When the Version Packages PR is merged, a new release will be published
+
 4. Testing
-    - Run `npm run test` to run tests locally. 
-    - Before submitting PR, run `npm run format:fix` to format your code
+    - Run `bun run test` to run tests locally
+    - Before submitting PR, run `bun run format:fix` to format your code
 
 ### Extension
 
@@ -88,12 +104,12 @@ We also welcome contributions to our [documentation](https://github.com/cline/cl
     - If you dismissed the prompts, you can install them manually from the Extensions panel
 
 2. **Local Development**
-    - Run `npm run install:all` to install dependencies
-    - Run `npm run protos` to generate Protocol Buffer files (required before first build)
-    - Run `npm run test` to run tests locally
+    - Run `bun run install:all` to install dependencies
+    - Run `bun run protos` to generate Protocol Buffer files (required before first build)
+    - Run `bun run test` to run tests locally
     - Run → Start Debugging or `>Debug: Select and Start Debugging` and wait for a new VS Code instance to open
-    - **Terminal Workflow**: Use `npm run dev` (generates protos + runs watch mode) or `npm run watch` (if protos already generated)
-    - Before submitting PR, run `npm run format:fix` to format your code
+    - **Terminal Workflow**: Use `bun run dev` (generates protos + runs watch mode) or `bun run watch` (if protos already generated)
+    - Before submitting PR, run `bun run format:fix` to format your code
 
 3. **Linux-specific Setup**
     VS Code extension tests on Linux require the following system libraries:
@@ -149,8 +165,8 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 
 2. **Code Quality**
 
-    - Run `npm run lint` to check code style
-    - Run `npm run format` to automatically format code
+    - Run `bun run lint` to check code style
+    - Run `bun run format` to automatically format code
     - All PRs must pass CI checks which include both linting and formatting
     - Address any warnings or errors from linter before submitting
     - Follow TypeScript best practices and maintain type safety
@@ -158,7 +174,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 3. **Testing**
 
     - Add tests for new features
-    - Run `npm test` to ensure all tests pass
+    - Run `bun test` to ensure all tests pass
     - Update existing tests if your changes affect them
     - Include both unit tests and integration tests where appropriate
 
@@ -168,9 +184,9 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
     
     - **Running E2E tests:**
       ```bash
-      npm run test:e2e        # Build and run all E2E tests
-      npm run e2e             # Run tests without rebuilding
-      npm run test:e2e -- --debug  # Run with interactive debugger
+      bun run test:e2e        # Build and run all E2E tests
+      bun run e2e             # Run tests without rebuilding
+      bun run test:e2e -- --debug  # Run with interactive debugger
       ```
     
     - **Writing E2E tests:**
@@ -194,7 +210,7 @@ Anyone can contribute code to Cline, but we ask that you follow these guidelines
 
 4. **Version Management with Changesets**
 
-    - Create a changeset for any user-facing changes using `npm run changeset`
+    - Create a changeset for any user-facing changes using `bun run changeset`
     - Choose the appropriate version bump:
         - `major` for breaking changes (1.0.0 → 2.0.0)
         - `minor` for new features (1.0.0 → 1.1.0)

biome.jsonc

@@ -1,5 +1,5 @@
 {
-	"$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
+	"$schema": "https://biomejs.dev/schemas/2.1.4/schema.json",
 	"vcs": {
 		"enabled": true,
 		"clientKind": "git",
@@ -28,19 +28,19 @@
 		"rules": {
 			"recommended": true,
 			"correctness": {
-				"useExhaustiveDependencies": "info",
+				"useExhaustiveDependencies": "off",
 				"noUndeclaredVariables": "off",
-				"noEmptyPattern": "info",
+				"noEmptyPattern": "off",
 				"useJsxKeyInIterable": "off",
 				"noInnerDeclarations": "off",
-				"useHookAtTopLevel": "info",
-				"useYield": "info",
+				"useHookAtTopLevel": "off",
+				"useYield": "off",
 				"noConstructorReturn": "off",
 				"noInvalidPositionAtImportRule": "off",
 				"noSwitchDeclarations": "off",
 				"noUnusedImports": "error"
 			},
-			"a11y": "info",
+			"a11y": "off",
 			"style": {
 				"useNodejsImportProtocol": "off",
 				"useImportType": "off",
@@ -51,36 +51,35 @@
 				"noParameterAssign": "off",
 				"useAsConstAssertion": "off",
 				"useDefaultParameterLast": "off",
-				"noNonNullAssertion": "info",
+				"noNonNullAssertion": "off",
 				"useEnumInitializers": "off",
-				"useSelfClosingElements": "info",
+				"useSelfClosingElements": "off",
 				"useSingleVarDeclarator": "off",
-				"useNumberNamespace": "info",
-				"noInferrableTypes": "info",
-				"useTemplate": "info",
-				"noUselessElse": "info"
+				"useNumberNamespace": "off",
+				"noInferrableTypes": "off",
+				"useTemplate": "off",
+				"noUselessElse": "off"
 			},
 			"suspicious": {
 				"noDoubleEquals": "warn",
 				"noImplicitAnyLet": "info",
 				"noThenProperty": "off",
-				"noAsyncPromiseExecutor": "info",
+				"noAsyncPromiseExecutor": "off",
 				"noImportAssign": "off",
-				"noExplicitAny": "info",
-				"noControlCharactersInRegex": "warn",
+				"noExplicitAny": "off",
+				"noControlCharactersInRegex": "off",
 				"noShadowRestrictedNames": "off",
 				"noArrayIndexKey": "info",
-				"noAssignInExpressions": "info",
-				"useIterableCallbackReturn": "info"
+				"noAssignInExpressions": "info"
 			},
 			"complexity": {
-				"noUselessConstructor": "info",
-				"useOptionalChain": "info",
-				"noBannedTypes": "warn",
-				"useLiteralKeys": "info",
-				"noUselessCatch": "info",
-				"noUselessSwitchCase": "info",
-				"noStaticOnlyClass": "info"
+				"noUselessConstructor": "off",
+				"useOptionalChain": "off",
+				"noBannedTypes": "off",
+				"useLiteralKeys": "off",
+				"noUselessCatch": "off",
+				"noUselessSwitchCase": "off",
+				"noStaticOnlyClass": "off"
 			},
 			"security": {
 				"noDangerouslySetInnerHtml": "info"
@@ -95,11 +94,6 @@
 		"lineEnding": "lf",
 		"formatWithErrors": true
 	},
-	"css": {
-		"parser": {
-			"tailwindDirectives": true
-		}
-	},
 	"javascript": {
 		"formatter": {
 			"semicolons": "asNeeded",
@@ -118,21 +112,21 @@
 		}
 	},
 	"files": {
-		"ignoreUnknown": true,
 		"includes": [
 			"**",
-			// explicitly force files to be ignored by the scanner with !!
-			"!!**/dist",
-			"!!**/dist-*",
-			"!!**/out",
-			"!!**/evals",
-			"!!**/playwright",
-			"!!**/test-results",
-			"!!**/node_modules",
-			"!!**/webview-ui/build",
-			"!!**/generated",
-			"!!**/proto",
-			"!!**/tests/specs"
+			"!**/dist",
+			"!**/dist-*",
+			"!**/out",
+			"!**/evals",
+			"!**/playwright",
+			"!**/test-results",
+			"!**/node_modules",
+			"!**/webview-ui/build",
+			"!**/generated",
+			"!**/proto",
+			"!**/tests/specs",
+			"!**/*.lock*",
+			"!**/*-lock.json"
 		]
 	},
 	"plugins": [
@@ -142,15 +136,14 @@
 		{
 			"includes": [
 				"**",
-				"!!**/dist",
-				"!!**/hosts/vscode/**",
-				"!!**/test/**",
-				"!!**/*.test.ts",
-				"!!src/dev/**",
-				"!!src/extension.ts",
-				"!!src/integrations/git/commit-message-generator.ts",
-				"!!src/integrations/terminal/**",
-				"!!src/core/controller/ui/openWalkthrough.ts"
+				"!**/hosts/vscode/**",
+				"!**/test/**",
+				"!**/*.test.ts",
+				"!src/dev/**",
+				"!src/extension.ts",
+				"!src/integrations/git/commit-message-generator.ts",
+				"!src/integrations/terminal/**",
+				"!src/core/controller/ui/openWalkthrough.ts"
 			],
 			"plugins": [
 				"src/dev/grit/vscode-api.grit"
@@ -163,37 +156,37 @@
 			],
 			"includes": [
 				"**",
-				"!!**/esbuild.*",
-				"!!**/*.mts",
-				"!!**/webview-ui/**",
-				"!!**/evals/**",
-				"!!**/standalone/**",
-				"!!**/cli/**",
-				"!!**/e2e/**",
-				"!!**/test/**",
-				"!!**/__tests__/**",
-				"!!**/*.test.ts",
-				"!!**/*.stories.ts",
-				"!!src/dev/**",
-				"!!**/*.mjs",
-				"!!**/*.js",
-				"!!**/scripts/**",
-				"!!**/*.tsx",
-				"!!**/testing-platform/**",
+				"!**/esbuild.*",
+				"!**/*.mts",
+				"!**/webview-ui/**",
+				"!**/evals/**",
+				"!**/standalone/**",
+				"!**/cli/**",
+				"!**/e2e/**",
+				"!**/test/**",
+				"!**/__tests__/**",
+				"!**/*.test.ts",
+				"!**/*.stories.ts",
+				"!src/dev/**",
+				"!**/*.mjs",
+				"!**/*.js",
+				"!**/scripts/**",
+				"!**/*.tsx",
+				"!**/testing-platform/**",
 				// ACP mode must redirect console to stderr - this is intentional
-				"!!cli/src/acp/index.ts"
+				"!cli/src/acp/index.ts"
 			]
 		},
 		{
 			"includes": [
 				"**",
-				"!!src/core/storage/state-migrations.ts",
-				"!!src/core/storage/FileContextTracker.ts",
-				"!!src/core/context/context-tracking/FileContextTracker.ts",
-				"!!src/common.ts",
-				"!!src/services/logging/distinctId.ts",
-				"!!src/core/storage/utils/state-helpers.ts",
-				"!!src/extension.ts"
+				"!src/core/storage/state-migrations.ts",
+				"!src/core/storage/FileContextTracker.ts",
+				"!src/core/context/context-tracking/FileContextTracker.ts",
+				"!src/common.ts",
+				"!src/services/logging/distinctId.ts",
+				"!src/core/storage/utils/state-helpers.ts",
+				"!src/extension.ts"
 			],
 			"plugins": [
 				"src/dev/grit/use-cache-service.grit"

bunfig.toml

@@ -0,0 +1,18 @@
+# Bun configuration for Cline monorepo
+
+[install]
+# Use npm for package resolution compatibility
+registry = "https://registry.npmjs.org/"
+
+# Cache configuration
+[install.cache]
+# Enable caching for faster installs
+disable = false
+
+[install.scopes]
+# Configure scoped registries if needed
+# "@myorg" = "https://registry.example.com/"
+
+[test]
+# Test configuration
+preload = []

cli/CHANGELOG.md

@@ -1,80 +0,0 @@
-# cline
-
-
-### Fixed
-- Banners now display immediately when opening the extension instead of requiring user interaction first
-- Resolved 17 security vulnerabilities including high-severity DoS issues in dependencies (body-parser, axios, qs, tar, and others)
-
-## [2.2.2]
-
-- Allows users to enter custom aws region when selecting bedrock as a provider
-- Prevent Parent Container Scrolling In Dropdowns
-
-## [2.2.1]
-
-- Added Minimax 2.5 Free Promo
-- Fixed Response chaining for OpenAI's Responses API
-
-## [2.2.0]
-
-### Added
-
-- Subagent: replace legacy subagents with the native `use_subagents` tool
-- Bundle `endpoints.json` support so packaged distributions can ship required endpoints out-of-the-box
-- Amazon Bedrock: support parallel tool calling
-- New "double-check completion" experimental feature to verify work before marking tasks complete
-- CLI: new task controls/flags including custom `--thinking` token budget and `--max-consecutive-mistakes` for yolo runs
-- Remote config: new UI/options (including connection/test buttons) and support for syncing deletion of remotely configured MCP servers
-- Vertex / Claude Code: add 1M context model options for Claude Opus 4.6
-- ZAI/GLM: add GLM-5
-
-### Fixed
-
-- CLI: handle stdin redirection correctly in CI/headless environments
-- CLI: preserve OAuth callback paths during auth redirects
-- VS Code Web: generate auth callback URLs via `vscode.env.asExternalUri` (OAuth callback reliability)
-- Terminal: surface command exit codes in results and improve long-running `execute_command` timeout behavior
-- UI: add loading indicator and fix `api_req_started` rendering
-- Task streaming: prevent duplicate streamed text rows after completion
-- API: preserve selected Vercel model when model metadata is missing
-- Telemetry: route PostHog networking through proxy-aware shared fetch and ensure telemetry flushes on shutdown
-- CI: increase Windows E2E test timeout to reduce flakiness
-
-### Changed
-
-- Settings/model UX: move "reasoning effort" into model configuration and expose it in settings
-- CLI provider selection: limit provider list to those remotely configured
-- UI: consolidate ViewHeader component/styling across views
-- Tools: add auto-approval support for `attempt_completion` commands
-- Remotely configured MCP server schema now supports custom headers
-
-## [2.1.0]
-
-### Minor Changes
-
-- 42ce100: Add Generate API Key on Hicap Provider selection
-
-### Patch Changes
-
-- 195294f: Add support for bundled endpoints.json in enterprise distributions. Extensions can now include a pre-configured endpoints.json file that automatically switches Cline to self-hosted mode. Includes packaging scripts for VSIX, NPM, and JetBrains plugins.
-- a1f2601: Replace the LiteLLM model list with a selector
-- 739d75a: Add Claude Code provider support for Claude Opus 4.6 and Sonnet 4.5 1M variants via both full model names and aliases (`opus[1m]`, `sonnet[1m]`), and align the `opus` alias with Opus 4.6.
-- 8440380: Add GitHub Actions workflow to build CLI from any commit for testing
-- b1a8db2: fix(cli): prevent hang when spawned without TTY
-- 7c87017: Add Claude Opus 4.6 model support
-- d116ac5: Supports rendering markdown table in chat view.
-- 6d8fb85: Fix CLI crashing in CI environments and with stdin redirection (e.g., `cline "prompt" < /dev/null`). Now checks both stdin and stdout TTY status before using Ink, and only errors on empty stdin when no prompt is provided.
-- 70a9904: Fix JetBrains sign-in regression by adding fallback for openExternal RPC
-- f440f3a: fix: use vscode.env.openExternal for auth in remote environments
-
-  Fixes OAuth authentication in VS Code Server and remote environments by routing browser URL opening through VS Code's native openExternal API instead of the npm 'open' package.
-
-- 70a9904: fix: use vscode.env.asExternalUri for auth callback URLs only in VS Code Web
-
-  Fixes OAuth callback redirect in VS Code Web (`code serve-web`, Codespaces) by using `vscode.env.asExternalUri()` to resolve the callback URI. This is gated behind a `vscode.env.uiKind === UIKind.Web` check so regular desktop VS Code continues to use the `vscode://` URI directly. The `getCallbackUrl` API now accepts a `path` parameter so the full callback URI (including route) is resolved correctly, and callers pass their path directly instead of appending after.
-
-- 5308ded: Updating script documentation and removing unnecessary continue on error
-- b514f18: Prevent duplicate streamed text rows when a partial text update arrives after the same text was already finalized.
-- 26391c9: Fix Bedrock model id
-- d19a877: Unify ViewHeader Styles Across All Views
-- 5dcaa8c: Add Vertex Claude Opus 4.6 1M model option and global endpoint support, and pass the 1M beta header for Vertex Claude requests.

cli/DEVELOPMENT.md

@@ -13,7 +13,7 @@ The official CLI for Cline. Run Cline tasks directly from the terminal with the
 ## Prerequisites
 
 - Node.js 20.x or later
-- npm or yarn
+- bun or npm or yarn
 - The parent Cline project dependencies installed
 
 ## Installation
@@ -22,13 +22,13 @@ From the repository root:
 
 ```bash
 # Install all dependencies first
-npm run install:all
+bun install
 
 # Ensure protos are generated
-npm run protos
+bun run protos
 
 # Build and link the CLI globally
-npm run cli:link
+bun run cli:link
 ```
 
 ## Usage
@@ -192,10 +192,10 @@ These options are available for the default command (running a task directly):
 
 ```bash
 # 1. Install all dependencies (root, webview-ui, cli)
-npm run install:all
+bun install
 
 # 2. Build and link globally so you can run `cline` from anywhere
-npm run cli:link
+bun run cli:link
 
 # 3. Test it
 cline --help
@@ -207,29 +207,29 @@ Run these from the repository root:
 
 | Script | Description |
 |--------|-------------|
-| `npm run install:all` | Install deps for root, webview-ui, and cli |
-| `npm run cli:build` | Generate protos and build CLI |
-| `npm run cli:build:production` | Production build (minified) |
-| `npm run cli:link` | Build and `npm link` so you can run `cline` from anywhere |
-| `npm run cli:unlink` | Remove the global `cline` symlink |
-| `npm run cli:dev` | Link + watch mode for development |
-| `npm run cli:watch` | Watch mode only (no initial build) |
-| `npm run cli:test` | Run CLI tests |
+| `bun install` | Install deps for root, webview-ui, and cli |
+| `bun run cli:build` | Generate protos and build CLI |
+| `bun run cli:build:production` | Production build (minified) |
+| `bun run cli:link` | Build and `bun link` so you can run `cline` from anywhere |
+| `bun run cli:unlink` | Remove the global `cline` symlink |
+| `bun run cli:dev` | Link + watch mode for development |
+| `bun run cli:watch` | Watch mode only (no initial build) |
+| `bun run cli:test` | Run CLI tests |
 
 ### Development Workflow
 
-1. Run `npm run cli:dev` - this links the CLI globally and starts watch mode
+1. Run `bun run cli:dev` - this links the CLI globally and starts watch mode
 2. Make changes to files in `cli/src/`
 3. The build automatically rebuilds on save
 4. Test your changes by running `cline` in another terminal
-5. When done, run `npm run cli:unlink` to clean up
+5. When done, run `bun run cli:unlink` to clean up
 
 ### Proto Generation
 
 The CLI uses proto-generated types for message passing (same as the VS Code extension). If you modify any `.proto` files, run:
 
 ```bash
-npm run protos
+bun run protos
 ```
 
 This generates TypeScript types in `src/generated/` that both the CLI and extension use.
@@ -238,12 +238,12 @@ This generates TypeScript types in `src/generated/` that both the CLI and extens
 
 #### 1. Publish to npm
 ```bash
-npm publish
+bun publish
 ```
 
 #### 2. Update the Homebrew formula
 ```bash
-npm run update-brew-formula
+bun run update-brew-formula
 ```
 
 #### 3. Test the formula locally
@@ -335,13 +335,13 @@ If you encounter build errors:
 
 ```bash
 # Make sure all deps are installed
-npm run install:all
+bun install
 
 # Regenerate proto types
-npm run protos
+bun run protos
 
 # Then rebuild
-npm run cli:build
+bun run cli:build
 ```
 
 ### "command not found: cline"
@@ -349,16 +349,16 @@ npm run cli:build
 The CLI isn't linked globally. Run:
 
 ```bash
-npm run cli:link
+bun run cli:link
 ```
 
 ### Changes Not Reflected
 
 If your code changes aren't showing up:
 
-1. Make sure watch mode is running (`npm run cli:dev`)
+1. Make sure watch mode is running (`bun run cli:dev`)
 2. Check for TypeScript errors in the watch output
-3. Try unlinking and relinking: `npm run cli:unlink && npm run cli:link`
+3. Try unlinking and relinking: `bun run cli:unlink && bun run cli:link`
 
 ### Import Errors from Core
 

cli/man/cline.1

@@ -88,10 +88,6 @@ directory
 \f[B]\-\-thinking\f[R] : Enable extended thinking (1024 token budget)
 .PP
 \f[B]\-\-json\f[R] : Output messages as JSON instead of styled text
-.PP
-\f[B]\-T\f[R], \f[B]\-\-taskId\f[R] \f[I]id\f[R] : Resume an existing
-task by ID.
-The prompt argument becomes an optional follow\-up message.
 .SS history (alias: h)
 List task history with pagination.
 .PP
@@ -183,10 +179,6 @@ the task
 .PP
 \f[B]\-\-json\f[R] : Output messages as JSON instead of styled text.
 Forces plain text mode.
-.PP
-\f[B]\-T\f[R], \f[B]\-\-taskId\f[R] \f[I]id\f[R] : Resume an existing
-task by ID instead of starting a new one.
-The prompt becomes an optional follow\-up message.
 .SH JSON OUTPUT FORMAT
 When using \f[B]\-\-json\f[R], each message is output as a JSON object
 with these fields:
@@ -282,21 +274,6 @@ cline history
 \f[I]# Show more tasks with pagination\f[R]
 cline history \-n 20 \-p 2
 .EE
-.SS Resuming Tasks
-.IP
-.EX
-\f[I]# Resume a task by ID (get IDs from cline history)\f[R]
-cline \-T abc123def
-
-\f[I]# Resume a task with a follow\-up message\f[R]
-cline \-T abc123def \(dqNow add unit tests for the changes\(dq
-
-\f[I]# Resume in plan mode to review before continuing\f[R]
-cline \-T abc123def \-p \(dqWhat\(aqs left to do?\(dq
-
-\f[I]# Resume with yolo mode for automated continuation\f[R]
-cline \-T abc123def \-y \(dqContinue with the implementation\(dq
-.EE
 .SS Authentication
 .IP
 .EX
@@ -371,19 +348,20 @@ export CLINE_COMMAND_PERMISSIONS=\(aq{\(dqallow\(dq: [\(dqnpm *\(dq, \(dqgit *\(
 \f[I]# Allow file operations with redirects\f[R]
 export CLINE_COMMAND_PERMISSIONS=\(aq{\(dqallow\(dq: [\(dqcat *\(dq, \(dqecho *\(dq], \(dqallowRedirects\(dq: true}\(aq
 .EE
-.SH CONFIGURATION FILES
-.IP
-.EX
-\(ti/.cline/
-├── data/                    # Default configuration directory
-│   ├── globalState.json     # Global settings and state
-│   ├── secrets.json         # API keys and secrets (stored securely)
-│   ├── workspace/           # Workspace\-specific state
-│   └── tasks/               # Task history and conversation data
-└── log/                     # Log files for debugging
-.EE
+.SH FILES
+\f[B]\(ti/.cline/data/\f[R] : Default configuration directory
+containing:
 .PP
-View logs with \f[CR]cline dev log\f[R].
+\f[B]globalState.json\f[R] : Global settings and state
+.PP
+\f[B]secrets.json\f[R] : API keys and secrets (stored securely)
+.PP
+\f[B]workspace/\f[R] : Workspace\-specific state
+.PP
+\f[B]tasks/\f[R] : Task history and conversation data
+.PP
+\f[B]\(ti/.cline/log/\f[R] : Log files for debugging.
+View with \f[CR]cline dev log\f[R].
 .SH BUGS
 Report bugs at: \c
 .UR https://github.com/cline/cline/issues

cli/man/cline.1.md

@@ -70,8 +70,6 @@ Run a new task with a prompt.
 
 **\--json** :   Output messages as JSON instead of styled text
 
-**-T**, **\--taskId** *id* :   Resume an existing task by ID. The prompt argument becomes an optional follow-up message.
-
 ## history (alias: h)
 
 List task history with pagination.
@@ -118,7 +116,7 @@ Authenticate a provider and configure the model.
 
 Check for updates and install if available.
 
-**cline update** [*options*] :   Check npm for newer versions. Options:
+**cline update** [*options*] :   Check bun for newer versions. Options:
 
 **-v**, **\--verbose** :   Show verbose output
 
@@ -156,8 +154,6 @@ When running **cline** with just a prompt (no subcommand), these options are ava
 
 **\--json** :   Output messages as JSON instead of styled text. Forces plain text mode.
 
-**-T**, **\--taskId** *id* :   Resume an existing task by ID instead of starting a new one. The prompt becomes an optional follow-up message.
-
 # JSON OUTPUT FORMAT
 
 When using **\--json**, each message is output as a JSON object with these fields:
@@ -255,22 +251,6 @@ cline history
 cline history -n 20 -p 2
 ```
 
-## Resuming Tasks
-
-```bash
-# Resume a task by ID (get IDs from cline history)
-cline -T abc123def
-
-# Resume a task with a follow-up message
-cline -T abc123def "Now add unit tests for the changes"
-
-# Resume in plan mode to review before continuing
-cline -T abc123def -p "What's left to do?"
-
-# Resume with yolo mode for automated continuation
-cline -T abc123def -y "Continue with the implementation"
-```
-
 ## Authentication
 
 ```bash
@@ -313,11 +293,11 @@ Format: `{"allow": ["pattern1", "pattern2"], "deny": ["pattern3"], "allowRedirec
 **Examples:**
 
 ```bash
-# Allow only npm and git commands.
-export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *"]}'
+# Allow only bun and git commands.
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["bun *", "git *"]}'
 
 # Allow development commands but deny dangerous ones. Deny not strictly required here since allow is set.
-export CLINE_COMMAND_PERMISSIONS='{"allow": ["npm *", "git *", "node *"], "deny": ["rm -rf *", "sudo *"]}'
+export CLINE_COMMAND_PERMISSIONS='{"allow": ["bun *", "git *", "node *"], "deny": ["rm -rf *", "sudo *"]}'
 
 # Allow file operations with redirects
 export CLINE_COMMAND_PERMISSIONS='{"allow": ["cat *", "echo *"], "allowRedirects": true}'

cli/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cline",
-	"version": "2.2.3",
+	"version": "2.0.3",
 	"description": "Autonomous coding agent CLI - capable of creating/editing files, running commands, using the browser, and more",
 	"main": "dist/cli.mjs",
 	"bin": {
@@ -21,16 +21,16 @@
 		"node": ">=20.0.0"
 	},
 	"scripts": {
-		"package:brew": "npx tsx ./scripts/update-brew-formula.mts",
-		"package": "npm pack --pack-destination ./dist",
-		"build": "npm run typecheck && npx tsx esbuild.mts",
-		"build:production": "npm run typecheck && npx tsx esbuild.mts --production",
-		"watch": "npx tsx esbuild.mts --watch",
-		"dev": "IS_DEV=true && npm run link && npm run watch ; npm run unlink",
+		"package:brew": "bunx tsx ./scripts/update-brew-formula.mts",
+		"package": "bun pm pack --pack-destination ./dist",
+		"build": "bun run typecheck && bunx tsx esbuild.mts",
+		"build:production": "bun run typecheck && bunx tsx esbuild.mts --production",
+		"watch": "bunx tsx esbuild.mts --watch",
+		"dev": "IS_DEV=true && bun run link && bun run watch ; bun run unlink",
 		"clean": "rimraf dist",
-		"typecheck": "npx tsc --noEmit",
-		"link": "npm run build && npm link",
-		"unlink": "npm unlink -g cline",
+		"typecheck": "bunx tsc --noEmit",
+		"link": "bun run build && bun link",
+		"unlink": "bun unlink",
 		"test": "vitest",
 		"test:run": "vitest run"
 	},

cli/src/acp/ACPHostBridgeClientProvider.ts

@@ -172,16 +172,6 @@ class ACPEnvServiceClient implements EnvServiceClientInterface {
 		Logger.debug("[ACPEnvServiceClient] shutdown called (stub)")
 		return proto.cline.Empty.create()
 	}
-
-	async openExternal(request: proto.cline.StringRequest): Promise<proto.cline.Empty> {
-		const url = request.value || ""
-		if (url) {
-			Logger.debug(`[ACPEnvServiceClient] openExternal: ${url}`)
-			const { openUrlInBrowser } = await import("../utils/browser")
-			await openUrlInBrowser(url)
-		}
-		return proto.cline.Empty.create()
-	}
 }
 
 /**

cli/src/acp/AcpTerminalManager.ts

@@ -12,7 +12,11 @@
 
 import type * as acp from "@agentclientprotocol/sdk"
 import type { TerminalHandle } from "@agentclientprotocol/sdk"
-import { DEFAULT_TERMINAL_OUTPUT_LINE_LIMIT, PROCESS_HOT_TIMEOUT_NORMAL } from "@integrations/terminal/constants"
+import {
+	DEFAULT_SUBAGENT_TERMINAL_OUTPUT_LINE_LIMIT,
+	DEFAULT_TERMINAL_OUTPUT_LINE_LIMIT,
+	PROCESS_HOT_TIMEOUT_NORMAL,
+} from "@integrations/terminal/constants"
 import type {
 	ITerminal,
 	ITerminalManager,
@@ -138,12 +142,12 @@ export interface ManagedTerminal {
  * Wraps ACP terminal operations and emits events compatible with ITerminalProcess.
  */
 class AcpTerminalProcess extends EventEmitter<TerminalProcessEvents> implements ITerminalProcess {
-	isHot = false
-	waitForShellIntegration = false
+	isHot: boolean = false
+	waitForShellIntegration: boolean = false
 
-	private _unretrievedOutput = ""
-	private _continued = false
-	private _completed = false
+	private _unretrievedOutput: string = ""
+	private _continued: boolean = false
+	private _completed: boolean = false
 	private _hotTimeout: NodeJS.Timeout | null = null
 	private _exitWaitTimeout: NodeJS.Timeout | null = null
 	private readonly manager: AcpTerminalManager
@@ -393,7 +397,7 @@ export class AcpTerminalManager implements ITerminalManager {
 	private readonly numericIdToStringId: Map<number, string> = new Map()
 
 	/** Next numeric ID to assign */
-	private nextNumericId = 1
+	private nextNumericId: number = 1
 
 	/** Active processes indexed by numeric terminal ID */
 	private readonly processes: Map<number, AcpTerminalProcess> = new Map()
@@ -402,8 +406,9 @@ export class AcpTerminalManager implements ITerminalManager {
 	private readonly terminalInfos: Map<number, TerminalInfo> = new Map()
 
 	// Configuration options for ITerminalManager
-	private terminalReuseEnabled = true
+	private terminalReuseEnabled: boolean = true
 	private terminalOutputLineLimit: number = DEFAULT_TERMINAL_OUTPUT_LINE_LIMIT
+	private subagentTerminalOutputLineLimit: number = DEFAULT_SUBAGENT_TERMINAL_OUTPUT_LINE_LIMIT
 
 	/**
 	 * Creates a new AcpTerminalManager.
@@ -662,6 +667,14 @@ export class AcpTerminalManager implements ITerminalManager {
 		this.terminalOutputLineLimit = limit
 	}
 
+	/**
+	 * Set the maximum number of output lines for subagent commands.
+	 * @param limit Maximum number of lines
+	 */
+	setSubagentTerminalOutputLineLimit(limit: number): void {
+		this.subagentTerminalOutputLineLimit = limit
+	}
+
 	/**
 	 * Set the default terminal profile.
 	 * @param profile The profile identifier
@@ -674,10 +687,15 @@ export class AcpTerminalManager implements ITerminalManager {
 	 * Process output lines, potentially truncating if over limit.
 	 * @param outputLines Array of output lines
 	 * @param overrideLimit Optional limit override
+	 * @param isSubagentCommand Whether this is a subagent command
 	 * @returns Processed output string
 	 */
-	processOutput(outputLines: string[], overrideLimit?: number): string {
-		const limit = overrideLimit !== undefined ? overrideLimit : this.terminalOutputLineLimit
+	processOutput(outputLines: string[], overrideLimit?: number, isSubagentCommand?: boolean): string {
+		const limit = isSubagentCommand
+			? overrideLimit !== undefined
+				? overrideLimit
+				: this.subagentTerminalOutputLineLimit
+			: this.terminalOutputLineLimit
 
 		if (outputLines.length > limit) {
 			const halfLimit = Math.floor(limit / 2)

cli/src/agent/ClineAgent.ts

@@ -173,7 +173,7 @@ export class ClineAgent implements acp.Agent {
 	async initialize(params: acp.InitializeRequest, connection?: acp.AgentSideConnection): Promise<acp.InitializeResponse> {
 		this.clientCapabilities = params.clientCapabilities
 		this.initializeHostProvider(this.clientCapabilities, connection)
-		await ClineEndpoint.initialize(this.ctx.EXTENSION_DIR)
+		await ClineEndpoint.initialize()
 		await StateManager.initialize(this.ctx.extensionContext)
 
 		return {
@@ -246,8 +246,8 @@ export class ClineAgent implements acp.Agent {
 			},
 			hostBridgeClientProvider,
 			(message: string) => Logger.info(message),
-			async (path: string) => {
-				return AuthHandler.getInstance().getCallbackUrl(path)
+			async () => {
+				return AuthHandler.getInstance().getCallbackUrl()
 			},
 			async () => "", // get binary location not needed in ACP mode
 			this.ctx.EXTENSION_DIR,
@@ -973,7 +973,7 @@ export class ClineAgent implements acp.Agent {
 		// Get the callback URL first to ensure the server is ready
 		let callbackUrl: string
 		try {
-			callbackUrl = await authHandler.getCallbackUrl("/auth")
+			callbackUrl = await authHandler.getCallbackUrl()
 			Logger.debug("[ClineAgent] Callback URL ready:", callbackUrl)
 		} catch (error) {
 			Logger.error("[ClineAgent] Failed to get callback URL:", error)

cli/src/agent/messageTranslator.ts

@@ -312,10 +312,6 @@ function translateSayMessage(
 			// API request finished - no specific update needed
 			break
 
-		case "subagent_usage":
-			// Hidden aggregate metrics event used for task-level accounting.
-			break
-
 		case "task":
 			// Task started - don't echo the user's prompt back to them
 			// The ACP client already knows what they typed

cli/src/components/AsciiMotionCli.tsx

@@ -34,7 +34,7 @@ type AsciiMotionCliProps = {
   autoPlay?: boolean;
   loop?: boolean;
   onReady?: (api: PlaybackAPI) => void;
-  onInteraction?: () => void; // Called when user scrolls, clicks, or drags
+  onScroll?: () => void; // Called when user scrolls (scroll wheel)
 };
 
 const FRAMES: FrameData[] = [
@@ -333364,7 +333364,7 @@ const FRAME_BOTTOM_RIGHT = 128;
 
 export const AsciiMotionCli: React.FC<AsciiMotionCliProps> = ({
   hasDarkBackground = true,
-  onInteraction,
+  onScroll,
 }) => {
   const [frameIndex, setFrameIndex] = useState(0);
   const [targetFrame, setTargetFrame] = useState(0);
@@ -333390,13 +333390,13 @@ export const AsciiMotionCli: React.FC<AsciiMotionCliProps> = ({
   // Stop animation on terminal resize to prevent visual glitches
   useEffect(() => {
     const handleResize = () => {
-      onInteraction?.();
+      onScroll?.();
     };
     process.stdout.on("resize", handleResize);
     return () => {
       process.stdout.off("resize", handleResize);
     };
-  }, [onInteraction]);
+  }, [onScroll]);
 
   // Mouse tracking - gracefully handle environments without tty support
   useEffect(() => {
@@ -333417,19 +333417,13 @@ export const AsciiMotionCli: React.FC<AsciiMotionCliProps> = ({
     const handleData = (data: Buffer) => {
       const str = data.toString();
 
-      // Parse mouse events: \x1b[<button;x;yM (M=press, m=release)
+      // Parse mouse events: \x1b[<button;x;yM
       const mouseMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
       if (mouseMatch) {
         const button = parseInt(mouseMatch[1], 10);
-        const isPress = mouseMatch[4] === "M";
-        // Button 64/65 = scroll up/down
-        // Button 0-2 = left/middle/right click (on press)
-        // Button 32-34 = drag with left/middle/right button held
-        const isScroll = button === 64 || button === 65;
-        const isClick = isPress && button >= 0 && button <= 2;
-        const isDrag = button >= 32 && button <= 34;
-        if (isScroll || isClick || isDrag) {
-          onInteraction?.();
+        // Button 64 = scroll up, 65 = scroll down
+        if (button === 64 || button === 65) {
+          onScroll?.();
         }
         // Throttle cursor updates to ~20fps to reduce re-renders
         const now = Date.now();

cli/src/components/AuthView.tsx

@@ -6,21 +6,19 @@
 import { Box, Text, useApp, useInput } from "ink"
 import Spinner from "ink-spinner"
 import React, { useCallback, useEffect, useMemo, useState } from "react"
-import { refreshOcaModels } from "@/core/controller/models/refreshOcaModels"
 import { StateManager } from "@/core/storage/StateManager"
 import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
 import { AuthService } from "@/services/auth/AuthService"
-import { openAiCodexDefaultModelId, openRouterDefaultModelId } from "@/shared/api"
-import { StringRequest } from "@/shared/proto/cline/common"
+import { liteLlmDefaultModelId, openAiCodexDefaultModelId, openRouterDefaultModelId } from "@/shared/api"
 import { openExternal } from "@/utils/env"
 import { COLORS } from "../constants/colors"
+import { getAllFeaturedModels } from "../constants/featured-models"
 import { useStdinContext } from "../context/StdinContext"
 import { useOcaAuth } from "../hooks/useOcaAuth"
 import { useScrollableList } from "../hooks/useScrollableList"
 import { type DetectedSources, detectImportSources, type ImportSource } from "../utils/import-configs"
 import { isMouseEscapeSequence } from "../utils/input"
 import { applyBedrockConfig, applyProviderConfig } from "../utils/provider-config"
-import { useValidProviders } from "../utils/providers"
 import { ApiKeyInput } from "./ApiKeyInput"
 import { StaticRobotFrame } from "./AsciiMotionCli"
 import { type BedrockConfig, BedrockSetup } from "./BedrockSetup"
@@ -32,8 +30,7 @@ import {
 } from "./FeaturedModelPicker"
 import { ImportView } from "./ImportView"
 import { getDefaultModelId, hasModelPicker, ModelPicker } from "./ModelPicker"
-import { OcaEmployeeCheck } from "./OcaEmployeeCheck"
-import { getProviderLabel } from "./ProviderPicker"
+import { CLI_EXCLUDED_PROVIDERS, getProviderLabel, getProviderOrder } from "./ProviderPicker"
 
 type AuthStep =
 	| "menu"
@@ -45,13 +42,15 @@ type AuthStep =
 	| "success"
 	| "error"
 	| "cline_auth"
-	| "oca_employee_check"
 	| "oca_auth"
 	| "cline_model"
 	| "openai_codex_auth"
 	| "bedrock"
 	| "import"
 
+// Featured models loaded from shared constants
+const featuredModels = getAllFeaturedModels()
+
 interface AuthViewProps {
 	controller: any
 	onComplete?: () => void
@@ -150,9 +149,6 @@ const TextInput: React.FC<{
 
 export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onError, onNavigateToWelcome }) => {
 	const { exit } = useApp()
-
-	const providers = useValidProviders()
-
 	const [step, setStep] = useState<AuthStep>("menu")
 	const [selectedProvider, setSelectedProvider] = useState<string>(
 		StateManager.get().getApiConfiguration().actModeApiProvider ||
@@ -163,6 +159,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	const [modelId, setModelId] = useState("")
 	const [baseUrl, setBaseUrl] = useState("")
 	const [errorMessage, setErrorMessage] = useState("")
+	const [authStatus, setAuthStatus] = useState<string>("")
 	const [providerSearch, setProviderSearch] = useState("")
 	const [providerIndex, setProviderIndex] = useState(0)
 	const [clineModelIndex, setClineModelIndex] = useState(0)
@@ -173,14 +170,11 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	// OCA auth hook - enabled when step is oca_auth
 	const handleOcaAuthSuccess = useCallback(async () => {
 		await applyProviderConfig({ providerId: "oca", controller })
-		// Fetch OCA models from the API - this sets actModeOcaModelId/planModeOcaModelId in state
-		await refreshOcaModels(controller, StringRequest.create({ value: "" }))
 		const stateManager = StateManager.get()
 		stateManager.setGlobalState("welcomeViewCompleted", true)
 		await stateManager.flushPendingState()
 		setSelectedProvider("oca")
-		const actModelId = stateManager.getGlobalSettingsKey("actModeOcaModelId") || ""
-		setModelId(actModelId)
+		setModelId(liteLlmDefaultModelId)
 		setStep("success")
 	}, [controller])
 
@@ -196,6 +190,11 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 		onError: handleOcaAuthError,
 	})
 
+	// Use providers.json order, filtered to exclude CLI-incompatible providers
+	const sortedProviders = useMemo(() => {
+		return getProviderOrder().filter((p) => !CLI_EXCLUDED_PROVIDERS.has(p))
+	}, [])
+
 	// Main menu items - conditionally include import options
 	const mainMenuItems: SelectItem[] = useMemo(() => {
 		const items: SelectItem[] = [{ label: "Sign in with Cline", value: "cline_auth" }]
@@ -221,13 +220,15 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	const providerItems: SelectItem[] = useMemo(() => {
 		const search = providerSearch.toLowerCase()
 		const filtered = providerSearch
-			? providers.filter((p) => p.toLowerCase().includes(search) || getProviderLabel(p).toLowerCase().includes(search))
-			: providers
+			? sortedProviders.filter(
+					(p) => p.toLowerCase().includes(search) || getProviderLabel(p).toLowerCase().includes(search),
+				)
+			: sortedProviders
 		return filtered.map((p: string) => ({
 			label: getProviderLabel(p),
 			value: p,
 		}))
-	}, [providers, providerSearch])
+	}, [sortedProviders, providerSearch])
 
 	// Use shared scrollable list hook for provider windowing
 	const TOTAL_PROVIDER_ROWS = 8
@@ -322,6 +323,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	const startClineAuth = useCallback(async () => {
 		try {
 			setStep("cline_auth")
+			setAuthStatus("Starting authentication...")
 			await AuthService.getInstance(controller).createAuthRequest()
 		} catch (error) {
 			setErrorMessage(error instanceof Error ? error.message : String(error))
@@ -331,6 +333,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 
 	const startOcaAuth = useCallback(() => {
 		setStep("oca_auth")
+		setAuthStatus("Starting authentication...")
 		initiateOcaAuth()
 	}, [initiateOcaAuth])
 
@@ -361,8 +364,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 		(value: string) => {
 			setSelectedProvider(value)
 			if (value === "oca") {
-				// Show employee check screen before starting auth
-				setStep("oca_employee_check")
+				startOcaAuth()
 			} else if (value === "openai-codex") {
 				setStep("openai_codex_auth")
 				startOpenAiCodexAuth()
@@ -538,11 +540,8 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 				setBaseUrl("")
 				setStep("modelid")
 				break
-			case "oca_employee_check":
-				setStep("provider")
-				break
 			case "oca_auth":
-				setStep("oca_employee_check")
+				setStep("provider")
 				break
 			case "cline_auth":
 				setStep("menu")
@@ -682,9 +681,6 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 					</Box>
 				)
 
-			case "oca_employee_check":
-				return <OcaEmployeeCheck isActive={step === "oca_employee_check"} onCancel={goBack} onSignIn={startOcaAuth} />
-
 			case "oca_auth":
 			case "cline_auth":
 				return (
@@ -770,7 +766,6 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 	const [menuIndex, setMenuIndex] = useState(0)
 
 	// Steps that allow going back with escape (apikey handled by ApiKeyInput component)
-	// OcaEmployeeCheck handles its own escape key, so oca_employee_check is not in this list
 	const canGoBack = [
 		"provider",
 		"modelid",
@@ -869,7 +864,7 @@ export const AuthView: React.FC<AuthViewProps> = ({ controller, onComplete, onEr
 										{index === menuIndex ? "❯ " : "  "}
 										{item.label}
 									</Text>
-									{item.value === "cline_auth" && <Text color="yellow"> (try Opus 4.6!)</Text>}
+									{item.value === "cline_auth" && <Text color="yellow"> (try Kimi K2.5 free!)</Text>}
 								</Text>
 							</Box>
 						))}

cli/src/components/ChatMessage.test.tsx

@@ -1,106 +0,0 @@
-import type { ClineMessage } from "@shared/ExtensionMessage"
-import { render } from "ink-testing-library"
-import React from "react"
-import { describe, expect, it, vi } from "vitest"
-import { ChatMessage } from "./ChatMessage"
-
-vi.mock("../hooks/useTerminalSize", () => ({
-	useTerminalSize: () => ({
-		columns: 120,
-		rows: 40,
-		resizeKey: 0,
-	}),
-}))
-
-describe("ChatMessage subagent rendering", () => {
-	it("renders subagent approval prompts as a tree", () => {
-		const message: ClineMessage = {
-			ts: Date.now(),
-			type: "ask",
-			ask: "use_subagents",
-			text: JSON.stringify({
-				prompts: [
-					"Find codebase stats and size",
-					"Find funny comments and easter eggs",
-					"Find unusual patterns and history",
-				],
-			}),
-		}
-
-		const { lastFrame } = render(React.createElement(ChatMessage, { message, mode: "act" }))
-		const frame = lastFrame() || ""
-
-		expect(frame).toContain("Cline wants to run subagents")
-		expect(frame).toContain("├─   Find codebase stats and size")
-		expect(frame).toContain("├─   Find funny comments and easter eggs")
-		expect(frame).toContain("└─   Find unusual patterns and history")
-	})
-
-	it("renders subagent progress rows with compact token stats and completion checks", () => {
-		const message: ClineMessage = {
-			ts: Date.now(),
-			type: "say",
-			say: "subagent",
-			text: JSON.stringify({
-				status: "running",
-				total: 3,
-				completed: 1,
-				successes: 1,
-				failures: 0,
-				toolCalls: 21,
-				inputTokens: 0,
-				outputTokens: 0,
-				contextWindow: 0,
-				maxContextTokens: 0,
-				maxContextUsagePercentage: 0,
-				items: [
-					{
-						index: 1,
-						prompt: "Find codebase stats and size",
-						status: "completed",
-						toolCalls: 5,
-						inputTokens: 0,
-						outputTokens: 0,
-						totalCost: 0.034,
-						contextTokens: 24400,
-						contextWindow: 200000,
-						contextUsagePercentage: 12.2,
-					},
-					{
-						index: 2,
-						prompt: "Find funny comments and easter eggs",
-						status: "running",
-						toolCalls: 11,
-						inputTokens: 0,
-						outputTokens: 0,
-						totalCost: 0.056,
-						contextTokens: 31600,
-						contextWindow: 200000,
-						contextUsagePercentage: 15.8,
-					},
-					{
-						index: 3,
-						prompt: "Find unusual patterns and history",
-						status: "pending",
-						toolCalls: 5,
-						inputTokens: 0,
-						outputTokens: 0,
-						totalCost: 0,
-						contextTokens: 28900,
-						contextWindow: 200000,
-						contextUsagePercentage: 14.4,
-					},
-				],
-			}),
-		}
-
-		const { lastFrame } = render(React.createElement(ChatMessage, { isStreaming: true, message, mode: "act" }))
-		const frame = lastFrame() || ""
-
-		expect(frame).toContain("Cline is running subagents")
-		expect(frame).toContain("✓ Find codebase stats and size")
-		expect(frame).toContain("5 tool uses · 24.4k tokens · $0.03")
-		expect(frame).toContain("11 tool uses · 31.6k tokens · $0.06")
-		expect(frame).toContain("5 tool uses · 28.9k tokens · $0.00")
-	})
-})

cli/src/components/ChatMessage.tsx

@@ -17,7 +17,6 @@ import { useTerminalSize } from "../hooks/useTerminalSize"
 import { jsonParseSafe } from "../utils/parser"
 import { getToolDescription, isFileEditTool, parseToolFromMessage } from "../utils/tools"
 import { DiffView } from "./DiffView"
-import { SubagentMessage } from "./SubagentMessage"
 
 /**
  * Add "(Tab)" hint after "Act mode" mentions.
@@ -25,7 +24,7 @@ import { SubagentMessage } from "./SubagentMessage"
  * Matches just "Act mode" without requiring "to " prefix because markdown
  * processing may split "toggle to **Act mode**" into separate text chunks.
  */
-function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
+function addActModeHint(text: string): React.ReactNode[] {
 	// Match "Act mode" in various capitalizations, but not if already followed by (Tab)
 	const actModeRegex = /\bact\s+mode\b(?!\s*\(tab\))/gi
 	const parts = text.split(actModeRegex)
@@ -42,7 +41,7 @@ function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
 		}
 		if (matches[i]) {
 			nodes.push(
-				<React.Fragment key={`${keyPrefix}-act-mode-${i}`}>
+				<React.Fragment key={`act-mode-${i}`}>
 					{matches[i]}
 					<Text color="gray"> (Tab)</Text>
 				</React.Fragment>,
@@ -60,8 +59,6 @@ function addActModeHint(text: string, keyPrefix: string): React.ReactNode[] {
  */
 function renderInlineMarkdown(text: string): React.ReactNode[] {
 	const nodes: React.ReactNode[] = []
-	let hintCallIndex = 0
-	const addHintedText = (value: string) => addActModeHint(value, `hint-${hintCallIndex++}`)
 	// Match **bold**, *italic*, or `code` - order matters (** before *)
 	const regex = /(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`)/g
 	let lastIndex = 0
@@ -71,7 +68,7 @@ function renderInlineMarkdown(text: string): React.ReactNode[] {
 		// Add text before match (with Act Mode hint processing)
 		if (match.index > lastIndex) {
 			const beforeText = text.slice(lastIndex, match.index)
-			nodes.push(...addHintedText(beforeText))
+			nodes.push(...addActModeHint(beforeText))
 		}
 
 		const fullMatch = match[0]
@@ -80,7 +77,7 @@ function renderInlineMarkdown(text: string): React.ReactNode[] {
 		if (fullMatch.startsWith("**") && fullMatch.endsWith("**")) {
 			// Bold - also process for Act Mode hints inside bold text
 			const boldContent = fullMatch.slice(2, -2)
-			const hintedContent = addHintedText(boldContent)
+			const hintedContent = addActModeHint(boldContent)
 			nodes.push(
 				<Text bold key={key}>
 					{hintedContent}
@@ -103,10 +100,10 @@ function renderInlineMarkdown(text: string): React.ReactNode[] {
 
 	// Add remaining text (with Act Mode hint processing)
 	if (lastIndex < text.length) {
-		nodes.push(...addHintedText(text.slice(lastIndex)))
+		nodes.push(...addActModeHint(text.slice(lastIndex)))
 	}
 
-	return nodes.length > 0 ? nodes : addHintedText(text)
+	return nodes.length > 0 ? nodes : addActModeHint(text)
 }
 
 /**
@@ -227,7 +224,7 @@ function truncate(text: string, maxLength: number): string {
 /**
  * Format tool result for display
  */
-function formatToolResult(result: string, maxLines = 5): string[] {
+function formatToolResult(result: string, maxLines: number = 5): string[] {
 	const lines = result.split("\n")
 	if (lines.length <= maxLines) {
 		return lines
@@ -449,10 +446,6 @@ export const ChatMessage: React.FC<ChatMessageProps> = ({ message, mode, isStrea
 		)
 	}
 
-	if ((type === "ask" && ask === "use_subagents") || say === "use_subagents" || say === "subagent") {
-		return <SubagentMessage isStreaming={isStreaming} message={message} mode={mode} />
-	}
-
 	// MCP response
 	if (say === "mcp_server_response" && text) {
 		const lines = formatToolResult(text, 8)
@@ -807,8 +800,6 @@ export const ChatMessageList: React.FC<ChatMessageListProps> = ({ messages, maxM
 	const displayMessages = messages.filter((m) => {
 		// Skip api_req_finished, they're just markers
 		if (m.say === "api_req_finished") return false
-		// Skip hidden aggregated usage messages
-		if (m.say === "subagent_usage") return false
 		// Skip empty text messages
 		if (m.say === "text" && !m.text?.trim()) return false
 		// Skip checkpoint messages

cli/src/components/ChatView.tsx

@@ -109,11 +109,10 @@ import { getApiMetrics, getLastApiReqTotalTokens } from "@shared/getApiMetrics"
 import { EmptyRequest, StringRequest } from "@shared/proto/cline/common"
 import type { SlashCommandInfo } from "@shared/proto/cline/slash"
 import { CLI_ONLY_COMMANDS } from "@shared/slashCommands"
-import { getProviderDefaultModelId, getProviderModelIdKey } from "@shared/storage"
+import { getProviderModelIdKey } from "@shared/storage"
 import type { Mode } from "@shared/storage/types"
 import { execSync } from "child_process"
 import { Box, Static, Text, useApp, useInput } from "ink"
-// biome-ignore lint/style/useImportType: JSX requires React as a value (jsx: "react" in tsconfig)
 import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import { getAvailableSlashCommands } from "@/core/controller/slash/getAvailableSlashCommands"
 import { showTaskWithId } from "@/core/controller/task/showTaskWithId"
@@ -138,7 +137,6 @@ import {
 import { isMouseEscapeSequence } from "../utils/input"
 import { jsonParseSafe, parseImagesFromInput } from "../utils/parser"
 import { extractSlashQuery, filterCommands, insertSlashCommand, sortCommandsWorkflowsFirst } from "../utils/slash-commands"
-import { waitFor } from "../utils/timeout"
 import { isFileEditTool, parseToolFromMessage } from "../utils/tools"
 import { shutdownEvent } from "../vscode-shim"
 import { ActionButtons, type ButtonActionType, getButtonConfig, getVisibleButtons } from "./ActionButtons"
@@ -153,24 +151,6 @@ import { SettingsPanelContent } from "./SettingsPanelContent"
 import { SlashCommandMenu } from "./SlashCommandMenu"
 import { ThinkingIndicator } from "./ThinkingIndicator"
 
-/**
- * Persistent input storage that survives React remounts (e.g., during terminal resize).
- * Keyed by a stable identifier so each task/session maintains its own input state.
- */
-interface PersistedInputState {
-	text: string
-	cursorPos: number
-	pastedTexts: Map<number, string>
-	pasteCounter: number
-}
-
-const inputStateStorage = new Map<string, PersistedInputState>()
-
-function getInputStorageKey(controller: any, taskId?: string): string {
-	// Use taskId if available, otherwise fall back to controller instance
-	return taskId || (controller?.task?.taskId ?? "default")
-}
-
 interface ChatViewProps {
 	controller?: any
 	onExit?: () => void
@@ -229,9 +209,9 @@ function getGitDiffStats(cwd?: string): GitDiffStats | null {
 		const delMatch = output.match(/(\d+) deletion/)
 
 		return {
-			files: filesMatch ? Number.parseInt(filesMatch[1], 10) : 0,
-			additions: addMatch ? Number.parseInt(addMatch[1], 10) : 0,
-			deletions: delMatch ? Number.parseInt(delMatch[1], 10) : 0,
+			files: filesMatch ? parseInt(filesMatch[1], 10) : 0,
+			additions: addMatch ? parseInt(addMatch[1], 10) : 0,
+			deletions: delMatch ? parseInt(delMatch[1], 10) : 0,
 		}
 	} catch {
 		return null
@@ -242,7 +222,7 @@ function getGitDiffStats(cwd?: string): GitDiffStats | null {
  * Create a progress bar for context window usage
  * Returns { filled, empty } strings to allow different coloring
  */
-function createContextBar(used: number, total: number, width = 8): { filled: string; empty: string } {
+function createContextBar(used: number, total: number, width: number = 8): { filled: string; empty: string } {
 	const ratio = Math.min(used / total, 1)
 	// Use ceil so any usage > 0 shows at least one bar
 	const filledCount = used > 0 ? Math.max(1, Math.ceil(ratio * width)) : 0
@@ -332,7 +312,7 @@ function parseAskOptions(text: string): string[] {
  */
 function expandPastedTexts(text: string, pastedTexts: Map<number, string>): string {
 	return text.replace(/\[Pasted text #(\d+) \+\d+ lines\]/g, (match, num) => {
-		const content = pastedTexts.get(Number.parseInt(num, 10))
+		const content = pastedTexts.get(parseInt(num, 10))
 		return content ?? match
 	})
 }
@@ -369,14 +349,9 @@ export const ChatView: React.FC<ChatViewProps> = ({
 		insertText: insertTextAtCursor,
 	} = useTextInput()
 
-	// Get storage key for persisting input across remounts
-	const storageKey = useMemo(() => getInputStorageKey(ctrl, taskId), [ctrl, taskId])
-
-	// Refs for text input and cursor position (used by useHomeEndKeys and to avoid stale closures in useInput)
+	// Ref for text input (used by useHomeEndKeys)
 	const textInputRef = useRef(textInput)
 	textInputRef.current = textInput
-	const cursorPosRef = useRef(cursorPos)
-	cursorPosRef.current = cursorPos
 
 	const [fileResults, setFileResults] = useState<FileSearchResult[]>([])
 	const [selectedIndex, setSelectedIndex] = useState(0) // For file menu
@@ -388,10 +363,8 @@ export const ChatView: React.FC<ChatViewProps> = ({
 	const [userScrolled, setUserScrolled] = useState(false)
 
 	// Pasted text storage - maps placeholder number to full pasted content
-	const [pastedTexts, setPastedTexts] = useState<Map<number, string>>(() => {
-		return inputStateStorage.get(storageKey)?.pastedTexts ?? new Map()
-	})
-	const pasteCounterRef = useRef<number>(inputStateStorage.get(storageKey)?.pasteCounter ?? 0)
+	const [pastedTexts, setPastedTexts] = useState<Map<number, string>>(new Map())
+	const pasteCounterRef = useRef(0)
 	// Track paste timing to combine chunks that arrive in rapid succession
 	const lastPasteTimeRef = useRef<number>(0)
 	const activePasteNumRef = useRef<number>(0)
@@ -425,29 +398,6 @@ export const ChatView: React.FC<ChatViewProps> = ({
 	// Track when we're exiting to hide UI elements before exit
 	const [isExiting, setIsExiting] = useState(false)
 
-	// Restore input state from storage on mount (after resize remount)
-	useEffect(() => {
-		const stored = inputStateStorage.get(storageKey)
-		if (stored) {
-			setTextInput(stored.text)
-			setCursorPos(stored.cursorPos)
-			setPastedTexts(stored.pastedTexts)
-			pasteCounterRef.current = stored.pasteCounter
-		}
-	}, [storageKey, setTextInput, setCursorPos])
-
-	// Persist input state to storage whenever it changes (survives remount)
-	useEffect(() => {
-		if (textInput || pastedTexts.size > 0) {
-			inputStateStorage.set(storageKey, {
-				text: textInput,
-				cursorPos,
-				pastedTexts: new Map(pastedTexts),
-				pasteCounter: pasteCounterRef.current,
-			})
-		}
-	}, [storageKey, textInput, cursorPos, pastedTexts])
-
 	// Task switch handling: when switching tasks via /history, we clear the terminal and
 	// increment a counter used as the root Box's key. This forces React to remount the tree,
 	// giving us a fresh Static instance. Mirrors how App.tsx handles resize with resizeKey.
@@ -502,12 +452,11 @@ export const ChatView: React.FC<ChatViewProps> = ({
 	// Get model ID based on current mode and provider
 	// Different providers use different state keys (e.g., cline uses actModeOpenRouterModelId)
 	// Re-read when activePanel changes (settings panel closes) to pick up changes
-	// Falls back to provider's default model if no model has been explicitly set
 	const modelId = useMemo(() => {
 		if (!provider) return ""
 		const stateManager = StateManager.get()
 		const modelKey = getProviderModelIdKey(provider as ApiProvider, mode)
-		return (stateManager.getGlobalSettingsKey(modelKey) as string) || getProviderDefaultModelId(provider as ApiProvider) || ""
+		return (stateManager.getGlobalSettingsKey(modelKey) as string) || ""
 	}, [mode, provider, activePanel])
 
 	const toggleMode = useCallback(async () => {
@@ -540,14 +489,12 @@ export const ChatView: React.FC<ChatViewProps> = ({
 		clearState() // Force clear React state (bypasses empty messages check)
 		setTextInput("")
 		setCursorPos(0)
-		// Clear persisted state
-		inputStateStorage.delete(storageKey)
 
 		// Post the now-empty state
 		if (ctrl) {
 			ctrl.postStateToWebview()
 		}
-	}, [ctrl, clearState, storageKey])
+	}, [ctrl, clearState])
 
 	const refs = useRef({
 		searchTimeout: null as NodeJS.Timeout | null,
@@ -808,8 +755,6 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			setCursorPos(0)
 			setPastedTexts(new Map()) // Clear stored pastes
 			pasteCounterRef.current = 0
-			// Clear persisted state
-			inputStateStorage.delete(storageKey)
 
 			try {
 				await ctrl.task.handleWebviewAskResponse(responseType, expandedText)
@@ -817,7 +762,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				// Controller may be disposed
 			}
 		},
-		[ctrl, pendingAsk, pastedTexts, storageKey],
+		[ctrl, pendingAsk, pastedTexts],
 	)
 
 	// Handle cancel/interrupt
@@ -908,8 +853,6 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			setCursorPos(0)
 			setPastedTexts(new Map()) // Clear stored pastes
 			pasteCounterRef.current = 0
-			// Clear persisted state
-			inputStateStorage.delete(storageKey)
 
 			try {
 				// Convert image paths to data URLs if needed
@@ -937,12 +880,10 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				onError?.()
 			}
 		},
-		[ctrl, onError, pastedTexts, storageKey],
+		[ctrl, onError, pastedTexts],
 	)
 
 	// Auto-submit initial prompt if provided
-	// When taskId is also provided, this sends the prompt to resume the existing task
-	// When no taskId, this creates a new task with the prompt
 	useEffect(() => {
 		const autoSubmit = async () => {
 			if (!initialPrompt && (!initialImages || initialImages.length === 0)) {
@@ -963,32 +904,8 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				if (initialPrompt) {
 					setTerminalTitle(initialPrompt)
 				}
-
-				if (taskId) {
-					// Resuming an existing task with a prompt - wait for task to load first
-					// The task loading happens in the other useEffect via showTaskWithId
-					// We need to wait for it to complete before sending the resume message
-					const task = await waitFor(() => ctrl.task, 5000)
-
-					if (task) {
-						// Send the prompt as a message to resume the task
-						await task.handleWebviewAskResponse("messageResponse", initialPrompt || "")
-					} else {
-						// Task failed to load, fall back to creating new task
-						Logger.error(`Failed to load task ${taskId} for resume, creating new task instead`)
-						await ctrl.initTask(
-							initialPrompt || "",
-							initialImages && initialImages.length > 0 ? initialImages : undefined,
-						)
-					}
-				} else {
-					// New task - use initTask
-					// initialImages are already data URLs from index.ts processing
-					await ctrl.initTask(
-						initialPrompt || "",
-						initialImages && initialImages.length > 0 ? initialImages : undefined,
-					)
-				}
+				// initialImages are already data URLs from index.ts processing
+				await ctrl.initTask(initialPrompt || "", initialImages && initialImages.length > 0 ? initialImages : undefined)
 			} catch (_error) {
 				onError?.()
 			}
@@ -1084,11 +1001,11 @@ export const ChatView: React.FC<ChatViewProps> = ({
 		// 3. Handle Option+arrow via key.meta (backup - Ink sometimes parses these instead of passing raw sequence)
 		if (key.meta) {
 			if (key.leftArrow) {
-				setCursorPos(findWordStart(textInputRef.current, cursorPosRef.current))
+				setCursorPos(findWordStart(textInput, cursorPos))
 				return
 			}
 			if (key.rightArrow) {
-				setCursorPos(findWordEnd(textInputRef.current, cursorPosRef.current))
+				setCursorPos(findWordEnd(textInput, cursorPos))
 				return
 			}
 		}
@@ -1274,8 +1191,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				if (hasPrimary && buttonConfig.primaryAction) {
 					handleButtonAction(buttonConfig.primaryAction, true)
 					return
-				}
-				if (hasSecondary && !hasPrimary && buttonConfig.secondaryAction) {
+				} else if (hasSecondary && !hasPrimary && buttonConfig.secondaryAction) {
 					handleButtonAction(buttonConfig.secondaryAction, false)
 					return
 				}
@@ -1296,7 +1212,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			}
 			// Number selection for options (only when no text typed yet)
 			if (askType === "options") {
-				const num = Number.parseInt(input, 10)
+				const num = parseInt(input, 10)
 				if (textInput === "" && !Number.isNaN(num) && num >= 1 && num <= askOptions.length) {
 					const selectedOption = askOptions[num - 1]
 					sendAskResponse("messageResponse", selectedOption)
@@ -1338,10 +1254,10 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				}
 				pasteUpdateTimeoutRef.current = setTimeout(() => {
 					const newPlaceholder = `[Pasted text #${pasteNum} +${activePasteLinesRef.current} lines]`
-					const pattern = new RegExp(`\\[Pasted text #${pasteNum} \\+\\d+ lines\\]`)
-					const newText = textInputRef.current.replace(pattern, newPlaceholder)
-					textInputRef.current = newText // Update ref immediately so setCursorPos bounds check works
-					setTextInput(newText)
+					setTextInput((prev) => {
+						const pattern = new RegExp(`\\[Pasted text #${pasteNum} \\+\\d+ lines\\]`)
+						return prev.replace(pattern, newPlaceholder)
+					})
 					// Update cursor to be right after the placeholder
 					setCursorPos(activePasteStartPosRef.current + newPlaceholder.length)
 					Logger.info(`Paste #${pasteNum} complete: ${activePasteLinesRef.current} lines`)
@@ -1354,8 +1270,7 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			pasteCounterRef.current += 1
 			const pasteNum = pasteCounterRef.current
 			activePasteNumRef.current = pasteNum
-			const currentCursorPos = cursorPosRef.current // Use ref to avoid stale closure
-			activePasteStartPosRef.current = currentCursorPos // Track where placeholder starts
+			activePasteStartPosRef.current = cursorPos // Track where placeholder starts
 			// Count line breaks in the pasted content (handle both \n and \r)
 			const extraLines = input.match(/[\r\n]/g)?.length || 0
 			activePasteLinesRef.current = extraLines // Track total lines
@@ -1367,11 +1282,8 @@ export const ChatView: React.FC<ChatViewProps> = ({
 				return next
 			})
 
-			const newText =
-				textInputRef.current.slice(0, currentCursorPos) + placeholder + textInputRef.current.slice(currentCursorPos)
-			textInputRef.current = newText // Update ref immediately so setCursorPos bounds check works
-			setTextInput(newText)
-			setCursorPos(currentCursorPos + placeholder.length)
+			setTextInput((prev) => prev.slice(0, cursorPos) + placeholder + prev.slice(cursorPos))
+			setCursorPos(cursorPos + placeholder.length)
 			return // Exit early - don't also add the raw input via normal handling below
 		}
 
@@ -1400,15 +1312,15 @@ export const ChatView: React.FC<ChatViewProps> = ({
 			return
 		}
 		if (key.rightArrow && !inSlashMenu && !inFileMenu) {
-			setCursorPos((pos) => Math.min(textInputRef.current.length, pos + 1))
+			setCursorPos((pos) => Math.min(textInput.length, pos + 1))
 			return
 		}
 		if (key.upArrow && !inSlashMenu && !inFileMenu) {
-			setCursorPos(moveCursorUp(textInputRef.current, cursorPosRef.current))
+			setCursorPos(moveCursorUp(textInput, cursorPos))
 			return
 		}
 		if (key.downArrow && !inSlashMenu && !inFileMenu) {
-			setCursorPos(moveCursorDown(textInputRef.current, cursorPosRef.current))
+			setCursorPos(moveCursorDown(textInput, cursorPos))
 			return
 		}
 		// Normal input (single char or short paste)
@@ -1474,10 +1386,10 @@ export const ChatView: React.FC<ChatViewProps> = ({
 
 			{/* Dynamic region - only current streaming message + input */}
 			<Box flexDirection="column" width="100%">
-				{/* Animated robot and welcome text - only shown before messages start and user hasn't interacted */}
+				{/* Animated robot and welcome text - only shown before messages start and user hasn't scrolled */}
 				{isWelcomeState && (
 					<Box flexDirection="column" marginBottom={1}>
-						<AsciiMotionCli onInteraction={() => setUserScrolled(true)} />
+						<AsciiMotionCli onScroll={() => setUserScrolled(true)} />
 						<Text> </Text>
 						<Text bold color="white">
 							{centerText("What can I do for you?")}

cli/src/components/ConfigView.tsx

@@ -13,7 +13,6 @@ import {
 import { Box, Text, useApp, useInput } from "ink"
 import React, { useMemo, useState } from "react"
 import { useStdinContext } from "../context/StdinContext"
-import { fuzzyFilter } from "../utils/fuzzy-search"
 import {
 	BooleanSelect,
 	buildConfigEntries,
@@ -22,8 +21,6 @@ import {
 	HookInfo,
 	HookRow,
 	MAX_VISIBLE,
-	ObjectEditorPanel,
-	ObjectEditorState,
 	parseValue,
 	SEPARATOR,
 	SectionHeader,
@@ -108,8 +105,6 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 	const [isEditing, setIsEditing] = useState(false)
 	const [selectedIndex, setSelectedIndex] = useState(0)
 	const [editValue, setEditValue] = useState("")
-	const [searchQuery, setSearchQuery] = useState("")
-	const [objectEditor, setObjectEditor] = useState<ObjectEditorState | null>(null)
 
 	// Build entries for settings tab
 	const configEntries = useMemo(
@@ -117,13 +112,6 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 		[globalState, workspaceState],
 	)
 
-	const filteredConfigEntries = useMemo(() => {
-		if (!searchQuery.trim()) {
-			return configEntries
-		}
-		return fuzzyFilter(configEntries, searchQuery, (entry) => `${entry.key} ${String(entry.value ?? "")}`)
-	}, [configEntries, searchQuery])
-
 	// Build entries for rules tab
 	const ruleEntries = useMemo(() => {
 		const entries: ToggleEntry[] = []
@@ -171,7 +159,7 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 	const currentListLength = useMemo(() => {
 		switch (currentTab) {
 			case "settings":
-				return filteredConfigEntries.length
+				return configEntries.length
 			case "rules":
 				return ruleEntries.length
 			case "workflows":
@@ -183,14 +171,7 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 			default:
 				return 0
 		}
-	}, [
-		currentTab,
-		filteredConfigEntries.length,
-		ruleEntries.length,
-		workflowEntries.length,
-		hookEntries.length,
-		skillEntries.length,
-	])
+	}, [currentTab, configEntries.length, ruleEntries.length, workflowEntries.length, hookEntries.length, skillEntries.length])
 
 	// Get available tabs
 	const availableTabs = useMemo(() => {
@@ -210,11 +191,10 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 		setCurrentTab(newTab)
 		setSelectedIndex(0)
 		setIsEditing(false)
-		setObjectEditor(null)
 	}
 
 	// Settings tab handlers
-	const selectedConfigEntry = filteredConfigEntries[selectedIndex]
+	const selectedConfigEntry = configEntries[selectedIndex]
 
 	const handleSettingsSave = (value: string | boolean) => {
 		if (!selectedConfigEntry) {
@@ -230,43 +210,6 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 		setIsEditing(false)
 	}
 
-	const getObjectAtPath = (root: Record<string, unknown>, path: string[]): Record<string, unknown> => {
-		let current: unknown = root
-		for (const segment of path) {
-			if (!current || typeof current !== "object") {
-				return {}
-			}
-			current = (current as Record<string, unknown>)[segment]
-		}
-		return current && typeof current === "object" ? (current as Record<string, unknown>) : {}
-	}
-
-	const setObjectValueAtPath = (
-		root: Record<string, unknown>,
-		path: string[],
-		key: string,
-		value: unknown,
-	): Record<string, unknown> => {
-		if (path.length === 0) {
-			return { ...root, [key]: value }
-		}
-		const [head, ...rest] = path
-		const child = root[head]
-		const childObj = child && typeof child === "object" ? (child as Record<string, unknown>) : {}
-		return {
-			...root,
-			[head]: setObjectValueAtPath(childObj, rest, key, value),
-		}
-	}
-
-	const persistObjectEditor = (nextObject: Record<string, unknown>, source: "global" | "workspace", key: string) => {
-		if (source === "global" && onUpdateGlobal) {
-			onUpdateGlobal(key as GlobalStateAndSettingsKey, nextObject as never)
-		} else if (source === "workspace" && onUpdateWorkspace) {
-			onUpdateWorkspace(key as LocalStateKey, nextObject as never)
-		}
-	}
-
 	const handleSettingsReset = () => {
 		if (!selectedConfigEntry?.isEditable || selectedConfigEntry.source !== "global") {
 			return
@@ -297,22 +240,15 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 	// Input handling
 	useInput(
 		(input, key) => {
-			if (objectEditor) {
-				return
-			}
-
-			if (key.escape) {
+			if (input.toLowerCase() === "q" || key.escape) {
 				exit()
 			}
 
-			if (key.leftArrow || key.rightArrow || (input >= "1" && input <= "5")) {
-				const currentTabIndex = availableTabs.findIndex((t) => t.key === currentTab)
-				const targetIdx =
-					input >= "1" && input <= "5"
-						? Number.parseInt(input) - 1
-						: key.leftArrow
-							? (currentTabIndex - 1 + availableTabs.length) % availableTabs.length
-							: (currentTabIndex + 1) % availableTabs.length
+			// Tab navigation with Tab key or number keys
+			if (key.tab || (input >= "1" && input <= "5")) {
+				const targetIdx = key.tab
+					? (availableTabs.findIndex((t) => t.key === currentTab) + 1) % availableTabs.length
+					: parseInt(input) - 1
 				if (targetIdx >= 0 && targetIdx < availableTabs.length) {
 					handleTabChange(availableTabs[targetIdx].key)
 				}
@@ -320,45 +256,21 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 			}
 
 			// List navigation (arrow keys and vim-style j/k)
-			if (key.upArrow) {
+			if (key.upArrow || input === "k") {
 				setSelectedIndex((i) => (i > 0 ? i - 1 : currentListLength - 1))
-			} else if (key.downArrow) {
+			} else if (key.downArrow || input === "j") {
 				setSelectedIndex((i) => (i < currentListLength - 1 ? i + 1 : 0))
 			}
 
 			// Tab-specific actions
 			if (currentTab === "settings") {
-				if ((key.return || key.tab) && selectedConfigEntry?.isEditable) {
-					if (selectedConfigEntry.type === "boolean") {
-						handleSettingsSave(!selectedConfigEntry.value)
-						return
-					}
-					if (selectedConfigEntry.type === "object") {
-						const value =
-							selectedConfigEntry.value && typeof selectedConfigEntry.value === "object"
-								? (selectedConfigEntry.value as Record<string, unknown>)
-								: {}
-						setObjectEditor({
-							source: selectedConfigEntry.source,
-							key: selectedConfigEntry.key,
-							path: [],
-							value,
-							selectedIndex: 0,
-							isEditingValue: false,
-							editValue: "",
-						})
-						return
-					}
+				if ((key.return || input === "e") && selectedConfigEntry?.isEditable) {
 					setEditValue(selectedConfigEntry.value !== undefined ? String(selectedConfigEntry.value) : "")
 					setIsEditing(true)
-				} else if (key.ctrl && input.toLowerCase() === "r") {
+				} else if (input === "r") {
 					handleSettingsReset()
-				} else if (key.backspace || key.delete) {
-					setSearchQuery((prev) => prev.slice(0, -1))
-				} else if (input && !key.ctrl && !key.meta && !key.escape && !key.upArrow && !key.downArrow) {
-					setSearchQuery((prev) => prev + input)
 				}
-			} else if (key.return || key.tab || input === " ") {
+			} else if (key.return || input === " ") {
 				// Toggle for rules/workflows/hooks/skills
 				handleToggle()
 			}
@@ -426,31 +338,13 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 		)
 	}
 
-	if (objectEditor && currentTab === "settings") {
-		return (
-			<ObjectEditorPanel
-				getObjectAtPath={getObjectAtPath}
-				onClose={() => setObjectEditor(null)}
-				onPersist={(nextObject) => persistObjectEditor(nextObject, objectEditor.source, objectEditor.key)}
-				setObjectValueAtPath={setObjectValueAtPath}
-				setState={setObjectEditor}
-				state={objectEditor}
-			/>
-		)
-	}
-
 	// Render tab content
 	const renderTabContent = () => {
 		switch (currentTab) {
 			case "settings": {
-				const visibleEntries = filteredConfigEntries.slice(startIndex, startIndex + MAX_VISIBLE)
+				const visibleEntries = configEntries.slice(startIndex, startIndex + MAX_VISIBLE)
 				return (
 					<React.Fragment>
-						<Box>
-							<Text>Search: </Text>
-							<Text color="white">{searchQuery}</Text>
-							<Text inverse> </Text>
-						</Box>
 						<Box>
 							<Text>Data directory: </Text>
 							<Text color="blue" underline>
@@ -613,12 +507,12 @@ export const ConfigView: React.FC<ConfigViewProps> = ({
 
 	// Help text based on current tab
 	const getHelpText = () => {
-		const base = "↑/↓ Navigate • ←/→ tabs • 1-5 tabs • Esc Exit"
+		const base = "↑/↓/j/k Navigate • Tab/1-5 Switch tabs • q/Esc Exit"
 		if (currentTab === "settings") {
-			return `${base} • Type to search • Enter/Tab Edit (booleans toggle) • Backspace clear search • Ctrl+R Reset`
+			return `${base} • Enter/e Edit • r Reset`
 		}
 		const openFolder = onOpenFolder ? " • o Open folder" : ""
-		return `${base} • Enter/Tab/Space Toggle${openFolder}`
+		return `${base} • Enter/Space Toggle${openFolder}`
 	}
 
 	return (

cli/src/components/ConfigViewComponents.tsx

@@ -46,19 +46,16 @@ export interface SkillInfo {
 	enabled: boolean
 }
 
-export interface ObjectEditorState {
-	source: "global" | "workspace"
-	key: string
-	path: string[]
-	value: Record<string, unknown>
-	selectedIndex: number
-	isEditingValue: boolean
-	editValue: string
-}
+export const EXCLUDED_KEYS = new Set([
+	"taskHistory",
+	"primaryRootIndex",
+	"subagentsEnabled",
+	"subagentTerminalOutputLineLimit",
+	"welcomeViewCompleted",
+	"isNewUser",
+])
 
-export const EXCLUDED_KEYS = new Set(["taskHistory", "primaryRootIndex", "welcomeViewCompleted", "isNewUser"])
-
-export const EDITABLE_TYPES: Set<ValueType> = new Set(["string", "number", "boolean", "object"])
+export const EDITABLE_TYPES: Set<ValueType> = new Set(["string", "number", "boolean"])
 export const MAX_VISIBLE = 12
 export const SEPARATOR = "─".repeat(80)
 
@@ -138,7 +135,7 @@ export function parseValue(input: string, type: ValueType): unknown {
 		return input.toLowerCase() === "true" || input === "1"
 	}
 	if (type === "number") {
-		const num = Number.parseFloat(input)
+		const num = parseFloat(input)
 		return Number.isNaN(num) ? 0 : num
 	}
 	if (type === "object") {
@@ -220,7 +217,7 @@ export const TextInput: React.FC<TextInputProps> = ({ label, onChange, onCancel,
 			</Text>
 			<Box>
 				<Text color="white">{value}</Text>
-				<Text color="cyan">|</Text>
+				<Text inverse> </Text>
 			</Box>
 			<Text color="gray">Type: {type} • Enter to save • Esc to cancel</Text>
 		</Box>
@@ -382,169 +379,3 @@ export const SectionHeader: React.FC<{ title: string }> = ({ title }) => (
 		</Text>
 	</Box>
 )
-
-interface ObjectEditorPanelProps {
-	state: ObjectEditorState
-	setState: React.Dispatch<React.SetStateAction<ObjectEditorState | null>>
-	onClose: () => void
-	onPersist: (nextObject: Record<string, unknown>) => void
-	getObjectAtPath: (root: Record<string, unknown>, path: string[]) => Record<string, unknown>
-	setObjectValueAtPath: (root: Record<string, unknown>, path: string[], key: string, value: unknown) => Record<string, unknown>
-}
-
-export const ObjectEditorPanel: React.FC<ObjectEditorPanelProps> = ({
-	state,
-	setState,
-	onClose,
-	onPersist,
-	getObjectAtPath,
-	setObjectValueAtPath,
-}) => {
-	const { isRawModeSupported } = useStdinContext()
-	const currentNode = getObjectAtPath(state.value, state.path)
-	const objectEntries = Object.entries(currentNode).sort(([a], [b]) => a.localeCompare(b))
-	const selectedEntry = objectEntries[state.selectedIndex]
-	const breadcrumb = [state.key, ...state.path].join(" › ")
-
-	useInput(
-		(input, key) => {
-			if (state.isEditingValue) {
-				if (key.escape) {
-					setState((prev) => (prev ? { ...prev, isEditingValue: false, editValue: "" } : prev))
-					return
-				}
-				if (key.return) {
-					if (!selectedEntry) {
-						setState((prev) => (prev ? { ...prev, isEditingValue: false, editValue: "" } : prev))
-						return
-					}
-					const [entryKey, entryValue] = selectedEntry
-					let parsed: unknown = state.editValue
-					if (typeof entryValue === "boolean") {
-						parsed = state.editValue.toLowerCase() === "true" || state.editValue === "1"
-					} else if (typeof entryValue === "number") {
-						const maybeNum = Number(state.editValue)
-						parsed = Number.isNaN(maybeNum) ? 0 : maybeNum
-					}
-					const nextObject = setObjectValueAtPath(state.value, state.path, entryKey, parsed)
-					onPersist(nextObject)
-					setState((prev) => (prev ? { ...prev, value: nextObject, isEditingValue: false, editValue: "" } : prev))
-					return
-				}
-				if (key.backspace || key.delete) {
-					setState((prev) => (prev ? { ...prev, editValue: prev.editValue.slice(0, -1) } : prev))
-					return
-				}
-				if (input && !key.ctrl && !key.meta) {
-					setState((prev) => (prev ? { ...prev, editValue: prev.editValue + input } : prev))
-				}
-				return
-			}
-
-			if (key.escape) {
-				if (state.path.length > 0) {
-					setState((prev) => (prev ? { ...prev, path: prev.path.slice(0, -1), selectedIndex: 0 } : prev))
-				} else {
-					onClose()
-				}
-				return
-			}
-
-			if (key.upArrow || input === "k") {
-				setState((prev) =>
-					prev
-						? {
-								...prev,
-								selectedIndex:
-									objectEntries.length > 0
-										? prev.selectedIndex > 0
-											? prev.selectedIndex - 1
-											: objectEntries.length - 1
-										: 0,
-							}
-						: prev,
-				)
-				return
-			}
-			if (key.downArrow || input === "j") {
-				setState((prev) =>
-					prev
-						? {
-								...prev,
-								selectedIndex:
-									objectEntries.length > 0
-										? prev.selectedIndex < objectEntries.length - 1
-											? prev.selectedIndex + 1
-											: 0
-										: 0,
-							}
-						: prev,
-				)
-				return
-			}
-
-			if (key.return || key.tab) {
-				if (!selectedEntry) {
-					return
-				}
-				const [entryKey, entryValue] = selectedEntry
-				if (typeof entryValue === "boolean") {
-					const nextObject = setObjectValueAtPath(state.value, state.path, entryKey, !entryValue)
-					onPersist(nextObject)
-					setState((prev) => (prev ? { ...prev, value: nextObject } : prev))
-					return
-				}
-				if (entryValue && typeof entryValue === "object" && !Array.isArray(entryValue)) {
-					setState((prev) => (prev ? { ...prev, path: [...prev.path, entryKey], selectedIndex: 0 } : prev))
-					return
-				}
-				setState((prev) =>
-					prev
-						? { ...prev, isEditingValue: true, editValue: entryValue !== undefined ? String(entryValue) : "" }
-						: prev,
-				)
-			}
-		},
-		{ isActive: isRawModeSupported },
-	)
-
-	return (
-		<Box flexDirection="column">
-			<Text bold color="white">
-				⚙️ Edit Nested Object
-			</Text>
-			<Text color="gray">{SEPARATOR}</Text>
-			<Text color="cyan">{breadcrumb}</Text>
-			{state.isEditingValue ? (
-				<Box flexDirection="column" marginTop={1}>
-					<Box>
-						<Text color="white">{state.editValue}</Text>
-						<Text color="cyan">|</Text>
-					</Box>
-					<Text color="gray">Enter to save • Esc to cancel</Text>
-				</Box>
-			) : (
-				<Box flexDirection="column" marginTop={1}>
-					{objectEntries.length === 0 ? (
-						<Text color="gray">No nested keys at this level.</Text>
-					) : (
-						objectEntries.map(([key, value], idx) => {
-							const isSelected = idx === state.selectedIndex
-							const valueText =
-								value && typeof value === "object" && !Array.isArray(value) ? "{...}" : String(value)
-							return (
-								<Text color={isSelected ? "cyan" : undefined} key={key}>
-									{isSelected ? "❯ " : "  "}
-									<Text color="cyan">{key}</Text>
-									<Text color="gray">: </Text>
-									<Text color="white">{valueText}</Text>
-								</Text>
-							)
-						})
-					)}
-					<Text color="gray">↑/↓ Navigate • Enter/Tab Edit or drill in • Esc Back/Close</Text>
-				</Box>
-			)}
-		</Box>
-	)
-}

cli/src/components/FeaturedModelPicker.tsx

@@ -45,15 +45,15 @@ export const FeaturedModelPicker: React.FC<FeaturedModelPickerProps> = ({
 							<Text bold color={isSelected ? COLORS.primaryBlue : "white"}>
 								{model.name}
 							</Text>
-							{model.labels.map((label) => (
-								<Text key={label}>
+							{model.label && (
+								<Text>
 									<Text> </Text>
-									<Text backgroundColor={label === "FREE" ? "gray" : COLORS.primaryBlue} color="black">
+									<Text backgroundColor={model.label === "FREE" ? "gray" : COLORS.primaryBlue} color="black">
 										{" "}
-										{label}{" "}
+										{model.label}{" "}
 									</Text>
 								</Text>
-							))}
+							)}
 						</Box>
 						<Box paddingLeft={2}>
 							<Text color="gray">{model.description}</Text>

cli/src/components/HelpPanelContent.tsx

@@ -43,30 +43,6 @@ export const HelpPanelContent: React.FC<HelpPanelContentProps> = ({ onClose }) =
 					</Text>
 				</Box>
 
-				<Box flexDirection="column">
-					<Text bold>Keyboard Shortcuts</Text>
-					<Text>
-						{"  "}
-						<Text color="white">Ctrl+U</Text> - Clear entire input (delete to start)
-					</Text>
-					<Text>
-						{"  "}
-						<Text color="white">Ctrl+K</Text> - Delete from cursor to end
-					</Text>
-					<Text>
-						{"  "}
-						<Text color="white">Ctrl+W</Text> - Delete word backwards
-					</Text>
-					<Text>
-						{"  "}
-						<Text color="white">Ctrl+A / Ctrl+E</Text> - Jump to start / end of input
-					</Text>
-					<Text>
-						{"  "}
-						<Text color="white">Alt/Option+←/→</Text> - Move by word
-					</Text>
-				</Box>
-
 				<Box flexDirection="column">
 					<Text bold>Slash Commands</Text>
 					<Text>

cli/src/components/ModelPicker.tsx

@@ -6,7 +6,6 @@
 import { Box, Text } from "ink"
 import Spinner from "ink-spinner"
 import React, { useEffect, useMemo, useState } from "react"
-import { refreshOcaModels } from "@/core/controller/models/refreshOcaModels"
 import { refreshOpenRouterModels } from "@/core/controller/models/refreshOpenRouterModels"
 import {
 	type ApiProvider,
@@ -65,7 +64,6 @@ import {
 	xaiDefaultModelId,
 	xaiModels,
 } from "@/shared/api"
-import { StringRequest } from "@/shared/proto/cline/common"
 import { filterOpenRouterModelIds } from "@/shared/utils/model-filters"
 import { COLORS } from "../constants/colors"
 import { getOpenRouterDefaultModelId, usesOpenRouterModels } from "../utils/openrouter-models"
@@ -107,7 +105,7 @@ export function hasStaticModels(provider: string): boolean {
 }
 
 export function hasModelPicker(provider: string): boolean {
-	return hasStaticModels(provider) || usesOpenRouterModels(provider) || provider === "oca"
+	return hasStaticModels(provider) || usesOpenRouterModels(provider)
 }
 
 export function getDefaultModelId(provider: string): string {
@@ -134,7 +132,7 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({ provider, controller,
 	const [isLoading, setIsLoading] = useState(false)
 	const [asyncModels, setAsyncModels] = useState<string[]>([])
 
-	// Fetch async models (OpenRouter or OCA) when needed
+	// Fetch OpenRouter models when needed using shared core function
 	useEffect(() => {
 		if (usesOpenRouterModels(provider)) {
 			setIsLoading(true)
@@ -147,23 +145,11 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({ provider, controller,
 				.finally(() => {
 					setIsLoading(false)
 				})
-		} else if (provider === "oca") {
-			setIsLoading(true)
-			refreshOcaModels(controller, StringRequest.create({ value: "" }))
-				.then((result) => {
-					if (result.models) {
-						const modelIds = Object.keys(result.models).sort((a, b) => a.localeCompare(b))
-						setAsyncModels(modelIds)
-					}
-				})
-				.finally(() => {
-					setIsLoading(false)
-				})
 		}
 	}, [provider, controller])
 
 	const modelList = useMemo(() => {
-		if (usesOpenRouterModels(provider) || provider === "oca") {
+		if (usesOpenRouterModels(provider)) {
 			return asyncModels
 		}
 		return getModelList(provider)
@@ -194,7 +180,7 @@ export const ModelPicker: React.FC<ModelPickerProps> = ({ provider, controller,
 	}
 
 	// If async fetch returned no models, render nothing
-	if ((usesOpenRouterModels(provider) || provider === "oca") && modelList.length === 0) {
+	if (usesOpenRouterModels(provider) && modelList.length === 0) {
 		return null
 	}
 

cli/src/components/OcaEmployeeCheck.tsx

@@ -1,88 +0,0 @@
-/**
- * OCA (Oracle Cloud Assist) employee check component.
- * Shows a checkbox for "I'm an Oracle Employee" and a sign-in button.
- * Sets ocaMode in state before triggering the OAuth flow.
- */
-
-import { Box, Text, useInput } from "ink"
-// biome-ignore lint/style/useImportType: React is used as a value by JSX (jsx: "react" in tsconfig)
-import React, { useCallback, useState } from "react"
-import { StateManager } from "@/core/storage/StateManager"
-import { COLORS } from "../constants/colors"
-import { useStdinContext } from "../context/StdinContext"
-
-interface OcaEmployeeCheckProps {
-	/** Whether this component is active and should handle input */
-	isActive: boolean
-	/** Called when user confirms and wants to proceed with sign-in */
-	onSignIn: () => void
-	/** Called when user presses Escape to go back */
-	onCancel: () => void
-}
-
-export const OcaEmployeeCheck: React.FC<OcaEmployeeCheckProps> = ({ isActive, onSignIn, onCancel }) => {
-	const { isRawModeSupported } = useStdinContext()
-	const [isEmployee, setIsEmployee] = useState(true) // Default to checked (internal), matching extension behavior
-	const [selectedIndex, setSelectedIndex] = useState(0) // 0 = checkbox, 1 = sign in button
-
-	const ITEM_COUNT = 2
-
-	const handleSignIn = useCallback(async () => {
-		// Persist ocaMode to state before starting auth
-		const stateManager = StateManager.get()
-		stateManager.setGlobalState("ocaMode", isEmployee ? "internal" : "external")
-		await stateManager.flushPendingState()
-		onSignIn()
-	}, [isEmployee, onSignIn])
-
-	useInput(
-		(_input, key) => {
-			if (key.escape) {
-				onCancel()
-				return
-			}
-			if (key.upArrow) {
-				setSelectedIndex((prev) => (prev > 0 ? prev - 1 : ITEM_COUNT - 1))
-			} else if (key.downArrow) {
-				setSelectedIndex((prev) => (prev < ITEM_COUNT - 1 ? prev + 1 : 0))
-			} else if (key.tab || (key.return && selectedIndex === 0)) {
-				// Toggle checkbox when Tab is pressed or Enter on checkbox item
-				if (selectedIndex === 0) {
-					setIsEmployee((prev) => !prev)
-				}
-			} else if (key.return && selectedIndex === 1) {
-				// Sign in button
-				handleSignIn()
-			}
-		},
-		{ isActive: isRawModeSupported && isActive },
-	)
-
-	return (
-		<Box flexDirection="column">
-			<Text color="white">Oracle Code Assist</Text>
-			<Text> </Text>
-			{/* Checkbox: I'm an Oracle Employee */}
-			<Text>
-				<Text bold color={selectedIndex === 0 ? COLORS.primaryBlue : undefined}>
-					{selectedIndex === 0 ? "❯" : " "}{" "}
-				</Text>
-				<Text color={selectedIndex === 0 || isEmployee ? COLORS.primaryBlue : "gray"}>{isEmployee ? "[✓]" : "[ ]"}</Text>
-				<Text color={selectedIndex === 0 ? COLORS.primaryBlue : "white"}> I'm an Oracle Employee</Text>
-				{selectedIndex === 0 && <Text color="gray"> (Tab to toggle)</Text>}
-			</Text>
-			{/* Sign in button */}
-			<Text>
-				<Text bold color={selectedIndex === 1 ? COLORS.primaryBlue : undefined}>
-					{selectedIndex === 1 ? "❯" : " "}{" "}
-				</Text>
-				<Text color={selectedIndex === 1 ? COLORS.primaryBlue : "white"}>Sign in with Oracle Code Assist</Text>
-				{selectedIndex === 1 && <Text color="gray"> (Enter)</Text>}
-			</Text>
-			<Text> </Text>
-			<Text color="gray">Please ask your IT administrator to set up Oracle Code Assist as a model provider.</Text>
-			<Text> </Text>
-			<Text color="gray">Arrows to navigate, Tab to toggle, Enter to continue, Esc to go back</Text>
-		</Box>
-	)
-}

cli/src/components/ProviderPicker.tsx

@@ -5,11 +5,11 @@
 import React, { useMemo } from "react"
 import { StateManager } from "@/core/storage/StateManager"
 import type { ApiConfiguration } from "@/shared/api"
-import { getProviderLabel, useValidProviders } from "../utils/providers"
-import { SearchableList, type SearchableListItem } from "./SearchableList"
+import { CLI_EXCLUDED_PROVIDERS, getProviderLabel, getProviderOrder } from "../utils/providers"
+import { SearchableList, SearchableListItem } from "./SearchableList"
 
 // Re-export for backwards compatibility
-export { getProviderLabel }
+export { CLI_EXCLUDED_PROVIDERS, getProviderLabel, getProviderOrder }
 
 /**
  * Check if a provider is configured (has required credentials/settings)
@@ -125,16 +125,17 @@ interface ProviderPickerProps {
 export const ProviderPicker: React.FC<ProviderPickerProps> = ({ onSelect, isActive = true }) => {
 	// Get API configuration to check which providers are configured
 	const apiConfig = StateManager.get().getApiConfiguration()
-	const sorted = useValidProviders()
 
 	// Use providers.json order, filtered to exclude CLI-incompatible providers
 	const items: SearchableListItem[] = useMemo(() => {
+		const sorted = getProviderOrder().filter((p: string) => !CLI_EXCLUDED_PROVIDERS.has(p))
+
 		return sorted.map((providerId: string) => ({
 			id: providerId,
 			label: getProviderLabel(providerId),
 			suffix: isProviderConfigured(providerId, apiConfig) ? "(Configured)" : undefined,
 		}))
-	}, [apiConfig, sorted])
+	}, [apiConfig])
 
 	return <SearchableList isActive={isActive} items={items} onSelect={(item) => onSelect(item.id)} />
 }

cli/src/components/SettingsPanelContent.tsx

@@ -7,21 +7,17 @@ import type { AutoApprovalSettings } from "@shared/AutoApprovalSettings"
 import { DEFAULT_AUTO_APPROVAL_SETTINGS } from "@shared/AutoApprovalSettings"
 import type { ApiProvider, ModelInfo } from "@shared/api"
 import { getProviderModelIdKey, isSettingsKey, ProviderToApiKeyMap } from "@shared/storage"
-import { isOpenaiReasoningEffort, OPENAI_REASONING_EFFORT_OPTIONS, type OpenaiReasoningEffort } from "@shared/storage/types"
 import type { TelemetrySetting } from "@shared/TelemetrySetting"
 import { Box, Text, useInput } from "ink"
 import Spinner from "ink-spinner"
 import React, { useCallback, useEffect, useMemo, useState } from "react"
 import { buildApiHandler } from "@/core/api"
 import type { Controller } from "@/core/controller"
-import { refreshOcaModels } from "@/core/controller/models/refreshOcaModels"
 import { StateManager } from "@/core/storage/StateManager"
 import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
 import { ClineAccountService } from "@/services/account/ClineAccountService"
 import { AuthService, ClineAccountOrganization } from "@/services/auth/AuthService"
-import { StringRequest } from "@/shared/proto/cline/common"
 import { openExternal } from "@/utils/env"
-import { supportsReasoningEffortForModel } from "@/utils/model-utils"
 import { version as CLI_VERSION } from "../../package.json"
 import { COLORS } from "../constants/colors"
 import { useStdinContext } from "../context/StdinContext"
@@ -39,7 +35,6 @@ import {
 } from "./FeaturedModelPicker"
 import { LanguagePicker } from "./LanguagePicker"
 import { hasModelPicker, ModelPicker } from "./ModelPicker"
-import { OcaEmployeeCheck } from "./OcaEmployeeCheck"
 import { OrganizationPicker } from "./OrganizationPicker"
 import { Panel, PanelTab } from "./Panel"
 import { getProviderLabel, ProviderPicker } from "./ProviderPicker"
@@ -56,25 +51,13 @@ type SettingsTab = "api" | "auto-approve" | "features" | "other" | "account"
 interface ListItem {
 	key: string
 	label: string
-	type: "checkbox" | "readonly" | "editable" | "separator" | "header" | "spacer" | "action" | "cycle"
+	type: "checkbox" | "readonly" | "editable" | "separator" | "header" | "spacer" | "action"
 	value: string | boolean
 	description?: string
 	isSubItem?: boolean
 	parentKey?: string
 }
 
-function normalizeReasoningEffort(value: unknown): OpenaiReasoningEffort {
-	if (isOpenaiReasoningEffort(value)) {
-		return value
-	}
-	return "low"
-}
-
-function nextReasoningEffort(current: OpenaiReasoningEffort): OpenaiReasoningEffort {
-	const idx = OPENAI_REASONING_EFFORT_OPTIONS.indexOf(current)
-	return OPENAI_REASONING_EFFORT_OPTIONS[(idx + 1) % OPENAI_REASONING_EFFORT_OPTIONS.length]
-}
-
 const TABS: PanelTab[] = [
 	{ key: "api", label: "API" },
 	{ key: "auto-approve", label: "Auto-approve" },
@@ -85,12 +68,6 @@ const TABS: PanelTab[] = [
 
 // Settings configuration for simple boolean toggles
 const FEATURE_SETTINGS = {
-	subagents: {
-		stateKey: "subagentsEnabled",
-		default: false,
-		label: "Subagents",
-		description: "Let Cline run focused subagents in parallel to explore the codebase for you",
-	},
 	autoCondense: {
 		stateKey: "useAutoCondense",
 		default: false,
@@ -121,12 +98,6 @@ const FEATURE_SETTINGS = {
 		label: "Parallel tool calling",
 		description: "Allow multiple tools in a single response",
 	},
-	doubleCheckCompletion: {
-		stateKey: "doubleCheckCompletionEnabled",
-		default: false,
-		label: "Double-check completion",
-		description: "Reject first completion attempt and require re-verification",
-	},
 } as const
 
 type FeatureKey = keyof typeof FEATURE_SETTINGS
@@ -165,7 +136,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 	const [isEnteringApiKey, setIsEnteringApiKey] = useState(false)
 	const [isConfiguringBedrock, setIsConfiguringBedrock] = useState(false)
 	const [isWaitingForCodexAuth, setIsWaitingForCodexAuth] = useState(false)
-	const [isShowingOcaEmployeeCheck, setIsShowingOcaEmployeeCheck] = useState(false)
 	const [codexAuthError, setCodexAuthError] = useState<string | null>(null)
 	const [pendingProvider, setPendingProvider] = useState<string | null>(null)
 	const [apiKeyValue, setApiKeyValue] = useState("")
@@ -195,12 +165,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 	const [planThinkingEnabled, setPlanThinkingEnabled] = useState<boolean>(
 		() => (stateManager.getGlobalSettingsKey("planModeThinkingBudgetTokens") ?? 0) > 0,
 	)
-	const [actReasoningEffort, setActReasoningEffort] = useState<OpenaiReasoningEffort>(() =>
-		normalizeReasoningEffort(stateManager.getGlobalSettingsKey("actModeReasoningEffort")),
-	)
-	const [planReasoningEffort, setPlanReasoningEffort] = useState<OpenaiReasoningEffort>(() =>
-		normalizeReasoningEffort(stateManager.getGlobalSettingsKey("planModeReasoningEffort")),
-	)
 
 	// Auto-approve settings (complex nested object)
 	const [autoApproveSettings, setAutoApproveSettings] = useState<AutoApprovalSettings>(() => {
@@ -239,8 +203,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 	// OCA auth hook
 	const handleOcaAuthSuccess = useCallback(async () => {
 		await applyProviderConfig({ providerId: "oca", controller })
-		// Fetch OCA models from the API - this sets actModeOcaModelId/planModeOcaModelId in state
-		await refreshOcaModels(controller!, StringRequest.create({ value: "" }))
 		setProvider("oca")
 		refreshModelIds()
 	}, [controller, refreshModelIds])
@@ -433,12 +395,9 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 
 	// Build items list based on current tab
 	const items: ListItem[] = useMemo(() => {
-		// Some providers/models expose reasoning effort instead of thinking budget controls.
-		const providerUsesReasoningEffort = provider === "openai-native" || provider === "openai-codex"
-		const showActReasoningEffort = supportsReasoningEffortForModel(actModelId || "")
-		const showPlanReasoningEffort = supportsReasoningEffortForModel(planModelId || "")
-		const showActThinkingOption = !providerUsesReasoningEffort && !showActReasoningEffort
-		const showPlanThinkingOption = !providerUsesReasoningEffort && !showPlanReasoningEffort
+		// OpenAI Native, Codex, and GPT models don't support thinking budget (they use reasoning effort)
+		const isGptModel = actModelId?.toLowerCase().includes("gpt") || planModelId?.toLowerCase().includes("gpt")
+		const showThinkingOption = provider !== "openai-native" && provider !== "openai-codex" && !isGptModel
 
 		switch (currentTab) {
 			case "api":
@@ -462,7 +421,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 									type: "editable" as const,
 									value: actModelId || "not set",
 								},
-								...(showActThinkingOption
+								...(showThinkingOption
 									? [
 											{
 												key: "actThinkingEnabled",
@@ -472,16 +431,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 											},
 										]
 									: []),
-								...(showActReasoningEffort
-									? [
-											{
-												key: "actReasoningEffort",
-												label: "Reasoning effort",
-												type: "cycle" as const,
-												value: actReasoningEffort,
-											},
-										]
-									: []),
 								{ key: "planHeader", label: "Plan Mode", type: "header" as const, value: "" },
 								{
 									key: "planModelId",
@@ -489,7 +438,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 									type: "editable" as const,
 									value: planModelId || "not set",
 								},
-								...(showPlanThinkingOption
+								...(showThinkingOption
 									? [
 											{
 												key: "planThinkingEnabled",
@@ -499,16 +448,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 											},
 										]
 									: []),
-								...(showPlanReasoningEffort
-									? [
-											{
-												key: "planReasoningEffort",
-												label: "Reasoning effort",
-												type: "cycle" as const,
-												value: planReasoningEffort,
-											},
-										]
-									: []),
 								{ key: "spacer1", label: "", type: "spacer" as const, value: "" },
 							]
 						: [
@@ -518,7 +457,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 									type: "editable" as const,
 									value: actModelId || "not set",
 								},
-								...(showActThinkingOption
+								...(showThinkingOption
 									? [
 											{
 												key: "actThinkingEnabled",
@@ -528,16 +467,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 											},
 										]
 									: []),
-								...(showActReasoningEffort
-									? [
-											{
-												key: "actReasoningEffort",
-												label: "Reasoning effort",
-												type: "cycle" as const,
-												value: actReasoningEffort,
-											},
-										]
-									: []),
 							]),
 					{
 						key: "separateModels",
@@ -700,8 +629,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		separateModels,
 		actThinkingEnabled,
 		planThinkingEnabled,
-		actReasoningEffort,
-		planReasoningEffort,
 		autoApproveSettings,
 		features,
 		preferredLanguage,
@@ -735,33 +662,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		}
 	}, [items.length, selectedIndex])
 
-	const rebuildTaskApi = useCallback(() => {
-		if (!controller?.task) {
-			return
-		}
-		const currentMode = stateManager.getGlobalSettingsKey("mode")
-		const apiConfig = stateManager.getApiConfiguration()
-		controller.task.api = buildApiHandler({ ...apiConfig, ulid: controller.task.ulid }, currentMode)
-	}, [controller, stateManager])
-
-	const setReasoningEffortForMode = useCallback(
-		(mode: "act" | "plan", effort: OpenaiReasoningEffort) => {
-			if (mode === "act") {
-				setActReasoningEffort(effort)
-				stateManager.setGlobalState("actModeReasoningEffort", effort)
-				if (!separateModels) {
-					setPlanReasoningEffort(effort)
-					stateManager.setGlobalState("planModeReasoningEffort", effort)
-				}
-			} else {
-				setPlanReasoningEffort(effort)
-				stateManager.setGlobalState("planModeReasoningEffort", effort)
-			}
-			rebuildTaskApi()
-		},
-		[separateModels, rebuildTaskApi, stateManager],
-	)
-
 	// Handle toggle/edit for selected item
 	const handleAction = useCallback(() => {
 		const item = items[selectedIndex]
@@ -785,15 +685,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 			return
 		}
 
-		if (item.type === "cycle") {
-			const targetMode = item.key === "actReasoningEffort" ? "act" : item.key === "planReasoningEffort" ? "plan" : undefined
-			if (targetMode) {
-				const currentEffort = targetMode === "act" ? actReasoningEffort : planReasoningEffort
-				setReasoningEffortForMode(targetMode, nextReasoningEffort(currentEffort))
-			}
-			return
-		}
-
 		if (item.type === "editable") {
 			// For provider field, use the provider picker
 			if (item.key === "provider") {
@@ -851,16 +742,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 					const actModel = stateManager.getGlobalSettingsKey(actKey)
 					if (planKey) stateManager.setGlobalState(planKey, actModel)
 				}
-				const actThinkingBudget = stateManager.getGlobalSettingsKey("actModeThinkingBudgetTokens") ?? 0
-				stateManager.setGlobalState("planModeThinkingBudgetTokens", actThinkingBudget)
-				setPlanThinkingEnabled(actThinkingBudget > 0)
-
-				const actEffort = normalizeReasoningEffort(stateManager.getGlobalSettingsKey("actModeReasoningEffort"))
-				stateManager.setGlobalState("planModeReasoningEffort", actEffort)
-				setPlanReasoningEffort(actEffort)
 			}
-
-			rebuildTaskApi()
 			return
 		}
 
@@ -868,19 +750,23 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		if (item.key === "actThinkingEnabled") {
 			setActThinkingEnabled(newValue)
 			stateManager.setGlobalState("actModeThinkingBudgetTokens", newValue ? 1024 : 0)
-			if (!separateModels) {
-				setPlanThinkingEnabled(newValue)
-				stateManager.setGlobalState("planModeThinkingBudgetTokens", newValue ? 1024 : 0)
-			}
 			// Rebuild API handler to apply thinking budget change
-			rebuildTaskApi()
+			if (controller?.task) {
+				const currentMode = stateManager.getGlobalSettingsKey("mode")
+				const apiConfig = stateManager.getApiConfiguration()
+				controller.task.api = buildApiHandler({ ...apiConfig, ulid: controller.task.ulid }, currentMode)
+			}
 			return
 		}
 		if (item.key === "planThinkingEnabled") {
 			setPlanThinkingEnabled(newValue)
 			stateManager.setGlobalState("planModeThinkingBudgetTokens", newValue ? 1024 : 0)
 			// Rebuild API handler to apply thinking budget change
-			rebuildTaskApi()
+			if (controller?.task) {
+				const currentMode = stateManager.getGlobalSettingsKey("mode")
+				const apiConfig = stateManager.getApiConfiguration()
+				controller.task.api = buildApiHandler({ ...apiConfig, ulid: controller.task.ulid }, currentMode)
+			}
 			return
 		}
 
@@ -937,11 +823,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		handleClineLogin,
 		handleClineLogout,
 		accountOrganizations,
-		separateModels,
-		actReasoningEffort,
-		planReasoningEffort,
-		rebuildTaskApi,
-		setReasoningEffortForMode,
 	])
 
 	// Handle model selection from picker
@@ -1084,8 +965,8 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 					setProvider("oca")
 					refreshModelIds()
 				} else {
-					// Not logged in - show employee check before auth
-					setIsShowingOcaEmployeeCheck(true)
+					// Not logged in - trigger OAuth
+					startOcaAuth()
 				}
 				return
 			}
@@ -1376,7 +1257,7 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 				return
 			}
 		},
-		{ isActive: isRawModeSupported && !isEnteringApiKey && !isConfiguringBedrock && !isShowingOcaEmployeeCheck },
+		{ isActive: isRawModeSupported && !isEnteringApiKey && !isConfiguringBedrock },
 	)
 
 	// Render content
@@ -1552,19 +1433,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 			)
 		}
 
-		if (isShowingOcaEmployeeCheck) {
-			return (
-				<OcaEmployeeCheck
-					isActive={isShowingOcaEmployeeCheck}
-					onCancel={() => setIsShowingOcaEmployeeCheck(false)}
-					onSignIn={() => {
-						setIsShowingOcaEmployeeCheck(false)
-						startOcaAuth()
-					}}
-				/>
-			)
-		}
-
 		if (isWaitingForOcaAuth) {
 			return (
 				<Box flexDirection="column">
@@ -1701,21 +1569,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 						)
 					}
 
-					if (item.type === "cycle") {
-						return (
-							<Text key={item.key}>
-								<Text bold color={isSelected ? COLORS.primaryBlue : undefined}>
-									{isSelected ? "❯" : " "}{" "}
-								</Text>
-								<Text color={isSelected ? COLORS.primaryBlue : "white"}>{item.label}: </Text>
-								<Text color={COLORS.primaryBlue}>
-									{typeof item.value === "string" ? item.value : String(item.value)}
-								</Text>
-								{isSelected && <Text color="gray"> (Tab to cycle)</Text>}
-							</Text>
-						)
-					}
-
 					// Readonly or editable field
 					return (
 						<Text key={item.key}>
@@ -1746,7 +1599,6 @@ export const SettingsPanelContent: React.FC<SettingsPanelContentProps> = ({
 		!!codexAuthError ||
 		isPickingOrganization ||
 		isWaitingForClineAuth ||
-		isShowingOcaEmployeeCheck ||
 		isWaitingForOcaAuth ||
 		isEditing
 

cli/src/components/SubagentMessage.tsx

@@ -1,361 +0,0 @@
-import type { ClineAskUseSubagents, ClineMessage, ClineSaySubagentStatus } from "@shared/ExtensionMessage"
-import { Box, Text } from "ink"
-import Spinner from "ink-spinner"
-import React from "react"
-import { COLORS } from "../constants/colors"
-import { useTerminalSize } from "../hooks/useTerminalSize"
-import { jsonParseSafe } from "../utils/parser"
-
-interface SubagentMessageProps {
-	message: ClineMessage
-	isStreaming?: boolean
-	mode?: "act" | "plan"
-}
-
-const TREE_PREFIX_WIDTH = 5
-const MIN_PROMPT_WIDTH = 20
-
-const DotRow: React.FC<{ children: React.ReactNode; color?: string; flashing?: boolean }> = ({
-	children,
-	color,
-	flashing = false,
-}) => (
-	<Box flexDirection="row">
-		<Box width={2}>
-			{flashing ? (
-				<Text color={color}>
-					<Spinner type="toggle8" />
-				</Text>
-			) : (
-				<Text color={color}>⏺</Text>
-			)}
-		</Box>
-		<Box flexGrow={1}>{children}</Box>
-	</Box>
-)
-
-function formatCompactTokens(tokens: number | undefined): string {
-	const value = Number.isFinite(tokens) ? Math.max(0, tokens || 0) : 0
-	return new Intl.NumberFormat("en-US", {
-		notation: "compact",
-		maximumFractionDigits: 1,
-	})
-		.format(value)
-		.toLowerCase()
-}
-
-function formatCompactCost(cost: number | undefined): string {
-	const value = Number.isFinite(cost) ? Math.max(0, cost || 0) : 0
-	const maximumFractionDigits = value >= 0.01 ? 2 : 4
-	return new Intl.NumberFormat("en-US", {
-		style: "currency",
-		currency: "USD",
-		minimumFractionDigits: 2,
-		maximumFractionDigits,
-	}).format(value)
-}
-
-function formatSubagentStatsValues(
-	toolCalls: number | undefined,
-	contextTokens: number | undefined,
-	totalCost: number | undefined,
-	latestToolCall?: string,
-) {
-	const safeToolCalls = Number.isFinite(toolCalls) ? Math.max(0, toolCalls || 0) : 0
-	const toolUses = safeToolCalls === 1 ? "tool use" : "tool uses"
-	const tokensUsed = formatCompactTokens(contextTokens || 0)
-	const formattedCost = formatCompactCost(totalCost || 0)
-	const stats = `${safeToolCalls} ${toolUses} · ${tokensUsed} tokens · ${formattedCost}`
-	const latestTool = latestToolCall?.trim()
-	return latestTool ? `${latestTool} · ${stats}` : stats
-}
-
-function wrapPrompt(text: string, width: number): string[] {
-	if (!text) {
-		return [""]
-	}
-
-	const normalizedWidth = Math.max(1, width)
-	const wrappedLines: string[] = []
-	const paragraphs = text.split("\n")
-
-	for (const paragraph of paragraphs) {
-		const words = paragraph.trim().split(/\s+/).filter(Boolean)
-		if (words.length === 0) {
-			wrappedLines.push("")
-			continue
-		}
-
-		let line = ""
-		for (const word of words) {
-			if (!line) {
-				if (word.length <= normalizedWidth) {
-					line = word
-					continue
-				}
-
-				let remaining = word
-				while (remaining.length > normalizedWidth) {
-					wrappedLines.push(remaining.slice(0, normalizedWidth))
-					remaining = remaining.slice(normalizedWidth)
-				}
-				line = remaining
-				continue
-			}
-
-			if (line.length + 1 + word.length <= normalizedWidth) {
-				line = `${line} ${word}`
-				continue
-			}
-
-			wrappedLines.push(line)
-
-			if (word.length <= normalizedWidth) {
-				line = word
-				continue
-			}
-
-			let remaining = word
-			while (remaining.length > normalizedWidth) {
-				wrappedLines.push(remaining.slice(0, normalizedWidth))
-				remaining = remaining.slice(normalizedWidth)
-			}
-			line = remaining
-		}
-
-		if (line) {
-			wrappedLines.push(line)
-		}
-	}
-
-	return wrappedLines.length > 0 ? wrappedLines : [text]
-}
-
-const TreePromptRow: React.FC<{
-	prefix: React.ReactNode
-	continuationPrefix: string
-	prompt: string
-	promptWidth: number
-	color?: string
-}> = ({ prefix, continuationPrefix, prompt, promptWidth, color }) => {
-	const lines = wrapPrompt(prompt, promptWidth)
-
-	return (
-		<Box flexDirection="column" width="100%">
-			{lines.map((line, index) => (
-				<Box flexDirection="row" key={`${line}-${index}`} width="100%">
-					<Box flexShrink={0} width={TREE_PREFIX_WIDTH}>
-						{index === 0 ? prefix : <Text color="gray">{continuationPrefix}</Text>}
-					</Box>
-					<Box flexGrow={1}>
-						<Text color={color}>{line}</Text>
-					</Box>
-				</Box>
-			))}
-		</Box>
-	)
-}
-
-const TreeStatsRow: React.FC<{ prefix: string; stats: string }> = ({ prefix, stats }) => (
-	<Box flexDirection="row" width="100%">
-		<Box flexShrink={0} width={TREE_PREFIX_WIDTH}>
-			<Text color="gray">{prefix}</Text>
-		</Box>
-		<Box flexGrow={1}>
-			<Text color="gray">⎿ {stats}</Text>
-		</Box>
-	</Box>
-)
-
-export const SubagentMessage: React.FC<SubagentMessageProps> = ({ message, mode, isStreaming }) => {
-	const { type, ask, say, text, partial } = message
-	const toolColor = mode === "plan" ? "yellow" : COLORS.primaryBlue
-	const { columns } = useTerminalSize()
-	const promptWidth = Math.max(MIN_PROMPT_WIDTH, columns - 2 - TREE_PREFIX_WIDTH)
-
-	if ((type === "ask" && ask === "use_subagents") || say === "use_subagents") {
-		const parsed = text
-			? jsonParseSafe<ClineAskUseSubagents>(text, {
-					prompts: [],
-				})
-			: { prompts: [] }
-
-		const prompts = (parsed.prompts || []).map((prompt) => prompt?.trim()).filter(Boolean)
-		if (prompts.length === 0) {
-			return (
-				<Box flexDirection="column" marginBottom={1} width="100%">
-					<DotRow color={toolColor}>
-						<Text color={toolColor}>Cline wants to run subagents:</Text>
-					</DotRow>
-				</Box>
-			)
-		}
-
-		const singular = prompts.length === 1
-		return (
-			<Box flexDirection="column" marginBottom={1} width="100%">
-				<DotRow color={toolColor} flashing={partial === true && isStreaming}>
-					<Text color={toolColor}>{singular ? "Cline wants to run a subagent:" : "Cline wants to run subagents:"}</Text>
-				</DotRow>
-				<Box flexDirection="column" marginLeft={2} width="100%">
-					{prompts.map((prompt, index) => {
-						const isLastPrompt = index === prompts.length - 1
-						const branch = isLastPrompt ? "└─" : "├─"
-						const continuationPrefix = isLastPrompt ? "     " : "│    "
-						const shouldShowPromptStats = partial !== true || !isLastPrompt
-						return (
-							<Box flexDirection="column" key={`${prompt}-${index}`}>
-								<TreePromptRow
-									color={toolColor}
-									continuationPrefix={continuationPrefix}
-									prefix={<Text color={toolColor}>{`${branch} `}</Text>}
-									prompt={prompt}
-									promptWidth={promptWidth}
-								/>
-								{shouldShowPromptStats && (
-									<TreeStatsRow
-										prefix={continuationPrefix}
-										stats={formatSubagentStatsValues(undefined, undefined, undefined)}
-									/>
-								)}
-							</Box>
-						)
-					})}
-				</Box>
-			</Box>
-		)
-	}
-
-	if (say === "subagent" && text) {
-		const parsed = jsonParseSafe<ClineSaySubagentStatus>(text, {
-			status: "running",
-			total: 0,
-			completed: 0,
-			successes: 0,
-			failures: 0,
-			toolCalls: 0,
-			inputTokens: 0,
-			outputTokens: 0,
-			contextWindow: 0,
-			maxContextTokens: 0,
-			maxContextUsagePercentage: 0,
-			items: [],
-		})
-
-		const items = parsed.items || []
-		if (items.length === 0) {
-			return null
-		}
-
-		return (
-			<Box flexDirection="column" marginBottom={1} width="100%">
-				<DotRow color={toolColor} flashing={partial === true && isStreaming}>
-					<Text color={toolColor}>
-						{items.length === 1 ? "Cline is running a subagent:" : "Cline is running subagents:"}
-					</Text>
-				</DotRow>
-				<Box flexDirection="column" marginLeft={2} width="100%">
-					{items.map((entry, index) => {
-						const isLastEntry = index === items.length - 1
-						const branch = isLastEntry ? "└─" : "├─"
-						const continuationPrefix = isLastEntry ? "     " : "│    "
-						const key = `${entry.index}-${index}`
-						const shouldShowStats = true
-
-						if (entry.status === "completed") {
-							return (
-								<Box flexDirection="column" key={key}>
-									<TreePromptRow
-										color="green"
-										continuationPrefix={continuationPrefix}
-										prefix={
-											<Box flexDirection="row">
-												<Text color="gray">{`${branch} `}</Text>
-												<Text color="green">✓</Text>
-											</Box>
-										}
-										prompt={entry.prompt}
-										promptWidth={promptWidth}
-									/>
-									<TreeStatsRow
-										prefix={continuationPrefix}
-										stats={formatSubagentStatsValues(
-											entry.toolCalls,
-											entry.contextTokens,
-											entry.totalCost,
-											entry.latestToolCall,
-										)}
-									/>
-								</Box>
-							)
-						}
-
-						if (entry.status === "failed") {
-							return (
-								<Box flexDirection="column" key={key}>
-									<TreePromptRow
-										color="red"
-										continuationPrefix={continuationPrefix}
-										prefix={
-											<Box flexDirection="row">
-												<Text color="gray">{`${branch} `}</Text>
-												<Text color="red">✗</Text>
-											</Box>
-										}
-										prompt={entry.prompt}
-										promptWidth={promptWidth}
-									/>
-									<TreeStatsRow
-										prefix={continuationPrefix}
-										stats={formatSubagentStatsValues(
-											entry.toolCalls,
-											entry.contextTokens,
-											entry.totalCost,
-											entry.latestToolCall,
-										)}
-									/>
-								</Box>
-							)
-						}
-
-						return (
-							<Box flexDirection="column" key={key}>
-								<TreePromptRow
-									color={toolColor}
-									continuationPrefix={continuationPrefix}
-									prefix={
-										<Box flexDirection="row">
-											<Text color="gray">{branch} </Text>
-											{entry.status === "running" ? (
-												<Text color={toolColor}>
-													<Spinner type="dots" />
-												</Text>
-											) : (
-												<Text color={toolColor}>•</Text>
-											)}
-										</Box>
-									}
-									prompt={entry.prompt}
-									promptWidth={promptWidth}
-								/>
-								{shouldShowStats && (
-									<TreeStatsRow
-										prefix={continuationPrefix}
-										stats={formatSubagentStatsValues(
-											entry.toolCalls,
-											entry.contextTokens,
-											entry.totalCost,
-											entry.latestToolCall,
-										)}
-									/>
-								)}
-							</Box>
-						)
-					})}
-				</Box>
-			</Box>
-		)
-	}
-
-	return null
-}

cli/src/constants/featured-models.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { getAllFeaturedModels } from "./featured-models"
-
-describe("featured models", () => {
-	it("includes display names for all featured models", () => {
-		const models = getAllFeaturedModels()
-
-		for (const model of models) {
-			expect(model.name).toBeTruthy()
-		}
-	})
-})

cli/src/constants/featured-models.ts

@@ -7,50 +7,50 @@ export interface FeaturedModel {
 	id: string
 	name: string
 	description: string
-	labels: string[]
+	label: string
 }
 
-export const FEATURED_MODELS: { recommended: FeaturedModel[]; free: FeaturedModel[] } = {
+export const FEATURED_MODELS = {
 	recommended: [
 		{
-			id: "anthropic/claude-opus-4.6",
-			name: "Claude Opus 4.6",
+			id: "anthropic/claude-opus-4.5",
+			name: "Claude Opus 4.5",
 			description: "State-of-the-art for complex coding",
-			labels: ["BEST"],
+			label: "Best",
 		},
 		{
 			id: "openai/gpt-5.2-codex",
 			name: "GPT 5.2 Codex",
 			description: "OpenAI's latest with strong coding abilities",
-			labels: ["NEW"],
+			label: "New",
 		},
 		{
 			id: "google/gemini-3-pro-preview",
 			name: "Gemini 3 Pro",
 			description: "1M context window for large codebases",
-			labels: ["TRENDING"],
+			label: "Trending",
 		},
-	],
+	] as FeaturedModel[],
 	free: [
 		{
-			id: "minimax/minimax-m2.5",
-			name: "MiniMax M2.5",
-			description: "MiniMax-M2.5 is a lightweight, state-of-the-art LLM optimized for coding and agentic workflows",
-			labels: ["FREE"],
+			id: "moonshotai/kimi-k2.5",
+			name: "Kimi K2.5",
+			description: "State-of-the-art model topping benchmarks",
+			label: "FREE",
 		},
 		{
 			id: "kwaipilot/kat-coder-pro",
 			name: "KAT Coder Pro",
-			description: "KwaiKAT's most advanced agentic coding model in the KAT-Coder series",
-			labels: ["FREE"],
+			description: "Advanced agentic coding model",
+			label: "FREE",
 		},
 		{
 			id: "arcee-ai/trinity-large-preview:free",
 			name: "Trinity Large Preview",
-			description: "Arcee AI's advanced large preview model in the Trinity series",
-			labels: ["FREE"],
+			description: "US built open source coding model",
+			label: "FREE",
 		},
-	],
+	] as FeaturedModel[],
 }
 
 export function getAllFeaturedModels(): FeaturedModel[] {

cli/src/controllers/index.ts

@@ -142,17 +142,6 @@ export class CliEnvServiceClient implements EnvServiceClientInterface {
 		printInfo("Shutting down...")
 		return proto.cline.Empty.create()
 	}
-
-	async openExternal(request: proto.cline.StringRequest): Promise<proto.cline.Empty> {
-		const url = request.value || ""
-		if (url) {
-			printInfo(`🌐 Opening: ${url}`)
-			// Dynamically import 'open' to open URL in default browser
-			const { default: open } = await import("open")
-			await open(url)
-		}
-		return proto.cline.Empty.create()
-	}
 }
 
 /**

cli/src/hooks/useTextInput.ts

@@ -6,7 +6,6 @@
  * - Ctrl+A/E: start/end of line
  * - Ctrl+W: delete word backwards
  * - Ctrl+U: delete to start of line
- * - Ctrl+K: delete to end of line
  *
  * Note: Home/End keys are handled by useHomeEndKeys hook because Ink doesn't
  * expose them in useInput (it sets input='' for these keys).
@@ -153,14 +152,6 @@ export function useTextInput(): UseTextInputReturn {
 		}
 	}, [])
 
-	const deleteToEnd = useCallback(() => {
-		const pos = cursorRef.current
-		if (pos < textRef.current.length) {
-			setTextState((prev) => prev.slice(0, pos))
-			// Cursor stays at same position (now at end of text)
-		}
-	}, [])
-
 	// Cursor movement (internal, used by handlers)
 	const moveToStart = useCallback(() => setCursorPosState(0), [])
 	const moveToEnd = useCallback(() => setCursorPosState(textRef.current.length), [])
@@ -199,9 +190,6 @@ export function useTextInput(): UseTextInputReturn {
 				case "u": // Ctrl+U - delete to start
 					deleteToStart()
 					return true
-				case "k": // Ctrl+K - delete to end
-					deleteToEnd()
-					return true
 				case "w": // Ctrl+W - delete word backwards
 					deleteWordBefore()
 					return true
@@ -209,7 +197,7 @@ export function useTextInput(): UseTextInputReturn {
 					return false
 			}
 		},
-		[moveToStart, moveToEnd, deleteToStart, deleteToEnd, deleteWordBefore],
+		[moveToStart, moveToEnd, deleteToStart, deleteWordBefore],
 	)
 
 	return {

cli/src/index.test.ts

@@ -30,9 +30,7 @@ describe("CLI Commands", () => {
 			.option("-v, --verbose", "Show verbose output")
 			.option("-c, --cwd <path>", "Working directory")
 			.option("--config <path>", "Configuration directory")
-			.option("--thinking [tokens]", "Enable extended thinking")
-			.option("--reasoning-effort <effort>", "Reasoning effort")
-			.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes")
+			.option("--thinking", "Enable extended thinking")
 			.action(() => {})
 
 		program
@@ -69,9 +67,7 @@ describe("CLI Commands", () => {
 			.option("-v, --verbose", "Verbose output")
 			.option("-c, --cwd <path>", "Working directory")
 			.option("--config <path>", "Configuration directory")
-			.option("--thinking [tokens]", "Enable extended thinking")
-			.option("--reasoning-effort <effort>", "Reasoning effort")
-			.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes")
+			.option("--thinking", "Enable extended thinking")
 			.action(() => {})
 	})
 
@@ -150,27 +146,6 @@ describe("CLI Commands", () => {
 			expect(taskCmd.opts().thinking).toBe(true)
 		})
 
-		it("should parse --thinking with token budget", () => {
-			const taskCmd = program.commands.find((c) => c.name() === "task")!
-			const args = ["test prompt", "--thinking", "8000"]
-			taskCmd.parse(args, { from: "user" })
-			expect(taskCmd.opts().thinking).toBe("8000")
-		})
-
-		it("should parse --reasoning-effort option", () => {
-			const taskCmd = program.commands.find((c) => c.name() === "task")!
-			const args = ["test prompt", "--reasoning-effort", "high"]
-			taskCmd.parse(args, { from: "user" })
-			expect(taskCmd.opts().reasoningEffort).toBe("high")
-		})
-
-		it("should parse --max-consecutive-mistakes option", () => {
-			const taskCmd = program.commands.find((c) => c.name() === "task")!
-			const args = ["test prompt", "--max-consecutive-mistakes", "999"]
-			taskCmd.parse(args, { from: "user" })
-			expect(taskCmd.opts().maxConsecutiveMistakes).toBe("999")
-		})
-
 		it("should parse short flags", () => {
 			const taskCmd = program.commands.find((c) => c.name() === "task")!
 			const args = ["test prompt", "-a", "-v", "-m", "gpt-4"]
@@ -306,21 +281,6 @@ describe("CLI Commands", () => {
 			program.parse(["node", "cli", "--thinking"])
 			expect(program.opts().thinking).toBe(true)
 		})
-
-		it("should parse --thinking with token budget", () => {
-			program.parse(["node", "cli", "--thinking", "4096"])
-			expect(program.opts().thinking).toBe("4096")
-		})
-
-		it("should parse --reasoning-effort option", () => {
-			program.parse(["node", "cli", "--reasoning-effort", "medium"])
-			expect(program.opts().reasoningEffort).toBe("medium")
-		})
-
-		it("should parse --max-consecutive-mistakes option", () => {
-			program.parse(["node", "cli", "--max-consecutive-mistakes", "7"])
-			expect(program.opts().maxConsecutiveMistakes).toBe("7")
-		})
 	})
 
 	describe("command structure", () => {

cli/src/index.ts

@@ -15,14 +15,13 @@ import { HostProvider } from "@/hosts/host-provider"
 import { FileEditProvider } from "@/integrations/editor/FileEditProvider"
 import { openAiCodexOAuthManager } from "@/integrations/openai-codex/oauth"
 import { StandaloneTerminalManager } from "@/integrations/terminal/standalone/StandaloneTerminalManager"
+import { BannerService } from "@/services/banner/BannerService"
 import { ErrorService } from "@/services/error/ErrorService"
+import { initializeDistinctId } from "@/services/logging/distinctId"
 import { telemetryService } from "@/services/telemetry"
-import { PostHogClientProvider } from "@/services/telemetry/providers/posthog/PostHogClientProvider"
-import { HistoryItem } from "@/shared/HistoryItem"
 import { Logger } from "@/shared/services/Logger"
 import { Session } from "@/shared/services/Session"
 import { getProviderModelIdKey, ProviderToApiKeyMap } from "@/shared/storage"
-import { isOpenaiReasoningEffort, OPENAI_REASONING_EFFORT_OPTIONS, type OpenaiReasoningEffort } from "@/shared/storage/types"
 import { version as CLI_VERSION } from "../package.json"
 import { runAcpMode } from "./acp/index.js"
 import { App } from "./components/App"
@@ -32,7 +31,6 @@ import { CliCommentReviewController } from "./controllers/CliCommentReviewContro
 import { CliWebviewProvider } from "./controllers/CliWebviewProvider"
 import { restoreConsole } from "./utils/console"
 import { printInfo, printWarning } from "./utils/display"
-import { selectOutputMode } from "./utils/mode-selection"
 import { parseImagesFromInput, processImagePaths } from "./utils/parser"
 import { CLINE_CLI_DIR, getCliBinaryPath } from "./utils/path"
 import { readStdinIfPiped } from "./utils/piped"
@@ -43,280 +41,11 @@ import { autoUpdateOnStartup, checkForUpdates } from "./utils/update"
 import { initializeCliContext } from "./vscode-context"
 import { CLI_LOG_FILE, shutdownEvent, window } from "./vscode-shim"
 
-/**
- * Common options shared between runTask and resumeTask
- */
-interface TaskOptions {
-	act?: boolean
-	plan?: boolean
-	model?: string
-	verbose?: boolean
-	cwd?: string
-	config?: string
-	thinking?: boolean | string
-	reasoningEffort?: string
-	maxConsecutiveMistakes?: string
-	yolo?: boolean
-	doubleCheckCompletion?: boolean
-	timeout?: string
-	json?: boolean
-	stdinWasPiped?: boolean
-}
-
-let telemetryDisposed = false
-
-async function disposeTelemetryServices(): Promise<void> {
-	if (telemetryDisposed) {
-		return
-	}
-
-	telemetryDisposed = true
-	await Promise.allSettled([telemetryService.dispose(), PostHogClientProvider.getInstance().dispose()])
-}
-
-/**
- * Restore yoloModeToggled to its original value from before this CLI session.
- * This ensures the --yolo flag is session-only and doesn't leak into future runs.
- * Must be called before flushPendingState so the restored value gets persisted.
- */
-function restoreYoloState(): void {
-	if (savedYoloModeToggled !== null) {
-		try {
-			StateManager.get().setGlobalState("yoloModeToggled", savedYoloModeToggled)
-			savedYoloModeToggled = null
-		} catch {
-			// StateManager may not be initialized (e.g., early exit before init)
-		}
-	}
-}
-
-async function disposeCliContext(ctx: CliContext): Promise<void> {
-	restoreYoloState()
-	await ctx.controller.stateManager.flushPendingState()
-	await ctx.controller.dispose()
-	await ErrorService.get().dispose()
-	await disposeTelemetryServices()
-}
-
-function setModeScopedState(currentMode: "act" | "plan", setter: (mode: "act" | "plan") => void): void {
-	const stateManager = StateManager.get()
-	setter(currentMode)
-
-	const separateModels = stateManager.getGlobalSettingsKey("planActSeparateModelsSetting") ?? false
-	if (!separateModels) {
-		const otherMode: "act" | "plan" = currentMode === "act" ? "plan" : "act"
-		setter(otherMode)
-	}
-}
-
-function normalizeReasoningEffort(value?: string): OpenaiReasoningEffort | undefined {
-	if (value === undefined) {
-		return undefined
-	}
-
-	const normalized = value.toLowerCase()
-	if (isOpenaiReasoningEffort(normalized)) {
-		return normalized
-	}
-
-	printWarning(
-		`Invalid --reasoning-effort '${value}'. Using 'medium'. Valid values: ${OPENAI_REASONING_EFFORT_OPTIONS.join(", ")}.`,
-	)
-	return "medium"
-}
-
-function normalizeMaxConsecutiveMistakes(value?: string): number | undefined {
-	if (value === undefined) {
-		return undefined
-	}
-
-	const parsed = Number.parseInt(value, 10)
-	if (Number.isNaN(parsed) || parsed < 1) {
-		printWarning(`Invalid --max-consecutive-mistakes value '${value}'. Expected integer >= 1.`)
-		return undefined
-	}
-
-	return parsed
-}
-
-/**
- * Apply task-related options (mode, model, thinking, yolo) to StateManager.
- * Shared between runTask and resumeTask to avoid duplication.
- */
-function applyTaskOptions(options: TaskOptions): void {
-	// Apply mode flag
-	if (options.plan) {
-		StateManager.get().setGlobalState("mode", "plan")
-		telemetryService.captureHostEvent("mode_flag", "plan")
-	} else if (options.act) {
-		StateManager.get().setGlobalState("mode", "act")
-		telemetryService.captureHostEvent("mode_flag", "act")
-	}
-
-	// Apply model override if specified
-	if (options.model) {
-		const selectedMode = (StateManager.get().getGlobalSettingsKey("mode") || "act") as "act" | "plan"
-		const providerKey = selectedMode === "act" ? "actModeApiProvider" : "planModeApiProvider"
-		const currentProvider = StateManager.get().getGlobalSettingsKey(providerKey) as ApiProvider
-		const modelKey = getProviderModelIdKey(currentProvider, selectedMode)
-		if (modelKey) {
-			StateManager.get().setGlobalState(modelKey, options.model)
-		}
-		telemetryService.captureHostEvent("model_flag", options.model)
-	}
-
-	// Set thinking budget based on --thinking flag (boolean or number)
-	let thinkingBudget = 0
-	if (options.thinking) {
-		if (typeof options.thinking === "string") {
-			const parsed = Number.parseInt(options.thinking, 10)
-			if (Number.isNaN(parsed) || parsed < 0) {
-				printWarning(`Invalid --thinking value '${options.thinking}'. Using default 1024.`)
-				thinkingBudget = 1024
-			} else {
-				thinkingBudget = parsed
-			}
-		} else {
-			thinkingBudget = 1024
-		}
-	}
-	const currentMode = (StateManager.get().getGlobalSettingsKey("mode") || "act") as "act" | "plan"
-	setModeScopedState(currentMode, (mode) => {
-		const thinkingKey = mode === "act" ? "actModeThinkingBudgetTokens" : "planModeThinkingBudgetTokens"
-		StateManager.get().setGlobalState(thinkingKey, thinkingBudget)
-	})
-	if (options.thinking) {
-		telemetryService.captureHostEvent("thinking_flag", "true")
-	}
-
-	const reasoningEffort = normalizeReasoningEffort(options.reasoningEffort)
-	if (reasoningEffort !== undefined) {
-		setModeScopedState(currentMode, (mode) => {
-			const reasoningKey = mode === "act" ? "actModeReasoningEffort" : "planModeReasoningEffort"
-			StateManager.get().setGlobalState(reasoningKey, reasoningEffort)
-		})
-		telemetryService.captureHostEvent("reasoning_effort_flag", reasoningEffort)
-	}
-
-	const maxConsecutiveMistakes = normalizeMaxConsecutiveMistakes(options.maxConsecutiveMistakes)
-	if (maxConsecutiveMistakes !== undefined) {
-		StateManager.get().setGlobalState("maxConsecutiveMistakes", maxConsecutiveMistakes)
-		telemetryService.captureHostEvent("max_consecutive_mistakes_flag", String(maxConsecutiveMistakes))
-	}
-
-	// Override yolo mode only if --yolo flag is explicitly passed.
-	// The original value is saved in initializeCli and restored on exit.
-	if (options.yolo) {
-		const state = StateManager.get()
-		savedYoloModeToggled = state.getGlobalSettingsKey("yoloModeToggled") ?? false
-		state.setGlobalState("yoloModeToggled", true)
-		telemetryService.captureHostEvent("yolo_flag", "true")
-	}
-
-	// Set double-check completion based on flag
-	if (options.doubleCheckCompletion) {
-		StateManager.get().setGlobalState("doubleCheckCompletionEnabled", true)
-		telemetryService.captureHostEvent("double_check_completion_flag", "true")
-	}
-}
-
-/**
- * Get mode selection result using the extracted, testable selectOutputMode function.
- * This wrapper provides the current process TTY state.
- */
-function getModeSelection(options: TaskOptions) {
-	return selectOutputMode({
-		stdoutIsTTY: process.stdout.isTTY === true,
-		stdinIsTTY: process.stdin.isTTY === true,
-		stdinWasPiped: options.stdinWasPiped ?? false,
-		json: options.json,
-		yolo: options.yolo,
-	})
-}
-
-/**
- * Determine if plain text mode should be used based on options and environment.
- */
-function shouldUsePlainTextMode(options: TaskOptions): boolean {
-	return getModeSelection(options).usePlainTextMode
-}
-
-/**
- * Get the reason for using plain text mode (for telemetry).
- */
-function getPlainTextModeReason(options: TaskOptions): string {
-	return getModeSelection(options).reason
-}
-
-/**
- * Run a task in plain text mode (no Ink UI).
- * Handles auth check, task execution, cleanup, and exit.
- */
-async function runTaskInPlainTextMode(
-	ctx: CliContext,
-	options: TaskOptions,
-	taskConfig: {
-		prompt?: string
-		taskId?: string
-		imageDataUrls?: string[]
-	},
-): Promise<never> {
-	// Set flag so shutdown handler knows not to clear Ink UI lines
-	isPlainTextMode = true
-
-	// Check if auth is configured before attempting to run the task
-	// In plain text mode we can't show the interactive auth flow
-	const hasAuth = await isAuthConfigured()
-	if (!hasAuth) {
-		printWarning("Not authenticated. Please run 'cline auth' first to configure your API credentials.")
-		await disposeCliContext(ctx)
-		exit(1)
-	}
-
-	const reason = getPlainTextModeReason(options)
-	telemetryService.captureHostEvent("plain_text_mode", reason)
-
-	// Plain text mode: no Ink rendering, just clean text output
-	const success = await runPlainTextTask({
-		controller: ctx.controller,
-		prompt: taskConfig.prompt,
-		taskId: taskConfig.taskId,
-		imageDataUrls: taskConfig.imageDataUrls,
-		verbose: options.verbose,
-		jsonOutput: options.json,
-		timeoutSeconds: options.timeout ? Number.parseInt(options.timeout, 10) : undefined,
-	})
-
-	// Cleanup
-	await disposeCliContext(ctx)
-
-	// Ensure stdout is fully drained before exiting - critical for piping
-	await drainStdout()
-	exit(success ? 0 : 1)
-}
-
-/**
- * Create the standard cleanup function for Ink apps.
- */
-function createInkCleanup(ctx: CliContext, onTaskError?: () => boolean): () => Promise<void> {
-	return async () => {
-		await disposeCliContext(ctx)
-		if (onTaskError?.()) {
-			printWarning("Task ended with errors.")
-			exit(1)
-		}
-		exit(0)
-	}
-}
-
 // Track active context for graceful shutdown
 let activeContext: CliContext | null = null
 let isShuttingDown = false
 // Track if we're in plain text mode (no Ink UI) - set by runTask when piped stdin detected
 let isPlainTextMode = false
-// Track the original yoloModeToggled value from before this CLI session so we can restore it on exit.
-// The --yolo flag should only affect the current invocation, not persist across runs.
-let savedYoloModeToggled: boolean | null = null
 
 /**
  * Wait for stdout to fully drain before exiting.
@@ -358,26 +87,15 @@ function setupSignalHandlers() {
 		printWarning(`${signal} received, shutting down...`)
 
 		try {
-			// Restore yolo state before any cleanup - this is idempotent and safe
-			// even if disposeCliContext also calls it (restoreYoloState checks savedYoloModeToggled !== null)
-			restoreYoloState()
-
 			if (activeContext) {
 				const task = activeContext.controller.task
 				if (task) {
 					task.abortTask()
 				}
-				await disposeCliContext(activeContext)
-			} else {
-				// Best-effort flush of restored yolo state when no active context
-				try {
-					await StateManager.get().flushPendingState()
-				} catch {
-					// StateManager may not be initialized yet
-				}
-				await ErrorService.get().dispose()
-				await disposeTelemetryServices()
+				await activeContext.controller.stateManager.flushPendingState()
+				await activeContext.controller.dispose()
 			}
+			await ErrorService.get().dispose()
 		} catch {
 			// Best effort cleanup
 		}
@@ -430,17 +148,8 @@ async function initializeCli(options: InitOptions): Promise<CliContext> {
 		workspaceDir: workspacePath,
 	})
 
-	// Set up output channel and Logger early so ClineEndpoint.initialize logs are captured
-	const outputChannel = window.createOutputChannel("Cline CLI")
-	const logToChannel = (message: string) => outputChannel.appendLine(message)
-
-	// Configure the shared Logging class early to capture all initialization logs
-	Logger.subscribe(logToChannel)
-
-	await ClineEndpoint.initialize(EXTENSION_DIR)
-
-	// Auto-update check (after endpoints initialized, so we can detect bundled configs)
-	autoUpdateOnStartup(CLI_VERSION)
+	await ClineEndpoint.initialize()
+	await initializeDistinctId(extensionContext)
 
 	// Initialize/reset session tracking for this CLI run
 	Session.reset()
@@ -449,9 +158,11 @@ async function initializeCli(options: InitOptions): Promise<CliContext> {
 		AuthHandler.getInstance().setEnabled(true)
 	}
 
+	const outputChannel = window.createOutputChannel("Cline CLI")
 	outputChannel.appendLine(
 		`Cline CLI initialized. Data dir: ${DATA_DIR}, Extension dir: ${EXTENSION_DIR}, Log dir: ${CLINE_CLI_DIR.log}`,
 	)
+	const logToChannel = (message: string) => outputChannel.appendLine(message)
 
 	HostProvider.initialize(
 		() => new CliWebviewProvider(extensionContext as any),
@@ -460,24 +171,28 @@ async function initializeCli(options: InitOptions): Promise<CliContext> {
 		() => new StandaloneTerminalManager(),
 		createCliHostBridgeProvider(workspacePath),
 		logToChannel,
-		async (path: string) => (options.enableAuth ? AuthHandler.getInstance().getCallbackUrl(path) : ""),
+		async () => (options.enableAuth ? AuthHandler.getInstance().getCallbackUrl() : ""),
 		getCliBinaryPath,
 		EXTENSION_DIR,
 		DATA_DIR,
 	)
 
 	await StateManager.initialize(extensionContext as any)
-
 	await ErrorService.initialize()
 
 	// Initialize OpenAI Codex OAuth manager with extension context for secrets storage
 	openAiCodexOAuthManager.initialize(extensionContext)
 
+	// Configure the shared Logging class to use HostProvider's output channel
+	Logger.subscribe((msg: string) => HostProvider.get().logToChannel(msg))
+
 	const webview = HostProvider.get().createWebviewProvider() as CliWebviewProvider
 	const controller = webview.controller
 
-	await telemetryService.captureExtensionActivated()
-	await telemetryService.captureHostEvent("cline_cli", "initialized")
+	BannerService.initialize(webview.controller)
+
+	telemetryService.captureExtensionActivated()
+	telemetryService.captureHostEvent("cline_cli", "initialized")
 
 	const ctx = { extensionContext, dataDir: DATA_DIR, extensionDir: EXTENSION_DIR, workspacePath, controller }
 	activeContext = ctx
@@ -513,7 +228,24 @@ async function runInkApp(element: React.ReactElement, cleanup: () => Promise<voi
 /**
  * Run a task with the given prompt - uses welcome view for consistent behavior
  */
-async function runTask(prompt: string, options: TaskOptions & { images?: string[] }, existingContext?: CliContext) {
+async function runTask(
+	prompt: string,
+	options: {
+		act?: boolean
+		plan?: boolean
+		model?: string
+		verbose?: boolean
+		cwd?: string
+		config?: string
+		thinking?: boolean
+		yolo?: boolean
+		timeout?: string
+		images?: string[]
+		json?: boolean
+		stdinWasPiped?: boolean
+	},
+	existingContext?: CliContext,
+) {
 	const ctx = existingContext || (await initializeCli({ ...options, enableAuth: true }))
 
 	// Parse images from the prompt text (e.g., @/path/to/image.png)
@@ -530,23 +262,101 @@ async function runTask(prompt: string, options: TaskOptions & { images?: string[
 	// Task without prompt starts in interactive mode
 	telemetryService.captureHostEvent("task_command", prompt ? "task" : "interactive")
 
-	// Apply shared task options (mode, model, thinking, yolo)
-	applyTaskOptions(options)
-	await StateManager.get().flushPendingState()
-
-	// Use plain text mode when output is redirected, stdin was piped, JSON mode is enabled, or --yolo flag is used
-	if (shouldUsePlainTextMode(options)) {
-		return runTaskInPlainTextMode(ctx, options, {
-			prompt: taskPrompt,
-			imageDataUrls: imageDataUrls.length > 0 ? imageDataUrls : undefined,
-		})
+	if (options.plan) {
+		StateManager.get().setGlobalState("mode", "plan")
+		telemetryService.captureHostEvent("mode_flag", "plan")
+	} else if (options.act) {
+		StateManager.get().setGlobalState("mode", "act")
+		telemetryService.captureHostEvent("mode_flag", "act")
+	}
+
+	if (options.model) {
+		const selectedMode = (StateManager.get().getGlobalSettingsKey("mode") || "act") as "act" | "plan"
+
+		// Get the current provider for the selected mode
+		const providerKey = selectedMode === "act" ? "actModeApiProvider" : "planModeApiProvider"
+		const currentProvider = StateManager.get().getGlobalSettingsKey(providerKey) as ApiProvider
+
+		// Update model ID using provider-specific key (e.g., cline uses actModeOpenRouterModelId)
+		const modelKey = getProviderModelIdKey(currentProvider, selectedMode)
+		if (modelKey) {
+			StateManager.get().setGlobalState(modelKey, options.model)
+		}
+		telemetryService.captureHostEvent("model_flag", options.model)
+	}
+
+	// Set thinking budget based on --thinking flag
+	const thinkingBudget = options.thinking ? 1024 : 0
+	const currentMode = StateManager.get().getGlobalSettingsKey("mode") || "act"
+	const thinkingKey = currentMode === "act" ? "actModeThinkingBudgetTokens" : "planModeThinkingBudgetTokens"
+	StateManager.get().setGlobalState(thinkingKey, thinkingBudget)
+	if (options.thinking) {
+		telemetryService.captureHostEvent("thinking_flag", "true")
+	}
+
+	// Set yolo mode based on --yolo flag
+	if (options.yolo) {
+		StateManager.get().setGlobalState("yoloModeToggled", true)
+		telemetryService.captureHostEvent("yolo_flag", "true")
+	}
+
+	await StateManager.get().flushPendingState()
+
+	// Detect if output is a TTY (interactive terminal) or redirected to a file/pipe
+	const isTTY = process.stdout.isTTY === true
+
+	// Use plain text mode when output is redirected, stdin was piped, JSON mode is enabled, or --yolo flag is used
+	// Ink requires raw mode on stdin which isn't available when stdin is piped
+	// Note: we use the stdinWasPiped flag passed from the caller because process.stdin.isTTY
+	// may not be reliable after stdin has been consumed by readStdinIfPiped()
+	if (!isTTY || options.stdinWasPiped || options.json || options.yolo) {
+		// Set flag so shutdown handler knows not to clear Ink UI lines
+		isPlainTextMode = true
+
+		// Check if auth is configured before attempting to run the task
+		// In plain text mode we can't show the interactive auth flow
+		const hasAuth = await isAuthConfigured()
+		if (!hasAuth) {
+			printWarning("Not authenticated. Please run 'cline auth' first to configure your API credentials.")
+			await ctx.controller.stateManager.flushPendingState()
+			await ctx.controller.dispose()
+			await ErrorService.get().dispose()
+			exit(1)
+		}
+
+		const reason = options.yolo
+			? "yolo_flag"
+			: options.json
+				? "json"
+				: options.stdinWasPiped
+					? "piped_stdin"
+					: "redirected_output"
+		telemetryService.captureHostEvent("plain_text_mode", reason)
+		// Plain text mode: no Ink rendering, just clean text output
+		const success = await runPlainTextTask({
+			controller: ctx.controller,
+			prompt: taskPrompt,
+			imageDataUrls: imageDataUrls.length > 0 ? imageDataUrls : undefined,
+			verbose: options.verbose,
+			jsonOutput: options.json,
+			timeoutSeconds: options.timeout ? parseInt(options.timeout, 10) : undefined,
+		})
+
+		// Cleanup
+		await ctx.controller.stateManager.flushPendingState()
+		await ctx.controller.dispose()
+		await ErrorService.get().dispose()
+
+		// Ensure stdout is fully drained before exiting - critical for piping
+		await drainStdout()
+		exit(success ? 0 : 1)
 	}
 
-	// Interactive mode: Render the welcome view with optional initial prompt/images
-	// If prompt provided (cline task "prompt"), ChatView will auto-submit
-	// If no prompt (cline interactive), user will type it in
 	let taskError = false
 
+	// Render the welcome view with optional initial prompt/images
+	// If prompt provided (cline task "prompt"), ChatView will auto-submit
+	// If no prompt (cline interactive), user will type it in
 	await runInkApp(
 		React.createElement(App, {
 			view: "welcome",
@@ -559,10 +369,20 @@ async function runTask(prompt: string, options: TaskOptions & { images?: string[
 				taskError = true
 			},
 			onWelcomeExit: () => {
-				// User pressed Esc; Ink exits and cleanup handles process exit.
+				// User pressed Esc
+				exit(0)
 			},
 		}),
-		createInkCleanup(ctx, () => taskError),
+		async () => {
+			await ctx.controller.stateManager.flushPendingState()
+			await ctx.controller.dispose()
+			await ErrorService.get().dispose()
+			if (taskError) {
+				printWarning("Task ended with errors.")
+				exit(1)
+			}
+			exit(0)
+		},
 	)
 }
 
@@ -575,8 +395,8 @@ async function listHistory(options: { config?: string; limit?: number; page?: nu
 	const taskHistory = StateManager.get().getGlobalStateKey("taskHistory") || []
 	// Sort by timestamp (newest first) before pagination
 	const sortedHistory = [...taskHistory].sort((a: any, b: any) => (b.ts || 0) - (a.ts || 0))
-	const limit = typeof options.limit === "string" ? Number.parseInt(options.limit, 10) : options.limit || 10
-	const initialPage = typeof options.page === "string" ? Number.parseInt(options.page, 10) : options.page || 1
+	const limit = typeof options.limit === "string" ? parseInt(options.limit, 10) : options.limit || 10
+	const initialPage = typeof options.page === "string" ? parseInt(options.page, 10) : options.page || 1
 	const totalCount = sortedHistory.length
 	const totalPages = Math.ceil(totalCount / limit)
 
@@ -584,7 +404,9 @@ async function listHistory(options: { config?: string; limit?: number; page?: nu
 
 	if (sortedHistory.length === 0) {
 		printInfo("No task history found.")
-		await disposeCliContext(ctx)
+		await ctx.controller.stateManager.flushPendingState()
+		await ctx.controller.dispose()
+		await ErrorService.get().dispose()
 		exit(0)
 	}
 
@@ -598,7 +420,9 @@ async function listHistory(options: { config?: string; limit?: number; page?: nu
 			isRawModeSupported: checkRawModeSupport(),
 		}),
 		async () => {
-			await disposeCliContext(ctx)
+			await ctx.controller.stateManager.flushPendingState()
+			await ctx.controller.dispose()
+			await ErrorService.get().dispose()
 			exit(0)
 		},
 	)
@@ -627,7 +451,9 @@ async function showConfig(options: { config?: string }) {
 			isRawModeSupported: checkRawModeSupport(),
 		}),
 		async () => {
-			await disposeCliContext(ctx)
+			await ctx.controller.stateManager.flushPendingState()
+			await ctx.controller.dispose()
+			await ErrorService.get().dispose()
 			exit(0)
 		},
 	)
@@ -703,15 +529,17 @@ async function runAuth(options: {
 			baseurl: options.baseurl,
 		})
 
+		await ctx.controller.stateManager.flushPendingState()
+		await ctx.controller.dispose()
+		await ErrorService.get().dispose()
+
 		if (!result.success) {
 			printWarning(result.error || "Quick setup failed")
-			await telemetryService.captureHostEvent("auth", "error")
-			await disposeCliContext(ctx)
+			telemetryService.captureHostEvent("auth", "error")
 			exit(1)
 		}
 
-		await telemetryService.captureHostEvent("auth", "completed")
-		await disposeCliContext(ctx)
+		telemetryService.captureHostEvent("auth", "completed")
 		exit(0)
 	}
 
@@ -725,6 +553,7 @@ async function runAuth(options: {
 			isRawModeSupported: checkRawModeSupport(),
 			onComplete: () => {
 				telemetryService.captureHostEvent("auth", "completed")
+				exit(0)
 			},
 			onError: () => {
 				telemetryService.captureHostEvent("auth", "error")
@@ -732,10 +561,16 @@ async function runAuth(options: {
 			},
 		}),
 		async () => {
-			await disposeCliContext(ctx)
-			exit(authError ? 1 : 0)
+			await ctx.controller.stateManager.flushPendingState()
+			await ctx.controller.dispose()
+			await ErrorService.get().dispose()
+			exit(0)
 		},
 	)
+
+	if (authError) {
+		process.exit(1)
+	}
 }
 
 // Setup CLI commands
@@ -759,18 +594,9 @@ program
 	.option("-v, --verbose", "Show verbose output")
 	.option("-c, --cwd <path>", "Working directory for the task")
 	.option("--config <path>", "Path to Cline configuration directory")
-	.option("--thinking [tokens]", "Enable extended thinking (default: 1024 tokens)")
-	.option("--reasoning-effort <effort>", "Reasoning effort: none|low|medium|high|xhigh")
-	.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes before halting in yolo mode")
+	.option("--thinking", "Enable extended thinking (1024 token budget)")
 	.option("--json", "Output messages as JSON instead of styled text")
-	.option("--double-check-completion", "Reject first completion attempt to force re-verification")
-	.option("-T, --taskId <id>", "Resume an existing task by ID")
-	.action((prompt, options) => {
-		if (options.taskId) {
-			return resumeTask(options.taskId, { ...options, initialPrompt: prompt })
-		}
-		return runTask(prompt, options)
-	})
+	.action((prompt, options) => runTask(prompt, options))
 
 program
 	.command("history")
@@ -883,67 +709,6 @@ async function checkAnyProviderConfigured(): Promise<boolean> {
 	return false
 }
 
-/**
- * Validate that a task exists in history
- * @returns The task history item if found, null otherwise
- */
-function findTaskInHistory(taskId: string): HistoryItem | null {
-	const taskHistory = StateManager.get().getGlobalStateKey("taskHistory") || []
-	return taskHistory.find((item) => item.id === taskId) || null
-}
-
-/**
- * Resume an existing task by ID
- * Loads the task and optionally prefills the input with a prompt
- */
-async function resumeTask(taskId: string, options: TaskOptions & { initialPrompt?: string }) {
-	const ctx = await initializeCli({ ...options, enableAuth: true })
-
-	// Validate task exists
-	const historyItem = findTaskInHistory(taskId)
-	if (!historyItem) {
-		printWarning(`Task not found: ${taskId}`)
-		printInfo("Use 'cline history' to see available tasks.")
-		await disposeCliContext(ctx)
-		exit(1)
-	}
-
-	telemetryService.captureHostEvent("resume_task_command", options.initialPrompt ? "with_prompt" : "interactive")
-
-	// Apply shared task options (mode, model, thinking, yolo)
-	applyTaskOptions(options)
-	await StateManager.get().flushPendingState()
-
-	// Use plain text mode for non-interactive scenarios
-	if (shouldUsePlainTextMode(options)) {
-		return runTaskInPlainTextMode(ctx, options, {
-			prompt: options.initialPrompt,
-			taskId: taskId,
-		})
-	}
-
-	// Interactive mode: render the task view with the existing task
-	let taskError = false
-
-	await runInkApp(
-		React.createElement(App, {
-			view: "task",
-			taskId: taskId,
-			verbose: options.verbose,
-			controller: ctx.controller,
-			isRawModeSupported: checkRawModeSupport(),
-			initialPrompt: options.initialPrompt || undefined,
-			onError: () => {
-				taskError = true
-			},
-			onWelcomeExit: () => {
-				// User pressed Esc; Ink exits and cleanup handles process exit.
-			},
-		}),
-		createInkCleanup(ctx, () => taskError),
-	)
-}
-
 /**
  * Show welcome prompt and wait for user input
  * If auth is not configured, show auth flow first
@@ -964,14 +729,16 @@ async function showWelcome(options: { verbose?: boolean; cwd?: string; config?:
 			controller: ctx.controller,
 			isRawModeSupported: checkRawModeSupport(),
 			onWelcomeExit: () => {
-				// User pressed Esc; Ink exits and cleanup handles process exit.
+				exit(0)
 			},
 			onError: () => {
 				hadError = true
 			},
 		}),
 		async () => {
-			await disposeCliContext(ctx)
+			await ctx.controller.stateManager.flushPendingState()
+			await ctx.controller.dispose()
+			await ErrorService.get().dispose()
 			exit(hadError ? 1 : 0)
 		},
 	)
@@ -988,13 +755,9 @@ program
 	.option("-v, --verbose", "Show verbose output")
 	.option("-c, --cwd <path>", "Working directory")
 	.option("--config <path>", "Configuration directory")
-	.option("--thinking [tokens]", "Enable extended thinking (default: 1024 tokens)")
-	.option("--reasoning-effort <effort>", "Reasoning effort: none|low|medium|high|xhigh")
-	.option("--max-consecutive-mistakes <count>", "Maximum consecutive mistakes before halting in yolo mode")
+	.option("--thinking", "Enable extended thinking (1024 token budget)")
 	.option("--json", "Output messages as JSON instead of styled text")
-	.option("--double-check-completion", "Reject first completion attempt to force re-verification")
 	.option("--acp", "Run in ACP (Agent Client Protocol) mode for editor integration")
-	.option("-T, --taskId <id>", "Resume an existing task by ID")
 	.action(async (prompt, options) => {
 		// Check for ACP mode first - this takes precedence over everything else
 		if (options.acp) {
@@ -1009,18 +772,8 @@ program
 		// Always check for piped stdin content
 		const stdinInput = await readStdinIfPiped()
 
-		// Track whether stdin was actually piped (even if empty) vs not piped (null)
-		// stdinInput === null means stdin wasn't piped (TTY or not FIFO/file)
-		// stdinInput === "" means stdin was piped but empty
-		// stdinInput has content means stdin was piped with data
-		const stdinWasPiped = stdinInput !== null
-
-		// Error if stdin was piped but empty AND no prompt was provided
-		// This handles:
-		// - `echo "" | cline` -> error (empty stdin, no prompt)
-		// - `cline "prompt"` in GitHub Actions -> OK (empty stdin ignored, has prompt)
-		// - `cat file | cline "explain"` -> OK (has stdin AND prompt)
-		if (stdinInput === "" && !prompt) {
+		// Error if stdin was piped but empty (e.g., `echo "" | cline`)
+		if (stdinInput === "") {
 			printWarning("Empty input received from stdin. Please provide content to process.")
 			exit(1)
 		}
@@ -1043,24 +796,17 @@ program
 			}
 		}
 
-		// Handle --taskId flag to resume an existing task
-		if (options.taskId) {
-			await resumeTask(options.taskId, {
-				...options,
-				initialPrompt: effectivePrompt,
-				stdinWasPiped,
-			})
-			return
-		}
-
 		if (effectivePrompt) {
 			// Pass stdinWasPiped flag so runTask knows to use plain text mode
-			await runTask(effectivePrompt, { ...options, stdinWasPiped })
+			await runTask(effectivePrompt, { ...options, stdinWasPiped: !!stdinInput })
 		} else {
 			// Show welcome prompt if no prompt given
 			await showWelcome(options)
 		}
 	})
 
+// Background auto-update check (non-blocking)
+autoUpdateOnStartup(CLI_VERSION)
+
 // Parse and run
 program.parse()

cli/src/utils/browser.ts

@@ -1,10 +0,0 @@
-/**
- * Opens a URL in the user's default browser.
- * Uses dynamic import of the 'open' package to open URLs.
- *
- * @param url - The URL to open in the browser
- */
-export async function openUrlInBrowser(url: string): Promise<void> {
-	const { default: open } = await import("open")
-	await open(url)
-}

cli/src/utils/mode-selection.test.ts

@@ -1,194 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { selectOutputMode } from "./mode-selection"
-
-describe("selectOutputMode", () => {
-	describe("interactive mode (Ink)", () => {
-		it("should use interactive mode when both stdin and stdout are TTY", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(false)
-			expect(result.reason).toBe("interactive")
-		})
-	})
-
-	describe("yolo flag", () => {
-		it("should use plain text mode when --yolo flag is set", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-				yolo: true,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("yolo_flag")
-		})
-
-		it("should prioritize yolo over other flags", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: false,
-				stdinIsTTY: false,
-				stdinWasPiped: true,
-				json: true,
-				yolo: true,
-			})
-			expect(result.reason).toBe("yolo_flag")
-		})
-	})
-
-	describe("json flag", () => {
-		it("should use plain text mode when --json flag is set", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-				json: true,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("json")
-		})
-	})
-
-	describe("piped stdin", () => {
-		it("should use plain text mode when stdin was piped (echo x | cline)", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: false, // piped stdin is not a TTY
-				stdinWasPiped: true,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("piped_stdin")
-		})
-
-		it("should use plain text mode when stdin was piped but empty (echo '' | cline 'prompt')", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: false,
-				stdinWasPiped: true, // empty pipe still counts as piped
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("piped_stdin")
-		})
-	})
-
-	describe("stdin redirected (< /dev/null)", () => {
-		it("should use plain text mode when stdin is redirected from /dev/null", () => {
-			// cline "prompt" < /dev/null
-			// stdin is not a TTY, but also not a FIFO/file, so stdinWasPiped=false
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: false, // redirected, not a TTY
-				stdinWasPiped: false, // /dev/null is a character device, not FIFO
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("stdin_redirected")
-		})
-	})
-
-	describe("stdout redirected", () => {
-		it("should use plain text mode when stdout is redirected to file", () => {
-			// cline "prompt" > output.txt
-			const result = selectOutputMode({
-				stdoutIsTTY: false,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("stdout_redirected")
-		})
-
-		it("should use plain text mode when stdout is piped", () => {
-			// cline "prompt" | grep something
-			const result = selectOutputMode({
-				stdoutIsTTY: false,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("stdout_redirected")
-		})
-	})
-
-	describe("GitHub Actions scenarios", () => {
-		it("should use plain text mode in GitHub Actions (stdin is empty FIFO)", () => {
-			// In GitHub Actions: stdin is an empty FIFO pipe
-			// stdinIsTTY=false, stdinWasPiped=true (FIFO detected)
-			const result = selectOutputMode({
-				stdoutIsTTY: true, // GitHub Actions stdout is TTY-like
-				stdinIsTTY: false,
-				stdinWasPiped: true, // empty FIFO still counts as piped
-			})
-			expect(result.usePlainTextMode).toBe(true)
-		})
-
-		it("should use plain text mode with --yolo in CI", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: false,
-				stdinIsTTY: false,
-				stdinWasPiped: false,
-				yolo: true,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-			expect(result.reason).toBe("yolo_flag")
-		})
-	})
-
-	describe("real-world scenarios", () => {
-		it("cline (no args, interactive terminal)", () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(false)
-		})
-
-		it('cline "prompt" (prompt arg, interactive terminal)', () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(false)
-		})
-
-		it('cat file | cline "explain"', () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: false,
-				stdinWasPiped: true,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-		})
-
-		it('cline --yolo "prompt"', () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-				yolo: true,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-		})
-
-		it('cline "prompt" < /dev/null', () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: true,
-				stdinIsTTY: false,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-		})
-
-		it('cline "prompt" > output.log', () => {
-			const result = selectOutputMode({
-				stdoutIsTTY: false,
-				stdinIsTTY: true,
-				stdinWasPiped: false,
-			})
-			expect(result.usePlainTextMode).toBe(true)
-		})
-	})
-})

cli/src/utils/mode-selection.ts

@@ -1,63 +0,0 @@
-/**
- * Mode selection logic for CLI - determines whether to use Ink (interactive) or plain text mode
- *
- * This is extracted as a pure function for testability. The decision tree:
- * - Plain text mode when output is redirected (stdout not TTY)
- * - Plain text mode when input is redirected (stdin not TTY) - Ink requires raw mode
- * - Plain text mode when stdin was piped (e.g., echo "x" | cline)
- * - Plain text mode when --json flag is used
- * - Plain text mode when --yolo flag is used
- * - Otherwise: Interactive Ink mode
- */
-
-export interface ModeSelectionInput {
-	/** Is stdout connected to a TTY (interactive terminal)? */
-	stdoutIsTTY: boolean
-	/** Is stdin connected to a TTY (interactive terminal)? */
-	stdinIsTTY: boolean
-	/** Was stdin piped (FIFO or file), even if empty? */
-	stdinWasPiped: boolean
-	/** --json flag for machine-readable output */
-	json?: boolean
-	/** --yolo flag for auto-approve mode */
-	yolo?: boolean
-}
-
-export interface ModeSelectionResult {
-	/** Use plain text mode instead of Ink */
-	usePlainTextMode: boolean
-	/** Reason for the mode selection (for telemetry/debugging) */
-	reason: "interactive" | "yolo_flag" | "json" | "piped_stdin" | "stdin_redirected" | "stdout_redirected"
-}
-
-/**
- * Determine whether to use plain text mode or interactive Ink mode
- *
- * @param input - Environment and option flags
- * @returns Mode selection result with reason
- */
-export function selectOutputMode(input: ModeSelectionInput): ModeSelectionResult {
-	// Priority order matters - check most specific flags first
-
-	if (input.yolo) {
-		return { usePlainTextMode: true, reason: "yolo_flag" }
-	}
-
-	if (input.json) {
-		return { usePlainTextMode: true, reason: "json" }
-	}
-
-	if (input.stdinWasPiped) {
-		return { usePlainTextMode: true, reason: "piped_stdin" }
-	}
-
-	if (!input.stdinIsTTY) {
-		return { usePlainTextMode: true, reason: "stdin_redirected" }
-	}
-
-	if (!input.stdoutIsTTY) {
-		return { usePlainTextMode: true, reason: "stdout_redirected" }
-	}
-
-	return { usePlainTextMode: false, reason: "interactive" }
-}

cli/src/utils/plain-text-task.test.ts

@@ -1,28 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest"
-import { emitTaskStartedMessage } from "./task-start-output"
-
-describe("emitTaskStartedMessage", () => {
-	afterEach(() => {
-		vi.restoreAllMocks()
-	})
-
-	it("writes structured task_started JSON to stdout in json mode", () => {
-		const stdoutWriteSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true)
-		const stderrWriteSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true)
-
-		emitTaskStartedMessage("task-123", true)
-
-		expect(stdoutWriteSpy).toHaveBeenCalledWith('{"type":"task_started","taskId":"task-123"}\n')
-		expect(stderrWriteSpy).not.toHaveBeenCalled()
-	})
-
-	it("writes human-readable task started line to stderr in non-json mode", () => {
-		const stdoutWriteSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true)
-		const stderrWriteSpy = vi.spyOn(process.stderr, "write").mockImplementation(() => true)
-
-		emitTaskStartedMessage("task-456", false)
-
-		expect(stderrWriteSpy).toHaveBeenCalledWith("Task started: task-456\n")
-		expect(stdoutWriteSpy).not.toHaveBeenCalled()
-	})
-})

cli/src/utils/plain-text-task.ts

@@ -12,24 +12,18 @@
 // Console output is intentional here for plain text mode
 
 import type { ClineMessage, ExtensionState } from "@shared/ExtensionMessage"
-import { StringRequest } from "@shared/proto/cline/common"
 import type { Controller } from "@/core/controller"
 import { getRequestRegistry } from "@/core/controller/grpc-handler"
 import { subscribeToState } from "@/core/controller/state/subscribeToState"
-import { showTaskWithId } from "@/core/controller/task/showTaskWithId"
-import { emitTaskStartedMessage } from "./task-start-output"
 
 export interface PlainTextTaskOptions {
 	controller: Controller
-	/** Prompt for new task or message to send to resumed task */
-	prompt?: string
+	prompt: string
 	imageDataUrls?: string[]
 	verbose?: boolean
 	jsonOutput?: boolean
 	/** Timeout in seconds (default: 600 = 10 minutes) */
 	timeoutSeconds?: number
-	/** Task ID to resume an existing task */
-	taskId?: string
 }
 
 /**
@@ -45,39 +39,17 @@ export interface PlainTextTaskOptions {
 export async function runPlainTextTask(options: PlainTextTaskOptions): Promise<boolean> {
 	const { controller, prompt, imageDataUrls, verbose, jsonOutput } = options
 
-	let completionResolve: (reason?: any) => void
+	let completionResolve: () => void
 	let completionReject: (reason?: any) => void
-	const completionPromise = new Promise<string>((res, rej) => {
+	const completionPromise = new Promise<void>((res, rej) => {
 		completionResolve = res
 		completionReject = rej
 	})
 
 	let hasError = false
-	let hasEmittedTaskStarted = false
 	// Track which messages have been processed (by timestamp)
 	const processedMessages = new Map<number, string>()
 
-	const isViewTaskOnly = Boolean(options.taskId) && !prompt
-
-	// When resuming a task, we need to ignore completion_result messages that existed
-	// before we sent our new prompt. This timestamp marks the cutoff - only completion
-	// results AFTER this time should trigger task completion.
-	const completionCutoffTs = Date.now()
-
-	const emitTaskStarted = () => {
-		if (hasEmittedTaskStarted) {
-			return
-		}
-
-		const taskId = controller.task?.taskId
-		if (!taskId) {
-			return
-		}
-
-		emitTaskStartedMessage(taskId, Boolean(jsonOutput))
-		hasEmittedTaskStarted = true
-	}
-
 	// Helper to process a message and track completion state
 	const processMessage = (message: ClineMessage) => {
 		const ts = message.ts || 0
@@ -95,12 +67,8 @@ export async function runPlainTextTask(options: PlainTextTaskOptions): Promise<b
 		processedMessages.set(ts, message.text ?? "")
 
 		// Check for completion (only on non-partial messages)
-		// When resuming a task, only consider completion_result messages that appeared
-		// AFTER we sent our resume message (ts > completionCutoffTs)
 		if (message.say === "completion_result" || message.ask === "completion_result") {
-			if (isViewTaskOnly || ts > completionCutoffTs) {
-				completionResolve()
-			}
+			completionResolve()
 		} else if (message.say === "error" || message.ask === "api_req_failed") {
 			completionReject(message.text ?? "message.say error || message.ask api_req_failed")
 		}
@@ -131,29 +99,8 @@ export async function runPlainTextTask(options: PlainTextTaskOptions): Promise<b
 	)
 
 	try {
-		// Either resume an existing task or start a new one
-		if (options.taskId) {
-			// Load the existing task
-			await showTaskWithId(controller, StringRequest.create({ value: options.taskId }))
-			emitTaskStarted()
-
-			// If a prompt was provided, send it as a message to the resumed task
-			if (prompt && controller.task) {
-				// Wait a moment for the task to fully load
-				await new Promise((resolve) => setTimeout(resolve, 100))
-
-				// Send the prompt as a response to any pending ask, or as a new message
-				await controller.task.handleWebviewAskResponse("messageResponse", prompt)
-			}
-		} else if (prompt) {
-			// Start a new task with the prompt
-			await controller.initTask(prompt, imageDataUrls)
-			emitTaskStarted()
-		} else {
-			throw new Error("Either taskId or prompt must be provided")
-		}
-
-		// Normal mode: wait for task completion
+		// Start the task
+		await controller.initTask(prompt, imageDataUrls)
 		const timeoutMs = (options.timeoutSeconds ?? 600) * 1000 // default 10 minutes
 		const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), timeoutMs))
 		await Promise.race([completionPromise, timeoutPromise])

cli/src/utils/providers.ts

@@ -3,10 +3,7 @@
  * Used by both UI components and CLI commands
  */
 
-import { useMemo } from "react"
-import { StateManager } from "@/core/storage/StateManager"
 import providersData from "@/shared/providers/providers.json"
-import type { RemoteConfigFields } from "@/shared/storage/state-keys"
 
 // Create a lookup map from provider value to display label
 const providerLabels: Record<string, string> = Object.fromEntries(
@@ -20,7 +17,7 @@ const providerOrder: string[] = providersData.list.map((p: { value: string }) =>
  * Providers that are not supported in CLI.
  * - vscode-lm: Requires VS Code's Language Model API (see ENG-1490 for OAuth-based support)
  */
-const CLI_EXCLUDED_PROVIDERS = new Set<string>(["vscode-lm"])
+export const CLI_EXCLUDED_PROVIDERS = new Set<string>(["vscode-lm"])
 
 /**
  * Get the display label for a provider ID
@@ -32,7 +29,7 @@ export function getProviderLabel(providerId: string): string {
 /**
  * Get the ordered list of all provider IDs (from providers.json)
  */
-function getProviderOrder(): string[] {
+export function getProviderOrder(): string[] {
 	return providerOrder
 }
 
@@ -49,19 +46,3 @@ export function getValidCliProviders(): string[] {
 export function isValidCliProvider(providerId: string): boolean {
 	return providerOrder.includes(providerId) && !CLI_EXCLUDED_PROVIDERS.has(providerId)
 }
-
-const getValidProviders = (remoteConfig: Partial<RemoteConfigFields> | undefined) => {
-	if (remoteConfig?.remoteConfiguredProviders?.length) {
-		return remoteConfig.remoteConfiguredProviders
-	}
-
-	return getProviderOrder().filter((p: string) => !CLI_EXCLUDED_PROVIDERS.has(p))
-}
-
-export const useValidProviders = () => {
-	const remoteConfig = StateManager.get().getRemoteConfigSettings()
-
-	return useMemo(() => {
-		return getValidProviders(remoteConfig)
-	}, [remoteConfig])
-}

cli/src/utils/task-start-output.ts

@@ -1,8 +0,0 @@
-export function emitTaskStartedMessage(taskId: string, jsonOutput: boolean): void {
-	if (jsonOutput) {
-		process.stdout.write(JSON.stringify({ type: "task_started", taskId }) + "\n")
-		return
-	}
-
-	process.stderr.write(`Task started: ${taskId}\n`)
-}

cli/src/utils/timeout.ts

@@ -1,36 +0,0 @@
-/**
- * Wait for a condition to become truthy, with a timeout.
- * Uses Promise.race for clean timeout handling instead of polling.
- *
- * @param condition - Function that returns the value to check (truthy = done)
- * @param timeoutMs - Maximum time to wait in milliseconds
- * @param pollIntervalMs - How often to check the condition (default: 100ms)
- * @returns The truthy value if condition is met, or undefined if timeout
- */
-export async function waitFor<T>(
-	condition: () => T | undefined | null,
-	timeoutMs: number,
-	pollIntervalMs: number = 100,
-): Promise<T | undefined> {
-	// Check immediately first
-	const immediate = condition()
-	if (immediate) {
-		return immediate
-	}
-
-	return new Promise((resolve) => {
-		const intervalId = setInterval(() => {
-			const result = condition()
-			if (result) {
-				clearInterval(intervalId)
-				clearTimeout(timeoutId)
-				resolve(result)
-			}
-		}, pollIntervalMs)
-
-		const timeoutId = setTimeout(() => {
-			clearInterval(intervalId)
-			resolve(undefined)
-		}, timeoutMs)
-	})
-}

cli/src/utils/update.ts

@@ -1,7 +1,6 @@
 import { spawn } from "node:child_process"
 import { realpathSync } from "node:fs"
 import { exit } from "node:process"
-import { ClineEndpoint } from "@/config"
 import { fetch } from "@/shared/net"
 import { printInfo, printWarning } from "./display"
 
@@ -108,7 +107,7 @@ async function getLatestVersion(currentVersion: string): Promise<string | null>
  * process to install if a newer version is available.
  *
  * Supports npm, pnpm, yarn, and bun global installs.
- * Skipped for npx, local dev, unknown installations, and bundled enterprise packages.
+ * Skipped for npx, local dev, and unknown installations.
  * Can be disabled with CLINE_NO_AUTO_UPDATE=1 environment variable.
  */
 export function autoUpdateOnStartup(currentVersion: string): void {
@@ -122,11 +121,6 @@ export function autoUpdateOnStartup(currentVersion: string): void {
 		return
 	}
 
-	// Skip if using bundled enterprise config (single source of truth)
-	if (ClineEndpoint.isBundledConfig()) {
-		return
-	}
-
 	const { updateCommand } = getInstallationInfo(currentVersion)
 	if (!updateCommand) {
 		return

cli/src/vscode-context.ts

@@ -4,7 +4,6 @@
  */
 
 import { mkdirSync } from "node:fs"
-import { fileURLToPath } from "node:url"
 import os from "os"
 import path from "path"
 import { ExtensionRegistryInfo } from "@/registry"
@@ -12,10 +11,6 @@ import { ClineExtensionContext } from "@/shared/cline"
 import { ClineFileStorage } from "@/shared/storage"
 import { EnvironmentVariableCollection, ExtensionKind, ExtensionMode, readJson, URI } from "./vscode-shim"
 
-// ES module equivalent of __dirname
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
 const SETTINGS_SUBFOLDER = "data"
 
 /**
@@ -145,8 +140,8 @@ export function initializeCliContext(config: CliContextConfig = {}): CliContextR
 	mkdirSync(DATA_DIR, { recursive: true })
 	mkdirSync(WORKSPACE_STORAGE_DIR, { recursive: true })
 
-	// For CLI, extension dir is the package root (one level up from dist/)
-	const EXTENSION_DIR = path.resolve(__dirname, "..")
+	// For CLI, extension dir is the root of the project (parent of cli)
+	const EXTENSION_DIR = path.resolve(__dirname, "..", "..")
 	const EXTENSION_MODE = process.env.IS_DEV === "true" ? ExtensionMode.Development : ExtensionMode.Production
 
 	const extension: ClineExtensionContext["extension"] = {

cli/vitest.config.ts

@@ -13,7 +13,6 @@ export default defineConfig({
 	},
 	resolve: {
 		alias: {
-			vscode: path.resolve(__dirname, "src/vscode-shim.ts"),
 			// Match tsconfig paths - baseUrl is parent directory
 			"@": path.resolve(__dirname, "../src"),
 			"@api": path.resolve(__dirname, "../src/core/api"),

docs/cline-cli/installation.mdx

@@ -22,7 +22,7 @@ If you need to install or update Node.js, visit [nodejs.org](https://nodejs.org)
 Install globally via npm:
 
 ```bash
-npm install -g cline
+bun install -g cline
 ```
 
 Verify the installation:
@@ -32,7 +32,7 @@ cline version
 ```
 
 <Tip>
-To install a specific version, use `npm install -g cline@2.0.0`. Check [npm](https://www.npmjs.com/package/cline) for available versions.
+To install a specific version, use `bun install -g cline@2.0.0`. Check [npm](https://www.npmjs.com/package/cline) for available versions.
 </Tip>
 
 ## Authenticate
@@ -186,7 +186,7 @@ cline update
 Or update manually via npm:
 
 ```bash
-npm update -g cline
+bun update -g cline
 ```
 
 ## Troubleshooting
@@ -195,14 +195,14 @@ npm update -g cline
 
 If `cline` is not found after installation:
 
-1. Ensure npm global bin is in your PATH:
+1. Ensure bun global bin is in your PATH:
    ```bash
-   npm bin -g
+   bun bin -g
    ```
 
 2. Add the path to your shell configuration (`.bashrc`, `.zshrc`, etc.):
    ```bash
-   export PATH="$PATH:$(npm bin -g)"
+   export PATH="$PATH:$(bun bin -g)"
    ```
 
 3. Restart your terminal or source your shell config.
@@ -215,7 +215,7 @@ If you get permission errors during installation:
 # Option 1: Use a Node version manager (recommended)
 # nvm, fnm, or volta handle permissions automatically
 
-# Option 2: Fix npm permissions
+# Option 2: Fix bun permissions
 # See: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally
 ```
 
@@ -244,7 +244,7 @@ If your API key is rejected:
 To remove Cline CLI:
 
 ```bash
-npm uninstall -g cline
+bun uninstall -g cline
 ```
 
 To also remove configuration data:

docs/docs.json

@@ -164,7 +164,6 @@
 							"features/multiroot-workspace",
 							"features/plan-and-act",
 							"features/skills",
-							"features/subagents",
 							{
 								"group": "Slash Commands",
 								"pages": [

docs/enterprise-solutions/bundled-endpoints.mdx

@@ -1,287 +0,0 @@
----
-title: "Bundled Endpoints Configuration"
-description: "Enterprise guide for distributing Cline with pre-configured endpoints"
----
-
-# Bundled Endpoints Configuration
-
-This guide explains how enterprise customers can distribute Cline with pre-configured endpoints bundled directly into the installation packages.
-
-## Overview
-
-Cline supports bundling custom endpoint configurations directly into distribution packages (VSIX, NPM, or JetBrains). This eliminates the need for end users to manually configure endpoints, ensuring consistent configuration across your organization.
-
-### Configuration Priority
-
-When Cline starts, it checks for endpoints configuration in this order:
-
-1. **Bundled endpoints.json** (in extension installation directory) - Highest priority
-2. **User endpoints.json** (`~/.cline/endpoints.json`) - Fallback
-3. **Built-in endpoints** (standard Cline URLs) - Default
-
-When a bundled `endpoints.json` is found, Cline automatically switches to self-hosted mode and uses those endpoints exclusively.
-
-## Prerequisites
-
-- Official Cline release package (VSIX, TGZ, or ZIP)
-- Your `endpoints.json` configuration file
-- `jq` command-line tool (for JSON validation)
-- `unzip`, `zip`, `tar` utilities
-
-## Creating endpoints.json
-
-Create a JSON file with your organization's endpoints:
-
-```json
-{
-  "appBaseUrl": "https://cline.yourcompany.com",
-  "apiBaseUrl": "https://api-cline.yourcompany.com",
-  "mcpBaseUrl": "https://api-cline.yourcompany.com/v1/mcp"
-}
-```
-
-### Required Fields
-
-All three fields are required and must be valid URLs:
-
-- **appBaseUrl**: Web application base URL
-- **apiBaseUrl**: API server base URL  
-- **mcpBaseUrl**: MCP (Model Context Protocol) server URL
-
-### Validation
-
-The packaging scripts automatically validate:
-- Valid JSON syntax
-- All required fields present
-- Non-empty string values
-- Valid URL format (must start with `http://` or `https://`)
-
-## Packaging Scripts
-
-Cline provides three scripts for adding bundled endpoints to packages:
-
-### VSCode Extension (VSIX)
-
-```bash
-./scripts/add-endpoints-to-vsix.sh \
-  cline-3.55.0.vsix \
-  cline-3.55.0-enterprise.vsix \
-  endpoints.json
-```
-
-This script:
-1. Extracts the VSIX package
-2. Adds `endpoints.json` to the `extension/` directory
-3. Repackages as a new VSIX file
-
-### NPM Package (CLI)
-
-```bash
-./scripts/add-endpoints-to-npm.sh \
-  cline-3.55.0.tgz \
-  cline-3.55.0-enterprise.tgz \
-  endpoints.json
-```
-
-This script:
-1. Extracts the NPM tarball
-2. Adds `endpoints.json` to the package root
-3. Repackages as a new tarball
-
-### JetBrains Plugin (ZIP)
-
-```bash
-./scripts/add-endpoints-to-jetbrains.sh \
-  cline-jetbrains-3.55.0.zip \
-  cline-jetbrains-3.55.0-enterprise.zip \
-  endpoints.json
-```
-
-This script:
-1. Extracts the ZIP package
-2. Adds `endpoints.json` to the plugin directory
-3. Repackages as a new ZIP file
-
-## Distribution Workflow
-
-### 1. Download Official Release
-
-Download the official Cline package for your platform:
-
-```bash
-# VSCode - from marketplace or GitHub releases
-curl -LO https://github.com/cline/cline/releases/download/v3.55.0/cline-3.55.0.vsix
-
-# NPM - from npm registry
-npm pack @cline/cline@3.55.0
-
-# JetBrains - from marketplace or GitHub releases
-curl -LO https://github.com/cline/cline/releases/download/v3.55.0/cline-jetbrains-3.55.0.zip
-```
-
-### 2. Create Endpoints Configuration
-
-Create your `endpoints.json` file:
-
-```json
-{
-  "appBaseUrl": "https://cline.internal.company.com",
-  "apiBaseUrl": "https://cline-api.internal.company.com",
-  "mcpBaseUrl": "https://cline-api.internal.company.com/v1/mcp"
-}
-```
-
-### 3. Run Packaging Script
-
-Choose the appropriate script for your platform:
-
-```bash
-# VSCode
-./scripts/add-endpoints-to-vsix.sh \
-  cline-3.55.0.vsix \
-  cline-3.55.0-yourcompany.vsix \
-  endpoints.json
-
-# CLI
-./scripts/add-endpoints-to-npm.sh \
-  cline-3.55.0.tgz \
-  cline-3.55.0-yourcompany.tgz \
-  endpoints.json
-
-# JetBrains
-./scripts/add-endpoints-to-jetbrains.sh \
-  cline-jetbrains-3.55.0.zip \
-  cline-jetbrains-3.55.0-yourcompany.zip \
-  endpoints.json
-```
-
-### 4. Distribute to Users
-
-Distribute the enterprise package to your users through your internal channels:
-
-- **VSCode**: Install via `code --install-extension cline-3.55.0-yourcompany.vsix`
-- **CLI**: Install via `npm install -g cline-3.55.0-yourcompany.tgz`
-- **JetBrains**: Install through IDE plugin manager from disk
-
-## Verification
-
-After installation, verify the configuration is active:
-
-1. Launch Cline
-2. Check the logs for: `"Cline running in self-hosted mode with custom endpoints"`
-3. Confirm that environment switching is disabled (as expected in self-hosted mode)
-
-## User Experience
-
-### What Users See
-
-- Cline automatically uses the bundled endpoints
-- No manual configuration required
-- Environment switching is disabled (prevents accidental misconfiguration)
-- All API calls route to your organization's infrastructure
-
-### User Override
-
-Users **cannot** override bundled endpoints through the UI. The bundled configuration takes absolute precedence. This ensures:
-- Consistent configuration across the organization
-- No accidental connections to external services
-- Simplified deployment and support
-
-If users have a `~/.cline/endpoints.json` file, it will be ignored when bundled configuration is present.
-
-## Troubleshooting
-
-### Invalid Configuration Error
-
-If users see an error about invalid configuration on startup:
-
-```
-ClineConfigurationError: Invalid JSON in bundled endpoints configuration file
-```
-
-**Solution**: The bundled `endpoints.json` is malformed. Repackage with a valid JSON file.
-
-### Missing Required Field Error
-
-```
-ClineConfigurationError: Missing required field "apiBaseUrl" in endpoints configuration file
-```
-
-**Solution**: Ensure all three required fields are present in `endpoints.json`.
-
-### Invalid URL Error
-
-```
-ClineConfigurationError: Field "appBaseUrl" must be a valid URL. Got: "not-a-url"
-```
-
-**Solution**: All URLs must start with `http://` or `https://`.
-
-## Security Considerations
-
-1. **Bundle Validation**: The packaging scripts validate JSON structure and required fields
-2. **Read-Only Configuration**: Users cannot modify bundled endpoints through the UI
-3. **Self-Hosted Mode**: Automatic switch to self-hosted mode prevents external connections
-4. **Audit Trail**: All endpoint access is logged with configuration source
-
-## Updating Endpoints
-
-To update endpoints for existing installations:
-
-1. Create updated `endpoints.json`
-2. Repackage the same Cline version with new endpoints
-3. Distribute updated package
-4. Users reinstall/update the package
-
-The version number remains the same since only configuration changed, not the Cline code.
-
-## Support
-
-For questions or issues with bundled endpoints:
-
-1. Verify your `endpoints.json` is valid JSON with all required fields
-2. Check that URLs are accessible from user networks
-3. Review Cline logs for configuration loading messages
-4. Contact your Cline support representative for assistance
-
-## Example: Complete Workflow
-
-Here's a complete example for VSCode deployment:
-
-```bash
-# 1. Download official release
-curl -LO https://github.com/cline/cline/releases/download/v3.55.0/cline-3.55.0.vsix
-
-# 2. Create endpoints configuration
-cat > endpoints.json << 'EOF'
-{
-  "appBaseUrl": "https://cline.acme.internal",
-  "apiBaseUrl": "https://cline-api.acme.internal",
-  "mcpBaseUrl": "https://cline-api.acme.internal/v1/mcp"
-}
-EOF
-
-# 3. Validate JSON
-jq empty endpoints.json  # Should succeed silently
-
-# 4. Run packaging script
-./scripts/add-endpoints-to-vsix.sh \
-  cline-3.55.0.vsix \
-  cline-3.55.0-acme.vsix \
-  endpoints.json
-
-# 5. Verify output
-unzip -l cline-3.55.0-acme.vsix | grep endpoints.json
-# Should show: extension/endpoints.json
-
-# 6. Test installation (on test machine)
-code --install-extension cline-3.55.0-acme.vsix
-
-# 7. Distribute to organization
-# Upload to internal package repository
-# or distribute via configuration management system
-```
-
-## Changelog
-
-- **v3.55.0**: Initial release of bundled endpoints support

docs/features/skills.mdx

@@ -62,16 +62,15 @@ The description is critical because it's how Cline decides whether to activate a
 Skills can be stored in two locations:
 
 **Global Skills** apply to all your projects:
-- **macOS/Linux:** `~/.agents/skills/` (recommended) or `~/.cline/skills/`
-- **Windows:** `C:\Users\USERNAME\.agents\skills\` (recommended) or `C:\Users\USERNAME\.cline\skills\`
+- **macOS/Linux:** `~/.cline/skills/`
+- **Windows:** `C:\Users\USERNAME\.cline\skills\`
 
 **Project Skills** apply only to the current workspace:
-- `.agents/skills/` (recommended)
-- `.cline/skills/`
+- `.cline/skills/` (recommended)
 - `.clinerules/skills/`
 - `.claude/skills/` (for Claude Code compatibility)
 
-When a global skill and project skill have the same name, the global skill takes precedence. Skills in `.agents/skills` directories take precedence over other locations with the same name, letting you customize skills for your personal workflow while still using project defaults.
+When a global skill and project skill have the same name, the global skill takes precedence. This lets you customize skills for your personal workflow while still using project defaults.
 
 ## Managing Skills
 

docs/features/subagents.mdx

@@ -1,85 +0,0 @@
----
-title: "Subagents"
-sidebarTitle: "Subagents"
-description: "Run parallel research agents to explore your codebase without filling the main agent's context window."
----
-
-Subagents let Cline spawn focused research agents that run in parallel. Each subagent gets its own prompt and context window, explores the codebase independently, and returns a detailed report to the main agent. This keeps the main agent's context clean while gathering broad information fast.
-
-<Tip>
-  Subagents is an experimental feature. Behavior may change in future releases.
-</Tip>
-
-## How It Works
-
-When Cline uses the `use_subagents` tool, it launches independent agents simultaneously. Each one:
-
-- Gets its own prompt describing what to investigate
-- Runs with a separate context window and token budget
-- Can read files, search code, list directories, run read-only commands, and use skills
-- Cannot edit files, use the browser, access MCP servers, or spawn nested subagents
-- Returns a result focused on the most relevant file paths for the main agent to read next
-
-Subagent costs (tokens and API spend) are tracked separately per subagent and rolled into the task's total cost. You can see per-subagent stats (tool calls, tokens, cost) in the chat UI as they run.
-
-## Enabling Subagents
-
-Subagents are disabled by default. To turn them on:
-
-1. Open Cline Settings (click the gear icon in the Cline panel)
-2. Go to **Features**
-3. Under the **Agent** section, toggle **Subagents** on
-
-This setting applies across all editors (VS Code, JetBrains, CLI).
-
-## Using Subagents
-
-Cline does not automatically decide to use subagents. You need to ask for them in your prompt. When the feature is enabled and you mention subagents (or describe a task that benefits from parallel exploration), Cline will use the `use_subagents` tool.
-
-Example prompts:
-
-- "Use subagents to explore how authentication works and where the database models are defined"
-- "Spin up subagents to investigate the API routes, the test setup, and the deployment config"
-- "I'm new to this codebase. Use subagents to map out the main entry points, the routing layer, and the data access patterns"
-
-Each subagent prompt should describe a focused research question. Cline will run them in parallel and synthesize the results.
-You can also run only one subagent when the task is small enough that parallel discovery would be unnecessary overhead.
-
-## Auto-Approve Behavior
-
-Subagents follow the **Read project files** auto-approve permission. If you have "Read project files" enabled in [Auto Approve](/features/auto-approve), subagent launches will be auto-approved.
-
-In [YOLO mode](/features/yolo-mode), subagents are always auto-approved.
-
-If auto-approve is off, Cline will ask for your approval before launching subagents, showing you the prompts it plans to send.
-
-## What Subagents Can Do
-
-Subagents are read-only research agents. Here is what they have access to:
-
-| Tool | Purpose |
-|------|---------|
-| `read_file` | Read file contents |
-| `list_files` | List directory contents |
-| `search_files` | Regex search across files |
-| `list_code_definition_names` | List top-level classes, functions, and methods |
-| `execute_command` | Run read-only commands (`ls`, `grep`, `git log`, `git diff`, etc.) |
-| `use_skill` | Load and activate skills |
-
-Subagents cannot write files, apply patches, use the browser, access MCP servers, or perform web searches. They also cannot spawn their own subagents.
-
-<Note>
-  Commands run by subagents execute in the background and are restricted to read-only operations. Subagents will not run commands that modify files or system state.
-  Subagents also benefit from command pipelines and filters to narrow output quickly before reading files, for example `rg ... | sort | uniq`.
-</Note>
-
-## When to Use Subagents
-
-Subagents work best when you need broad context from multiple areas of a codebase at once:
-
-- **Onboarding to an unfamiliar project**: Ask subagents to map out the architecture, key entry points, and data flow in parallel.
-- **Investigating cross-cutting concerns**: Have separate subagents trace authentication, logging, and error handling simultaneously.
-- **Pre-edit research**: Before making changes, use subagents to gather context from related files so the main agent can make informed edits without burning through its context window.
-- **Large codebases**: When reading many files sequentially would consume too much of the main agent's context, subagents let you explore broadly without that tradeoff.
-
-For small, focused tasks where you already know which files to look at, subagents add unnecessary overhead. Just ask Cline directly.

docs/mcp/mcp-server-development-protocol.mdx

@@ -281,7 +281,7 @@ We began by bootstrapping the project:
 ```bash
 npx @modelcontextprotocol/create-server alphaadvantage-mcp
 cd alphaadvantage-mcp
-npm install axios node-cache
+bun install axios node-cache
 ```
 
 Next, we structured our project with:

docs/package.json

@@ -13,19 +13,10 @@
 	"license": "ISC",
 	"description": "",
 	"dependencies": {
-		"mintlify": "^4.2.338"
+		"mintlify": "^4.2.249"
 	},
 	"overrides": {
 		"tar-fs": "^3.1.1",
-		"js-yaml": "^4.1.1",
-		"tar@<=6.2.1": "6.2.1",
-		"body-parser@<=1.20.3": "1.20.3",
-		"axios@<=1.13.5": "1.13.5",
-		"qs@<=6.14.1": "6.14.1",
-		"express@<=4.20.0": "4.20.0",
-		"serve-static@<=1.16.0": "1.16.0",
-		"send@<=0.19.0": "0.19.0",
-		"path-to-regexp@<=0.1.12": "0.1.12",
-		"cookie@<=0.7.0": "0.7.0"
+		"js-yaml": "^4.1.1"
 	}
 }

docs/provider-config/gcp-vertex-ai.mdx

@@ -53,7 +53,7 @@ Vertex AI supports multiple regions. Select a region that meets your latency, co
 -   **asia-southeast1 (Singapore)**
 -   **global (Global)**
 
-The Global endpoint may offer higher availability and reduce resource exhausted errors. Gemini models and supported Claude models can use it, depending on model availability in your project.
+The Global endpoint may offer higher availability and reduce resource exhausted errors. Only Gemini models are supported.
 
 #### 2.2 Enable the Claude 3.5 Sonnet v2 Model
 

evals/.gitignore

@@ -2,28 +2,23 @@ repositories
 temp-files
 results
 
-# Tool precision - results and databases
-benchmarks/tool-precision/replace-in-file/results/
-benchmarks/tool-precision/replace-in-file/*.db
-benchmarks/tool-precision/replace-in-file/*.db-wal
-benchmarks/tool-precision/replace-in-file/*.db-shm
-
-# Tool precision - private test cases (from real sessions)
-# Public/synthetic cases (example-*.json) ARE committed
-benchmarks/tool-precision/replace-in-file/cases/private-*.json
-benchmarks/tool-precision/replace-in-file/cases/session-*.json
-
-# Legacy paths (kept for backwards compatibility)
 diff-edits/cases/
 diff-edits/results/
-diff_editing/test_cases/
-diff_editing/test_outputs/
-diff-edits/cases.zip
 
 # Environment variables
 .env
 
+# backwards compatible
+diff_editing/test_cases/
+diff_editing/test_outputs/
+
+*.db
+*.db-wal
+*.db-shm
+
+.cache
+
 # Python bytecode cache
 *__pycache__/
 
-.cache
+diff-edits/cases.zip

evals/ARCHITECTURE.md

@@ -1,288 +0,0 @@
-# Cline Evals Architecture
-
-## Overview
-
-The evals system provides multi-layered testing for Cline's AI capabilities.
-
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                           TESTING PYRAMID                                   │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                                                                             │
-│                              ┌─────────┐                                    │
-│                             /   E2E    \         Layer 3: Full Agent        │
-│                            /  cline-   \         - Real coding tasks        │
-│                           /   bench     \        - Harbor execution         │
-│                          /_______________\       - Nightly runs             │
-│                                                                             │
-│                        ┌───────────────────┐                                │
-│                       /    Smoke Tests     \     Layer 2: Provider          │
-│                      /   run-smoke-tests    \    - 5 curated scenarios      │
-│                     /    (cline provider)    \   - 3 models via Vercel      │
-│                    /_________________________\   - pass@k metrics           │
-│                                                                             │
-│              ┌─────────────────────────────────┐                            │
-│             /        Contract Tests            \  Layer 1: Unit             │
-│            /   thinking-traces.test.ts          \ - No LLM calls            │
-│           /    tool-parsing.test.ts              \ - Fast, deterministic    │
-│          /______________________________________ \ - API format validation  │
-│                                                                             │
-└─────────────────────────────────────────────────────────────────────────────┘
-```
-
-## Directory Structure
-
-```
-evals/
-├── ARCHITECTURE.md          # This file
-├── README.md                # Quick start guide
-│
-├── analysis/                # Shared metrics & reporting
-│   └── src/
-│       ├── metrics.ts       # pass@k, pass^k, flakiness calculations
-│       └── cli.ts           # Analysis CLI
-│
-├── smoke-tests/             # Layer 2: Provider smoke tests
-│   ├── run-smoke-tests.ts   # Main runner
-│   ├── README.md            # Usage docs
-│   ├── scenarios/           # Test definitions
-│   │   ├── 01-create-file/
-│   │   │   ├── config.json  # Prompt, expected files/content
-│   │   │   ├── template/    # Initial files (if any)
-│   │   │   └── workspace/   # Working dir (cleaned each run)
-│   │   ├── 02-edit-file/
-│   │   ├── 03-read-summarize/
-│   │   ├── 04-multi-file/
-│   │   └── 05-typescript-function/
-│   └── results/             # Generated outputs
-│       ├── latest -> 2026-01-27T.../  # Symlink to most recent
-│       └── 2026-01-27T19-50-54-391Z/
-│           ├── report.json  # Full results
-│           ├── summary.md   # CI-friendly markdown
-│           └── 01-create-file/
-│               └── claude-sonnet/
-│                   ├── trial-1.log           # CLI stdout/stderr
-│                   └── workspace-trial-1/    # Kept for failures only
-│
-├── e2e/                     # Layer 3: Full agent E2E
-│   ├── run-cline-bench.ts   # Harbor runner
-│   └── README.md
-│
-└── cline-bench/             # Git submodule with real coding tasks
-    └── tasks/               # SWE-bench style problems
-```
-
-## Smoke Test Workflow
-
-```
-┌──────────────────────────────────────────────────────────────────────────────┐
-│                         SMOKE TEST EXECUTION FLOW                            │
-└──────────────────────────────────────────────────────────────────────────────┘
-
- npm run eval:smoke
-        │
-        ▼
-┌───────────────────┐
-│ Load scenarios    │  Read config.json from each scenarios/* dir
-│ from disk         │
-└────────┬──────────┘
-         │
-         ▼
-┌───────────────────┐
-│ Create results    │  evals/smoke-tests/results/2026-01-27T.../
-│ directory         │
-└────────┬──────────┘
-         │
-         ▼
-┌───────────────────────────────────────────────────────────────┐
-│                    FOR EACH SCENARIO                          │
-│  ┌─────────────────────────────────────────────────────────┐  │
-│  │                  FOR EACH MODEL                         │  │
-│  │  ┌───────────────────────────────────────────────────┐  │  │
-│  │  │           RUN 3 TRIALS SEQUENTIALLY               │  │  │
-│  │  │                                                   │  │  │
-│  │  │  Trial 1 ──► Trial 2 ──► Trial 3 ──► Results      │  │  │
-│  │  │  (Sequential - Cline instance handles one at a time)  │  │
-│  │  │                                                   │  │  │
-│  │  │  Each trial:                                      │  │  │
-│  │  │  1. Create workspace-trial-N/                     │  │  │
-│  │  │  2. Copy template files (if any)                  │  │  │
-│  │  │  3. Run: cline -y -o "prompt"                     │  │  │
-│  │  │  4. Verify expected files exist                   │  │  │
-│  │  │  5. Verify expected content                       │  │  │
-│  │  │  6. Save trial-N.log                              │  │  │
-│  │  │  7. If failed, copy workspace to results/         │  │  │
-│  │  └───────────────────────────────────────────────────┘  │  │
-│  │                         │                               │  │
-│  │                         ▼                               │  │
-│  │  ┌───────────────────────────────────────────────────┐  │  │
-│  │  │ Calculate metrics: pass@1, pass@3, pass^3, flaky  │  │  │
-│  │  └───────────────────────────────────────────────────┘  │  │
-│  └─────────────────────────────────────────────────────────┘  │
-└───────────────────────────────────────────────────────────────┘
-         │
-         ▼
-┌───────────────────┐
-│ Generate outputs  │
-│ - report.json     │
-│ - summary.md      │
-│ - latest symlink  │
-└───────────────────┘
-```
-
-## Models Tested
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                    CLINE PROVIDER ROUTING                       │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│   ┌─────────────┐                                               │
-│   │ Smoke Test  │                                               │
-│   │   Runner    │                                               │
-│   └──────┬──────┘                                               │
-│          │                                                      │
-│          │  cline -y -o "prompt" --model <model>                │
-│          │                                                      │
-│          ▼                                                      │
-│   ┌─────────────┐                                               │
-│   │   Cline     │                                               │
-│   │  Provider   │ ◄─── Uses your Cline auth (cline auth)        │
-│   └──────┬──────┘                                               │
-│          │                                                      │
-│          │ Routes to backend                                    │
-│          ▼                                                      │
-│   ┌─────────────────────────────────────────────────────────┐   │
-│   │                   Default Models                        │   │
-│   ├─────────────────────────────────────────────────────────┤   │
-│   │  claude-sonnet-4-20250514                               │   │
-│   │  gpt-4o                                                 │   │
-│   │  gemini-2.5-pro-preview-06-05                           │   │
-│   └─────────────────────────────────────────────────────────┘   │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Metrics Explained
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                        METRICS                                  │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  pass@k   "What's the probability of getting at least one      │
-│            success if I run k trials?"                          │
-│                                                                 │
-│            Example: 2/3 trials pass → pass@3 ≈ 96%              │
-│            (Very likely to pass if you run 3 times)             │
-│                                                                 │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  pass^k   "What's the probability of ALL k trials succeeding?" │
-│                                                                 │
-│            Example: 2/3 trials pass → pass^3 ≈ 30%              │
-│            (Only 30% chance all 3 would pass)                   │
-│                                                                 │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  Status   PASS  = All trials passed                             │
-│           FLAKY = Some passed, some failed                      │
-│           FAIL  = All trials failed                             │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-## Quick Commands
-
-```bash
-# Run all smoke tests (all models, 3 trials each)
-npm run eval:smoke
-
-# Run single model (use exact model ID for reproducibility)
-npm run eval:smoke -- --model claude-sonnet-4-20250514
-
-# Run single scenario
-npm run eval:smoke -- --scenario 01-create-file
-
-# Quick check (1 trial)
-npm run eval:smoke -- --trials 1
-
-# CI-like run (builds CLI from source, single trial)
-npm run eval:smoke:ci
-
-# View latest results
-cat evals/smoke-tests/results/latest/summary.md
-
-# Debug a failure
-cat evals/smoke-tests/results/latest/<scenario>/<model>/trial-1.log
-ls evals/smoke-tests/results/latest/<scenario>/<model>/workspace-trial-1/
-```
-
-## CI Integration
-
-Smoke tests run automatically on merge to `main` via `.github/workflows/cline-evals-regression.yml`.
-
-**Triggers:**
-- Push to `main` branch (paths: `src/core/**`, `src/shared/**`, `proto/**`)
-- Manual dispatch via `workflow_dispatch`
-
-**What it does:**
-1. Builds the Go CLI from source via `scripts/run-smoke-tests.sh`
-2. Runs all 5 scenarios × 3 models × 1 trial
-3. Uploads results as artifact
-4. Posts summary to GitHub Actions job summary
-
-```bash
-# The CI runs this script which handles proto generation + CLI build:
-bash scripts/run-smoke-tests.sh --trials 1
-```
-
-### Viewing CI Results
-
-1. **Job Summary**: Each run posts results to the Actions tab
-2. **Artifacts**: Full results downloadable as `smoke-test-results-<run_id>`
-
-### Running CI-like Tests Locally
-
-```bash
-# One command - builds CLI from source and runs tests
-npm run eval:smoke:ci
-
-# Or manually:
-npm run protos-go
-cd cli && go build -o cline ./cmd/cline
-export PATH="$(pwd)/cli:$PATH"
-npx tsx evals/smoke-tests/run-smoke-tests.ts --trials 1
-```
-
-### Why Build CLI in CI?
-
-We build the Go CLI from source rather than using a pre-built release because:
-- Tests actual CLI code from the commit (catches CLI regressions)
-- Proto definitions may have changed
-- No dependency on external releases
-
-## Contract Tests (Layer 1)
-
-> **Note**: The old `evals/benchmarks/tool-precision/` tests have been removed. Their functionality is now covered by contract tests in `src/core/**/__tests__/` and the 52 system prompt snapshot tests that run with `npm run test:unit`.
-
-Located in `src/core/api/transform/__tests__/`:
-
-```
-thinking-traces.test.ts
-├── convertToOpenAiMessages preserves reasoning_details
-├── convertToAnthropicMessage preserves thinking blocks
-└── sanitizeGeminiMessages handles provider-specific cleaning
-
-tool-parsing.test.ts
-├── Anthropic tool_use → OpenAI tool_calls conversion
-├── Tool call ID truncation (>40 chars)
-├── OpenAI Responses API ID transformation
-└── Tool result matching
-```
-
-Run with:
-```bash
-npm run test:unit -- --grep "Thinking Trace"  # 9 tests
-npm run test:unit -- --grep "Tool Call"       # 11 tests
-```

evals/README.md

@@ -1,149 +1,341 @@
-# Cline Evaluation Framework
+# Cline Evaluation System
 
-A layered testing system for measuring Cline's performance at different levels.
+This directory contains the evaluation system for benchmarking Cline against various coding evaluation frameworks.
+
+## Overview
+
+The Cline Evaluation System allows you to:
+
+1. Run Cline against standardized coding benchmarks
+2. Collect comprehensive metrics on performance
+3. Generate detailed reports on evaluation results
+4. Compare performance across different models and benchmarks
+
+## Architecture
+
+The evaluation system consists of two main components:
+
+1. **CLI Tool**: Command-line interface in `evals/cli/` for orchestrating evaluations
+2. **Diff Edit Benchmark**: Separate command using the CLI tool that runs a comprehensive diff editing benchmark suite on real world cases, along with a streamlit dashboard displaying the results. For more details, see the Diff Edit Benchmark [README](./diff-edits/README.md). Make sure you add a `evals/diff-edits/cases` folder with all the conversation jsons.
 
 ## Directory Structure
 
 ```
-evals/
-├── smoke-tests/           # Quick provider validation (minutes)
-│   ├── run-smoke-tests.ts
-│   └── scenarios/         # 5 curated test scenarios
-│
-├── e2e/                   # Full E2E with cline-bench (hours)
-│   └── run-cline-bench.ts
-│
-├── cline-bench/           # Real-world tasks (git submodule)
-│   └── tasks/             # 12 production bug fixes
-│
-├── analysis/              # Metrics and reporting framework
-│   ├── src/
-│   │   ├── metrics.ts     # pass@k, pass^k calculations
-│   │   ├── classifier.ts  # Failure pattern matching
-│   │   └── reporters/     # Markdown, JSON output
-│   └── patterns/
-│       └── cline-failures.yaml
-│
-└── baselines/             # Performance baselines for regression detection
+evals/                            # Main directory for evaluation system
+├── cli/                          # CLI tool for orchestrating evaluations
+│   └── src/
+│       ├── index.ts              # CLI entry point
+│       ├── commands/             # CLI commands (setup, run, report)
+│       ├── adapters/             # Benchmark adapters
+│       ├── db/                   # Database management
+│       └── utils/                # Utility functions
+├── diff-edits/                   # Diff editing evaluation suite
+│   ├── cases/                    # Test case JSON files
+│   ├── results/                  # Evaluation results
+│   ├── diff-apply/               # Diff application logic
+│   ├── parsing/                  # Assistant message parsing
+│   └── prompts/                  # System prompts
+├── repositories/                 # Cloned benchmark repositories
+│   └── exercism/                 # Exercism (Aider Polyglot)
+├── results/                      # Evaluation results storage
+│   ├── runs/                     # Individual run results
+│   └── reports/                  # Generated reports
+└── README.md                     # This file
 ```
 
-## Test Layers
+## Getting Started
 
-### Layer 1: Contract Tests (Unit)
+### Prerequisites
 
-Location: `src/core/api/transform/__tests__/`
+- Node.js 16+
+- VSCode with Cline extension installed
+- Git
 
-Tests API transform logic without LLM calls:
-- Thinking trace preservation
-- Tool call parsing (XML, native formats)
-- Provider format conversions
+### Installation
+
+1. Build the CLI tool:
 
 ```bash
-npm run test:unit -- --grep "Thinking\|Tool Call"
+cd evals
+npm install
+npm run build:cli
 ```
 
-### Layer 2: Smoke Tests (Minutes)
+### Usage
 
-Location: `evals/smoke-tests/`
-
-Quick validation across providers with real LLM calls:
-- 5 curated scenarios
-- 3 trials per test for pass@k metrics
-- Runs via cline CLI with `-s` flags
+#### Setting Up Benchmarks
 
 ```bash
-# Set API key (Cline provider)
-export CLINE_API_KEY=sk-...
-
-# Run smoke tests
-npm run eval:smoke
-
-# Run specific scenario
-npm run eval:smoke -- --scenario 01-create-file
-
-# Run with specific model (overrides per-scenario models)
-npm run eval:smoke -- --model anthropic/claude-sonnet-4.5
+cd evals/cli
+node dist/index.js setup
 ```
 
-### Layer 3: E2E Tests (Hours)
-
-Location: `evals/e2e/` + `evals/cline-bench/`
-
-Full agent tests on production-grade tasks:
-- 12 real-world coding problems
-- Docker/Daytona execution via Harbor
-- Nightly CI runs
+This will clone and set up all benchmark repositories. You can specify specific benchmarks:
 
 ```bash
-# Prerequisites: Python 3.13, Harbor, Docker
-npm run eval:e2e
-
-# Specific task
-npm run eval:e2e -- --tasks discord
-
-# Different provider
-npm run eval:e2e -- --provider openai --model gpt-4o
+node dist/index.js setup --benchmarks exercism
 ```
 
+#### Running Evaluations
+
+```bash
+node dist/index.js run --benchmark exercism --count 10
+```
+
+Options:
+- `--benchmark`: Specific benchmark to run (default: exercism)
+- `--count`: Number of tasks to run (default: all available tasks)
+
+**Note:** Model selection is currently configured through the Cline CLI itself, not through evaluation flags.
+
+#### Generating Reports
+
+```bash
+node dist/index.js report
+```
+
+Options:
+- `--format`: Report format (json, markdown) (default: markdown)
+- `--output`: Output path for the report
+
+## Benchmarks
+
+### Exercism
+
+Modified Exercism exercises from the [polyglot-benchmark](https://github.com/Aider-AI/polyglot-benchmark) repository. These are small, focused programming exercises in various languages.
+
+### SWE-Bench (Coming Soon)
+
+Real-world software engineering tasks from the [SWE-bench](https://github.com/SWE-bench/SWE-bench) repository.
+
+### SWELancer (Coming Soon)
+
+Freelance-style programming tasks from the SWELancer benchmark.
+
+### Multi-SWE-Bench (Coming Soon)
+
+Multi-file software engineering tasks from the Multi-SWE-Bench repository.
+
+## Diff Edit Evaluations
+
+The Cline Evaluation System includes a specialized suite for evaluating how well models can make precise edits to files using the `replace_in_file` tool.
+
+### Overview
+
+Diff edit evaluations test a model's ability to:
+
+1. Understand file content and identify specific sections to modify
+2. Generate correct SEARCH/REPLACE blocks for targeted edits
+3. Successfully apply changes without introducing errors
+
+### Directory Structure
+
+```
+diff-edits/
+├── cases/                  # Test case JSON files
+├── results/                # Evaluation results
+├── ClineWrapper.ts         # Wrapper for model interaction
+├── TestRunner.ts           # Main test execution logic
+├── types.ts                # Type definitions
+├── diff-apply/             # Diff application logic
+├── parsing/                # Assistant message parsing
+└── prompts/                # System prompts
+```
+
+### Creating Test Cases
+
+Test cases are defined as JSON files in the `diff-edits/cases/` directory. Each test case should include:
+
+```json
+{
+  "test_id": "example_test_1",
+  "messages": [
+    {
+      "role": "user",
+      "text": "Please fix the bug in this code...",
+      "images": []
+    },
+    {
+      "role": "assistant",
+      "text": "I'll help you fix that bug..."
+    }
+  ],
+  "file_contents": "// Original file content here\nfunction example() {\n  // Code with bug\n}",
+  "file_path": "src/example.js",
+  "system_prompt_details": {
+    "mcp_string": "",
+    "cwd_value": "/path/to/working/directory",
+    "browser_use": false,
+    "width": 900,
+    "height": 600,
+    "os_value": "macOS",
+    "shell_value": "/bin/zsh",
+    "home_value": "/Users/username",
+    "user_custom_instructions": ""
+  },
+  "original_diff_edit_tool_call_message": ""
+}
+```
+
+### Running Diff Edit Evaluations
+
+#### Single Model Evaluation
+
+```bash
+cd evals/cli
+node dist/index.js run-diff-eval --model-ids "anthropic/claude-3-5-sonnet-20241022"
+```
+
+#### Multi-Model Evaluation
+
+Compare multiple models in a single evaluation run:
+
+```bash
+# Compare Claude and Grok models
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-beta" \
+  --max-cases 10 \
+  --valid-attempts-per-case 3 \
+  --verbose
+
+# Compare multiple Claude variants
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,anthropic/claude-3-5-haiku-20241022,anthropic/claude-3-opus-20240229" \
+  --max-cases 5 \
+  --valid-attempts-per-case 2 \
+  --parallel
+```
+
+#### Options
+
+- `--model-ids`: Comma-separated list of model IDs to evaluate (required)
+- `--system-prompt-name`: System prompt to use (default: "basicSystemPrompt")
+- `--valid-attempts-per-case`: Number of attempts per test case per model (default: 1)
+- `--max-cases`: Maximum number of test cases to run (default: all available)
+- `--parsing-function`: Function to parse assistant messages (default: "parseAssistantMessageV2")
+- `--diff-edit-function`: Function to apply diffs (default: "constructNewFileContentV2")
+- `--test-path`: Path to test cases (default: diff-edits/cases)
+- `--thinking-budget`: Tokens allocated for thinking (default: 0)
+- `--parallel`: Run tests in parallel (flag)
+- `--replay`: Use pre-recorded LLM output (flag)
+- `--verbose`: Enable detailed logging (flag)
+
+#### Examples
+
+```bash
+# Quick test with 2 models, 4 cases, 2 attempts each
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-beta" \
+  --max-cases 4 \
+  --valid-attempts-per-case 2 \
+  --verbose
+
+# Comprehensive evaluation with parallel execution
+node dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,anthropic/claude-3-5-haiku-20241022" \
+  --system-prompt-name claude4SystemPrompt \
+  --valid-attempts-per-case 5 \
+  --max-cases 20 \
+  --parallel \
+  --verbose
+```
+
+### Database Storage & Analytics
+
+All evaluation results are automatically stored in a SQLite database (`diff-edits/evals.db`) for advanced analytics and comparison. The database includes:
+
+- **System Prompts**: Versioned system prompt content with hashing for deduplication
+- **Processing Functions**: Versioned parsing and diff-edit function configurations
+- **Files**: Original and edited file content with content-based hashing
+- **Runs**: Evaluation run metadata and configuration
+- **Cases**: Individual test case information with context tokens
+- **Results**: Detailed results with timing, cost, and success metrics
+
+### Interactive Dashboard
+
+Launch the Streamlit dashboard to visualize and analyze evaluation results:
+
+```bash
+cd diff-edits/dashboard
+streamlit run app.py
+```
+
+The dashboard provides:
+
+- **Model Performance Comparison**: Side-by-side comparison of success rates, latency, and costs
+- **Interactive Charts**: Success rate trends, latency vs cost analysis, and performance metrics
+- **Detailed Drill-Down**: Individual result analysis with file content viewing
+- **Run Selection**: Browse and compare different evaluation runs
+- **Real-time Updates**: Automatically refreshes with new evaluation data
+
+#### Dashboard Features
+
+1. **Hero Section**: Overview of current run with key metrics
+2. **Model Cards**: Performance cards with grades and detailed metrics
+3. **Comparison Charts**: Interactive Plotly charts for visual analysis
+4. **Result Explorer**: Detailed view of individual test results including:
+   - Original and edited file content
+   - Raw model output
+   - Parsed tool calls
+   - Timing and cost metrics
+   - Error analysis
+
+#### Quick Start Dashboard
+
+```bash
+# Run a quick evaluation
+node cli/dist/index.js run-diff-eval \
+  --model-ids "anthropic/claude-3-5-sonnet-20241022,x-ai/grok-beta" \
+  --max-cases 4 \
+  --valid-attempts-per-case 2 \
+  --verbose
+
+# Launch dashboard to view results
+cd diff-edits/dashboard && streamlit run app.py
+```
+
+### Legacy Results
+
+For backward compatibility, results are also saved as JSON files in the `diff-edits/results/` directory. The JSON results include:
+- Success/failure status
+- Extracted tool calls
+- Diff edit content
+- Token usage and cost metrics
+
 ## Metrics
 
-The framework calculates:
+The evaluation system collects the following metrics:
 
-| Metric | Formula | Interpretation |
-|--------|---------|----------------|
-| **pass@k** | P(≥1 of k passes) | Solution finding capability |
-| **pass^k** | P(all k pass) | Reliability |
-| **Flakiness** | Entropy of pass rate | Consistency |
+- **Token Usage**: Input and output tokens
+- **Cost**: Estimated cost of API calls
+- **Duration**: Time taken to complete tasks
+- **Tool Usage**: Number of tool calls and failures
+- **Success Rate**: Percentage of tasks completed successfully
+- **Test Success Rate**: Percentage of tests passed
+- **Functional Correctness**: Ratio of tests passed to total tests
 
-With 3 trials:
-- All pass → `pass` (reliable)
-- All fail → `fail` (broken)
-- Mixed → `flaky` (needs investigation)
+## Reports
 
-## CI Integration
+Reports are generated in Markdown or JSON format and include:
 
-- **PR Gate**: Contract tests + smoke tests (fast, ~3min)
-- **Nightly**: E2E tests with cline-bench (not yet implemented, see TODO)
+- Overall summary
+- Benchmark-specific results
+- Model-specific results
+- Tool usage statistics
+- Charts and visualizations
 
-## Quick Start
+## Development
 
-```bash
-# Run all fast tests
-npm run test:unit
-npm run eval:smoke
+### Adding a New Benchmark
 
-# Run E2E (requires setup)
-cd evals/cline-bench
-# Follow README.md for Harbor setup
-npm run eval:e2e
-```
+1. Create a new adapter in `evals/cli/src/adapters/`
+2. Implement the `BenchmarkAdapter` interface
+3. Register the adapter in `evals/cli/src/adapters/index.ts`
 
-## Adding Tests
+### Extending Metrics
 
-### Smoke Test Scenario
+To add new metrics:
 
-1. Create `evals/smoke-tests/scenarios/<name>/config.json`
-2. Add optional `template/` directory with starting files
-3. Run to verify: `npm run eval:smoke -- --scenario <name>`
-
-### Contract Test
-
-1. Add to `src/core/api/transform/__tests__/`
-2. Run: `npm run test:unit -- --grep "YourTest"`
-
-### E2E Task
-
-Contribute to [cline/cline-bench](https://github.com/cline/cline-bench)
-
-## Resources
-
-- [cline-bench tasks](evals/cline-bench/README.md)
-- [Smoke test scenarios](evals/smoke-tests/README.md)
-
-## TODO
-
-- [ ] **Nightly E2E CI**: Add scheduled workflow for cline-bench tests
-  - Requires: Docker runner, Harbor setup, ~1-2 hour timeout
-  - Should run on schedule (e.g., nightly) not per-PR
-  - Separate secrets for E2E environment
-- [ ] **Native tool calling smoke tests**: Add CLI support for `native_tool_call_enabled` setting to test Claude 4 with native tools
+1. Update the database schema in `evals/cli/src/db/schema.ts`
+2. Add collection logic in `evals/cli/src/utils/results.ts`
+3. Update report generation in `evals/cli/src/commands/report.ts`

evals/analysis/package.json

@@ -1,34 +0,0 @@
-{
-	"name": "@cline/analysis",
-	"version": "1.0.0",
-	"description": "Analysis framework for Cline evaluations with failure classification and metrics",
-	"type": "module",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"scripts": {
-		"start": "tsx src/cli.ts",
-		"build": "tsc",
-		"test": "vitest run",
-		"test:watch": "vitest",
-		"test:ui": "vitest --ui"
-	},
-	"keywords": [
-		"cline",
-		"evaluation",
-		"benchmarking",
-		"ai-testing",
-		"metrics"
-	],
-	"dependencies": {
-		"commander": "^12.0.0",
-		"js-yaml": "^4.1.0",
-		"chalk": "^5.0.0"
-	},
-	"devDependencies": {
-		"@types/node": "^20.0.0",
-		"@types/js-yaml": "^4.0.0",
-		"tsx": "^4.0.0",
-		"typescript": "^5.0.0",
-		"vitest": "^1.0.0"
-	}
-}

evals/analysis/patterns/cline-failures.yaml

@@ -1,57 +0,0 @@
-# Cline-specific failure patterns for classification
-# Version 1.0
-
-version: "1.0"
-
-patterns:
-  # Provider-specific bugs (Cline integration issues)
-  - name: "gemini_signature"
-    pattern: "missing.?signature|thoughtSignature"
-    category: "provider_bug"
-    issue: "https://github.com/cline/cline/issues/7974"
-    description: "Gemini 3 Pro requires thoughtSignature for native tool calls"
-
-  - name: "claude_tool_format"
-    pattern: "write_to_file.*missing.*content|content.*parameter.*required"
-    category: "provider_bug"
-    issue: "https://github.com/cline/cline/issues/7998"
-    description: "Claude tool parameter extraction failure"
-
-  # Transient failures (retriable)
-  - name: "rate_limit"
-    pattern: "429|rate.?limit|too.?many.?requests|quota.?exceeded"
-    category: "transient"
-    description: "API rate limiting"
-
-  - name: "network_timeout"
-    pattern: "ECONNREFUSED|ETIMEDOUT|ENOTFOUND|timed.?out"
-    category: "transient"
-    description: "Network connectivity issues"
-
-  - name: "model_overloaded"
-    pattern: "503|service.?unavailable|overloaded"
-    category: "transient"
-    description: "Provider service unavailable"
-
-  # Infrastructure/harness failures
-  - name: "harness_error"
-    pattern: "verifier.*failed|test.*harness.*error|missing.*test.*file"
-    category: "harness"
-    description: "Test harness or verification script failure"
-
-  - name: "environment_failure"
-    pattern: "docker.*failed|container.*exit|OCI.*runtime|pod.*error"
-    category: "environment"
-    description: "Docker/Daytona environment setup failure"
-
-  # Policy/safety failures
-  - name: "safety_refusal"
-    pattern: "content.*policy|safety.*filter|inappropriate.*request"
-    category: "policy"
-    description: "Model refused due to safety/content policy"
-
-  # Auth issues (non-retriable)
-  - name: "auth_error"
-    pattern: "401|unauthorized|invalid.?api.?key"
-    category: "auth"
-    description: "Invalid API credentials"

evals/analysis/src/__tests__/classifier.test.ts

@@ -1,180 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { FailureClassifier } from "../classifier"
-
-describe("FailureClassifier", () => {
-	const classifier = new FailureClassifier()
-
-	describe("Provider Bug Detection", () => {
-		it("detects Gemini signature issue", () => {
-			const logs = `
-				Error: Function call is missing a thought_signature in functionCall parts.
-				This is required for tools to work correctly with Gemini 3 Pro...
-			`
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("gemini_signature")
-			expect(failures[0].category).toBe("provider_bug")
-			expect(failures[0].issue_url).toBe("https://github.com/cline/cline/issues/7974")
-		})
-
-		it("detects Claude tool format issue", () => {
-			const logs = `Cline tried to use write_to_file without value for required parameter 'content'`
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("claude_tool_format")
-			expect(failures[0].category).toBe("provider_bug")
-			expect(failures[0].issue_url).toBe("https://github.com/cline/cline/issues/7998")
-		})
-	})
-
-	describe("Transient Failure Detection", () => {
-		it("detects rate limiting", () => {
-			const logs = "Error: 429 Too Many Requests - Rate limit exceeded"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("rate_limit")
-			expect(failures[0].category).toBe("transient")
-		})
-
-		it("detects network timeout", () => {
-			const logs = "Error: ETIMEDOUT - Connection timed out"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("network_timeout")
-			expect(failures[0].category).toBe("transient")
-		})
-
-		it("detects service unavailable", () => {
-			const logs = "503 Service Unavailable - Model is currently overloaded"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("model_overloaded")
-			expect(failures[0].category).toBe("transient")
-		})
-	})
-
-	describe("Infrastructure Failure Detection", () => {
-		it("detects harness errors", () => {
-			const logs = "verifier script failed with exit code 1"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("harness_error")
-			expect(failures[0].category).toBe("harness")
-		})
-
-		it("detects environment failures", () => {
-			const logs = "Error: docker container exit code 137"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("environment_failure")
-			expect(failures[0].category).toBe("environment")
-		})
-	})
-
-	describe("Policy and Auth Failures", () => {
-		it("detects safety refusals", () => {
-			const logs = "Request blocked: Content policy violation"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("safety_refusal")
-			expect(failures[0].category).toBe("policy")
-		})
-
-		it("detects auth errors", () => {
-			const logs = "401 Unauthorized: Invalid API key"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("auth_error")
-			expect(failures[0].category).toBe("auth")
-		})
-	})
-
-	describe("Excerpt Extraction", () => {
-		it("extracts context around the matched pattern", () => {
-			const logs = `
-				This is some context before the error.
-				Error: 429 Too Many Requests - Rate limit exceeded
-				This is some context after the error.
-			`
-			const failures = classifier.classify(logs)
-
-			expect(failures[0].excerpt).toContain("Rate limit exceeded")
-			expect(failures[0].excerpt.length).toBeLessThan(500)
-		})
-	})
-
-	describe("Helper Methods", () => {
-		it("hasProviderBug returns true for provider bugs", () => {
-			const logs = "Error: missing thoughtSignature in function call"
-			expect(classifier.hasProviderBug(logs)).toBe(true)
-		})
-
-		it("hasProviderBug returns false for non-provider bugs", () => {
-			const logs = "Error: 429 Too Many Requests"
-			expect(classifier.hasProviderBug(logs)).toBe(false)
-		})
-
-		it("hasTransientFailure returns true for transient errors", () => {
-			const logs = "Error: ETIMEDOUT"
-			expect(classifier.hasTransientFailure(logs)).toBe(true)
-		})
-
-		it("hasTransientFailure returns false for non-transient errors", () => {
-			const logs = "Error: missing thoughtSignature"
-			expect(classifier.hasTransientFailure(logs)).toBe(false)
-		})
-
-		it("getPatternsByCategory returns correct patterns", () => {
-			const providerBugs = classifier.getPatternsByCategory("provider_bug")
-			expect(providerBugs).toContain("gemini_signature")
-			expect(providerBugs).toContain("claude_tool_format")
-
-			const transient = classifier.getPatternsByCategory("transient")
-			expect(transient).toContain("rate_limit")
-			expect(transient).toContain("network_timeout")
-			expect(transient).toContain("model_overloaded")
-		})
-	})
-
-	describe("Multiple Pattern Matching", () => {
-		it("detects multiple failures in same log", () => {
-			const logs = `
-				Error: 429 Too Many Requests
-				Later: Error: ETIMEDOUT
-			`
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBe(2)
-			expect(failures.map((f) => f.name)).toContain("rate_limit")
-			expect(failures.map((f) => f.name)).toContain("network_timeout")
-		})
-	})
-
-	describe("Case Insensitivity", () => {
-		it("matches patterns case-insensitively", () => {
-			const logs = "error: RATE LIMIT exceeded"
-			const failures = classifier.classify(logs)
-
-			expect(failures.length).toBeGreaterThan(0)
-			expect(failures[0].name).toBe("rate_limit")
-		})
-	})
-
-	describe("No Match", () => {
-		it("returns empty array when no patterns match", () => {
-			const logs = "Everything completed successfully"
-			const failures = classifier.classify(logs)
-
-			expect(failures).toEqual([])
-		})
-	})
-})

evals/analysis/src/__tests__/metrics.test.ts

@@ -1,249 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { MetricsCalculator } from "../metrics"
-
-describe("MetricsCalculator", () => {
-	const calc = new MetricsCalculator()
-
-	describe("pass@k (solution finding)", () => {
-		it("calculates 100% when at least k trials pass", () => {
-			expect(calc.passAtK([true, true, true], 1)).toBe(1.0)
-			expect(calc.passAtK([true, true, false], 1)).toBe(1.0)
-			expect(calc.passAtK([true, true, true], 3)).toBe(1.0)
-		})
-
-		it("calculates 0% when fewer than k trials pass", () => {
-			expect(calc.passAtK([false, false, false], 1)).toBe(0.0)
-		})
-
-		it("calculates correct probability for mixed results", () => {
-			// With n=3, c=2, k=2: 1 - C(1,2)/C(3,2) = 1 - 0/3 = 1.0
-			expect(calc.passAtK([true, true, false], 2)).toBe(1.0)
-
-			// With n=3, c=1, k=2: 1 - C(2,2)/C(3,2) = 1 - 1/3 = 2/3
-			expect(calc.passAtK([true, false, false], 2)).toBeCloseTo(0.6667, 4)
-		})
-
-		it("throws error when k > n", () => {
-			expect(() => calc.passAtK([true, false], 3)).toThrow()
-		})
-
-		it("handles k=1 correctly (most common case)", () => {
-			expect(calc.passAtK([true, false, false], 1)).toBe(1.0)
-			expect(calc.passAtK([false, false, false], 1)).toBe(0.0)
-		})
-
-		it("handles all-pass scenarios", () => {
-			expect(calc.passAtK([true, true, true, true, true], 3)).toBe(1.0)
-			expect(calc.passAtK([true, true, true, true, true], 5)).toBe(1.0)
-		})
-
-		it("handles all-fail scenarios", () => {
-			expect(calc.passAtK([false, false, false], 1)).toBe(0.0)
-			expect(calc.passAtK([false, false, false], 3)).toBe(0.0)
-		})
-	})
-
-	describe("pass^k (reliability)", () => {
-		it("calculates 100% when all k trials must and do pass", () => {
-			expect(calc.passCaretK([true, true, true], 3)).toBe(1.0)
-			expect(calc.passCaretK([true, true, true, true], 3)).toBeCloseTo(1.0, 4)
-		})
-
-		it("calculates 0% when fewer than k trials pass", () => {
-			expect(calc.passCaretK([true, true, false], 3)).toBe(0.0)
-			expect(calc.passCaretK([true, false, false], 2)).toBe(0.0)
-			expect(calc.passCaretK([false, false, false], 1)).toBe(0.0)
-		})
-
-		it("calculates correct probability for sufficient passes", () => {
-			// With n=4, c=3, k=2: C(3,2)/C(4,2) = 3/6 = 0.5
-			expect(calc.passCaretK([true, true, true, false], 2)).toBeCloseTo(0.5, 4)
-
-			// With n=5, c=3, k=2: C(3,2)/C(5,2) = 3/10 = 0.3
-			expect(calc.passCaretK([true, true, true, false, false], 2)).toBeCloseTo(0.3, 4)
-		})
-
-		it("throws error when k > n", () => {
-			expect(() => calc.passCaretK([true, false], 3)).toThrow()
-		})
-
-		it("diverges from pass@k as trials increase", () => {
-			const trials = [true, true, false, false, false]
-
-			// pass@k increases (eventually finds solution)
-			const passAt1 = calc.passAtK(trials, 1)
-			const passAt3 = calc.passAtK(trials, 3)
-			expect(passAt3).toBeGreaterThanOrEqual(passAt1)
-
-			// pass^k decreases (reliability drops)
-			const passCaret1 = calc.passCaretK(trials, 1)
-			const passCaret3 = calc.passCaretK(trials, 3)
-			expect(passCaret3).toBeLessThanOrEqual(passCaret1)
-		})
-	})
-
-	describe("flakinessScore (variance)", () => {
-		it("returns 0 for all-pass scenarios", () => {
-			expect(calc.flakinessScore([true, true, true])).toBe(0)
-		})
-
-		it("returns 0 for all-fail scenarios", () => {
-			expect(calc.flakinessScore([false, false, false])).toBe(0)
-		})
-
-		it("returns 1 for maximum variance (50% pass rate)", () => {
-			expect(calc.flakinessScore([true, false])).toBe(1)
-			expect(calc.flakinessScore([true, true, false, false])).toBe(1)
-		})
-
-		it("returns values between 0 and 1 for partial variance", () => {
-			const score1 = calc.flakinessScore([true, true, true, false])
-			expect(score1).toBeGreaterThan(0)
-			expect(score1).toBeLessThan(1)
-
-			const score2 = calc.flakinessScore([true, false, false, false])
-			expect(score2).toBeGreaterThan(0)
-			expect(score2).toBeLessThan(1)
-		})
-
-		it("symmetric around 50% pass rate", () => {
-			const score25 = calc.flakinessScore([true, false, false, false])
-			const score75 = calc.flakinessScore([true, true, true, false])
-			expect(score25).toBeCloseTo(score75, 4)
-		})
-
-		it("higher variance for rates closer to 50%", () => {
-			const score25 = calc.flakinessScore([true, false, false, false])
-			const score50 = calc.flakinessScore([true, true, false, false])
-			expect(score50).toBeGreaterThan(score25)
-		})
-	})
-
-	describe("binomial coefficient", () => {
-		it("calculates C(n, 0) = 1", () => {
-			expect(calc["binomial"](5, 0)).toBe(1)
-		})
-
-		it("calculates C(n, n) = 1", () => {
-			expect(calc["binomial"](5, 5)).toBe(1)
-		})
-
-		it("calculates C(n, 1) = n", () => {
-			expect(calc["binomial"](5, 1)).toBe(5)
-		})
-
-		it("calculates C(n, k) correctly", () => {
-			expect(calc["binomial"](5, 2)).toBe(10)
-			expect(calc["binomial"](6, 3)).toBe(20)
-			expect(calc["binomial"](10, 3)).toBe(120)
-		})
-
-		it("returns 0 when k > n", () => {
-			expect(calc["binomial"](3, 5)).toBe(0)
-		})
-
-		it("optimizes by using smaller k", () => {
-			// C(10, 8) = C(10, 2) = 45
-			expect(calc["binomial"](10, 8)).toBe(45)
-			expect(calc["binomial"](10, 2)).toBe(45)
-		})
-	})
-
-	describe("calculateTaskMetrics", () => {
-		it("calculates all metrics for 3 trials", () => {
-			const metrics = calc.calculateTaskMetrics([true, true, false])
-
-			expect(metrics.passAt1).toBe(1.0)
-			expect(metrics.passAt3).toBeGreaterThan(0)
-			expect(metrics.passCaret3).toBe(0.0)
-			expect(metrics.flakinessScore).toBeGreaterThan(0)
-		})
-
-		it("calculates all metrics for perfect pass", () => {
-			const metrics = calc.calculateTaskMetrics([true, true, true])
-
-			expect(metrics.passAt1).toBe(1.0)
-			expect(metrics.passAt3).toBe(1.0)
-			expect(metrics.passCaret3).toBe(1.0)
-			expect(metrics.flakinessScore).toBe(0)
-		})
-
-		it("calculates all metrics for perfect fail", () => {
-			const metrics = calc.calculateTaskMetrics([false, false, false])
-
-			expect(metrics.passAt1).toBe(0.0)
-			expect(metrics.passAt3).toBe(0.0)
-			expect(metrics.passCaret3).toBe(0.0)
-			expect(metrics.flakinessScore).toBe(0)
-		})
-
-		it("throws error for empty trials", () => {
-			expect(() => calc.calculateTaskMetrics([])).toThrow()
-		})
-
-		it("handles fewer than 3 trials gracefully", () => {
-			const metrics = calc.calculateTaskMetrics([true, false])
-
-			expect(metrics.passAt1).toBe(1.0)
-			expect(metrics.passAt3).toBe(0) // Not enough trials
-			expect(metrics.passCaret3).toBe(0)
-			expect(metrics.flakinessScore).toBe(1)
-		})
-	})
-
-	describe("getTaskStatus", () => {
-		it("returns 'pass' when all trials pass", () => {
-			expect(calc.getTaskStatus([true, true, true])).toBe("pass")
-		})
-
-		it("returns 'fail' when all trials fail", () => {
-			expect(calc.getTaskStatus([false, false, false])).toBe("fail")
-		})
-
-		it("returns 'flaky' when some trials pass and some fail", () => {
-			expect(calc.getTaskStatus([true, false, false])).toBe("flaky")
-			expect(calc.getTaskStatus([true, true, false])).toBe("flaky")
-		})
-
-		it("handles single trial", () => {
-			expect(calc.getTaskStatus([true])).toBe("pass")
-			expect(calc.getTaskStatus([false])).toBe("fail")
-		})
-	})
-
-	describe("Real-world scenarios", () => {
-		it("handles typical cline-bench results", () => {
-			// Scenario: Task passed 2/3 times
-			const trials = [true, true, false]
-			const metrics = calc.calculateTaskMetrics(trials)
-
-			expect(metrics.passAt1).toBe(1.0) // Found solution
-			expect(metrics.passAt3).toBeGreaterThan(0.5) // Likely to solve
-			expect(metrics.passCaret3).toBe(0) // Not reliable
-			expect(metrics.flakinessScore).toBeGreaterThan(0) // Has variance
-			expect(calc.getTaskStatus(trials)).toBe("flaky")
-		})
-
-		it("handles consistent success", () => {
-			const trials = [true, true, true]
-			const metrics = calc.calculateTaskMetrics(trials)
-
-			expect(metrics.passAt1).toBe(1.0)
-			expect(metrics.passAt3).toBe(1.0)
-			expect(metrics.passCaret3).toBe(1.0)
-			expect(metrics.flakinessScore).toBe(0)
-			expect(calc.getTaskStatus(trials)).toBe("pass")
-		})
-
-		it("handles consistent failure", () => {
-			const trials = [false, false, false]
-			const metrics = calc.calculateTaskMetrics(trials)
-
-			expect(metrics.passAt1).toBe(0)
-			expect(metrics.passAt3).toBe(0)
-			expect(metrics.passCaret3).toBe(0)
-			expect(metrics.flakinessScore).toBe(0)
-			expect(calc.getTaskStatus(trials)).toBe("fail")
-		})
-	})
-})

evals/analysis/src/classifier.ts

@@ -1,124 +0,0 @@
-/**
- * Failure classification system for Cline evaluations
- *
- * Classifies failures by matching log patterns against known issues:
- * - Provider bugs (Gemini #7974, Claude #7998)
- * - Transient failures (rate limits, timeouts)
- * - Infrastructure issues (harness, environment)
- * - Policy/safety refusals
- * - Auth errors
- */
-
-import * as fs from "fs"
-import * as yaml from "js-yaml"
-import * as path from "path"
-import type { FailureCategory, FailureInfo } from "./schemas"
-
-export interface FailurePattern {
-	name: string
-	pattern: string // Regex pattern as string
-	category: FailureCategory
-	issue?: string // GitHub issue URL
-	description: string
-}
-
-export interface FailurePatternsConfig {
-	version: string
-	patterns: FailurePattern[]
-}
-
-export class FailureClassifier {
-	private patterns: Array<FailurePattern & { regex: RegExp }>
-
-	constructor(patternsPath?: string) {
-		const defaultPath = path.join(__dirname, "../patterns/cline-failures.yaml")
-		const configPath = patternsPath || defaultPath
-
-		const config = this.loadPatternsFromYaml(configPath)
-		this.patterns = config.patterns.map((p) => ({
-			...p,
-			regex: new RegExp(p.pattern, "i"), // Case-insensitive matching
-		}))
-	}
-
-	private loadPatternsFromYaml(filePath: string): FailurePatternsConfig {
-		const content = fs.readFileSync(filePath, "utf-8")
-		const config = yaml.load(content) as FailurePatternsConfig
-
-		if (!config.version || !config.patterns) {
-			throw new Error("Invalid patterns YAML: missing version or patterns")
-		}
-
-		return config
-	}
-
-	/**
-	 * Classify failures in log text
-	 * @param logs Full log text (e.g., cline.txt content)
-	 * @returns Array of matched failure categories with excerpts
-	 */
-	classify(logs: string): FailureInfo[] {
-		const failures: FailureInfo[] = []
-
-		for (const pattern of this.patterns) {
-			const match = pattern.regex.exec(logs)
-			if (match) {
-				failures.push({
-					name: pattern.name,
-					category: pattern.category,
-					excerpt: this.extractExcerpt(logs, match.index, match[0].length),
-					issue_url: pattern.issue,
-				})
-			}
-		}
-
-		return failures
-	}
-
-	/**
-	 * Extract a context snippet around the matched pattern
-	 * @param logs Full log text
-	 * @param matchIndex Index where pattern matched
-	 * @param matchLength Length of the matched text
-	 * @returns Context snippet (up to 200 chars before/after match)
-	 */
-	private extractExcerpt(logs: string, matchIndex: number, matchLength: number): string {
-		const contextSize = 200
-		const start = Math.max(0, matchIndex - contextSize)
-		const end = Math.min(logs.length, matchIndex + matchLength + contextSize)
-
-		let excerpt = logs.slice(start, end)
-
-		// Trim to complete lines for readability
-		excerpt = excerpt.replace(/^\s*\S*\s*/, "") // Remove partial first line
-		excerpt = excerpt.replace(/\s*\S*\s*$/, "") // Remove partial last line
-
-		// Truncate if still too long
-		if (excerpt.length > 400) {
-			excerpt = excerpt.slice(0, 400) + "..."
-		}
-
-		return excerpt.trim()
-	}
-
-	/**
-	 * Check if logs contain any known provider bug patterns
-	 */
-	hasProviderBug(logs: string): boolean {
-		return this.classify(logs).some((f) => f.category === "provider_bug")
-	}
-
-	/**
-	 * Check if logs contain transient failure patterns (retriable)
-	 */
-	hasTransientFailure(logs: string): boolean {
-		return this.classify(logs).some((f) => f.category === "transient")
-	}
-
-	/**
-	 * Get all pattern names for a specific category
-	 */
-	getPatternsByCategory(category: FailureCategory): string[] {
-		return this.patterns.filter((p) => p.category === category).map((p) => p.name)
-	}
-}

evals/analysis/src/cli.ts

@@ -1,240 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Cline Analysis Framework CLI
- *
- * Commands:
- * - analyze: Parse Harbor job output and generate reports
- * - compare: Compare baseline vs current results for regression detection
- */
-
-import chalk from "chalk"
-import { Command } from "commander"
-import * as fs from "fs"
-import { HarborParser } from "./parsers"
-import { JsonReporter, MarkdownReporter } from "./reporters"
-import type { AnalysisOutputV1, ComparisonResult } from "./schemas"
-
-const program = new Command()
-
-program.name("cline-analysis").description("Analysis framework for Cline evaluations").version("1.0.0")
-
-// Analyze command
-program
-	.command("analyze <job-dir>")
-	.description("Parse Harbor job output and generate analysis report")
-	.option("-f, --format <format>", "Output format: markdown, json, or minimal", "markdown")
-	.option("-o, --output <file>", "Write report to file (default: stdout)")
-	.option("--no-color", "Disable colored output")
-	.action(async (jobDir: string, options: any) => {
-		try {
-			// Validate job directory
-			if (!fs.existsSync(jobDir)) {
-				console.error(chalk.red(`Error: Job directory not found: ${jobDir}`))
-				process.exit(1)
-			}
-
-			console.error(chalk.blue(`Analyzing Harbor job: ${jobDir}`))
-
-			// Parse Harbor output
-			const parser = new HarborParser()
-			const analysis = parser.parseJob(jobDir)
-
-			// Generate report
-			let report: string
-
-			if (options.format === "json") {
-				const jsonReporter = new JsonReporter()
-				report = jsonReporter.generate(analysis, true)
-			} else if (options.format === "minimal") {
-				const jsonReporter = new JsonReporter()
-				report = jsonReporter.generateMinimal(analysis)
-			} else {
-				const markdownReporter = new MarkdownReporter()
-				report = markdownReporter.generate(analysis, options.color)
-			}
-
-			// Output report
-			if (options.output) {
-				fs.writeFileSync(options.output, report)
-				console.error(chalk.green(`✓ Report written to: ${options.output}`))
-
-				// Also write full JSON for future reference
-				if (options.format === "markdown") {
-					const jsonPath = options.output.replace(/\.md$/, ".json")
-					const jsonReporter = new JsonReporter()
-					fs.writeFileSync(jsonPath, jsonReporter.generate(analysis, true))
-					console.error(chalk.gray(`  (Full JSON saved to: ${jsonPath})`))
-				}
-			} else {
-				console.log(report)
-			}
-
-			// Summary on stderr
-			const markdownReporter = new MarkdownReporter()
-			const summary = markdownReporter.generateCompactSummary(analysis)
-			console.error("\n" + chalk.bold("Summary:"))
-			console.error(summary)
-		} catch (error) {
-			console.error(chalk.red("Error during analysis:"))
-			console.error(error)
-			process.exit(1)
-		}
-	})
-
-// Compare command
-program
-	.command("compare <baseline> <current>")
-	.description("Compare baseline and current analysis results")
-	.option("-t, --threshold <number>", "Regression threshold (percentage points)", "10")
-	.option("--no-color", "Disable colored output")
-	.action(async (baselinePath: string, currentPath: string, options: any) => {
-		try {
-			// Load both analysis outputs
-			if (!fs.existsSync(baselinePath)) {
-				console.error(chalk.red(`Error: Baseline file not found: ${baselinePath}`))
-				process.exit(1)
-			}
-
-			if (!fs.existsSync(currentPath)) {
-				console.error(chalk.red(`Error: Current file not found: ${currentPath}`))
-				process.exit(1)
-			}
-
-			const baseline: AnalysisOutputV1 = JSON.parse(fs.readFileSync(baselinePath, "utf-8"))
-			const current: AnalysisOutputV1 = JSON.parse(fs.readFileSync(currentPath, "utf-8"))
-
-			const threshold = parseFloat(options.threshold)
-
-			// Compare results
-			const comparison = compareAnalyses(baseline, current, threshold)
-
-			// Display comparison
-			displayComparison(comparison, options.color)
-
-			// Exit with error if regression detected
-			if (comparison.regression_detected) {
-				console.error(chalk.red("\n✗ Regression detected! See details above."))
-				process.exit(1)
-			} else {
-				console.error(chalk.green("\n✓ No significant regression detected."))
-				process.exit(0)
-			}
-		} catch (error) {
-			console.error(chalk.red("Error during comparison:"))
-			console.error(error)
-			process.exit(1)
-		}
-	})
-
-program.parse()
-
-/**
- * Compare two analysis outputs for regression detection
- */
-function compareAnalyses(baseline: AnalysisOutputV1, current: AnalysisOutputV1, threshold: number): ComparisonResult {
-	const delta = {
-		pass_at_1: (current.summary.pass_at_1 - baseline.summary.pass_at_1) * 100,
-		pass_at_3: (current.summary.pass_at_3 - baseline.summary.pass_at_3) * 100,
-		pass_caret_3: (current.summary.pass_caret_3 - baseline.summary.pass_caret_3) * 100,
-		cost_usd: current.summary.total_cost_usd - baseline.summary.total_cost_usd,
-		duration_sec: current.summary.total_duration_sec - baseline.summary.total_duration_sec,
-	}
-
-	// Detect regression (drop in pass rates exceeding threshold)
-	const regression_detected = delta.pass_at_1 < -threshold || delta.pass_at_3 < -threshold
-
-	// Find tasks that regressed or improved
-	const tasks_regressed: string[] = []
-	const tasks_improved: string[] = []
-
-	const baselineTaskMap = new Map(baseline.tasks.map((t) => [t.task_id, t]))
-
-	for (const currentTask of current.tasks) {
-		const baselineTask = baselineTaskMap.get(currentTask.task_id)
-		if (!baselineTask) {
-			continue
-		}
-
-		const taskDelta = (currentTask.metrics.pass_at_3 - baselineTask.metrics.pass_at_3) * 100
-
-		if (taskDelta < -threshold) {
-			tasks_regressed.push(currentTask.task_name)
-		} else if (taskDelta > threshold) {
-			tasks_improved.push(currentTask.task_name)
-		}
-	}
-
-	return {
-		baseline: baseline.summary,
-		current: current.summary,
-		delta,
-		regression_detected,
-		tasks_regressed,
-		tasks_improved,
-	}
-}
-
-/**
- * Display comparison results with color coding
- */
-function displayComparison(comparison: ComparisonResult, useColor: boolean): void {
-	const separator = "━".repeat(79)
-
-	console.log(useColor ? chalk.bold(separator) : separator)
-	console.log(useColor ? chalk.bold.cyan("Baseline vs Current Comparison") : "Baseline vs Current Comparison")
-	console.log(useColor ? chalk.bold(separator) : separator)
-	console.log("")
-
-	// Pass rate changes
-	console.log(useColor ? chalk.bold("Pass Rate Changes:") : "Pass Rate Changes:")
-	console.log(`  pass@1: ${formatDelta(comparison.delta.pass_at_1, useColor)} percentage points`)
-	console.log(`  pass@3: ${formatDelta(comparison.delta.pass_at_3, useColor)} percentage points`)
-	console.log(`  pass^3: ${formatDelta(comparison.delta.pass_caret_3, useColor)} percentage points`)
-	console.log("")
-
-	// Cost and duration changes
-	console.log(useColor ? chalk.bold("Resource Changes:") : "Resource Changes:")
-	console.log(`  Cost: ${formatDelta(comparison.delta.cost_usd, useColor, true)} USD`)
-	console.log(`  Duration: ${formatDelta(comparison.delta.duration_sec, useColor)} seconds`)
-	console.log("")
-
-	// Tasks regressed
-	if (comparison.tasks_regressed.length > 0) {
-		console.log(useColor ? chalk.bold.red("Tasks Regressed:") : "Tasks Regressed:")
-		for (const task of comparison.tasks_regressed) {
-			console.log(`  • ${task}`)
-		}
-		console.log("")
-	}
-
-	// Tasks improved
-	if (comparison.tasks_improved.length > 0) {
-		console.log(useColor ? chalk.bold.green("Tasks Improved:") : "Tasks Improved:")
-		for (const task of comparison.tasks_improved) {
-			console.log(`  • ${task}`)
-		}
-		console.log("")
-	}
-}
-
-/**
- * Format delta value with color coding
- */
-function formatDelta(value: number, useColor: boolean, invertSign = false): string {
-	const sign = invertSign ? -Math.sign(value) : Math.sign(value)
-	const absValue = Math.abs(value).toFixed(2)
-	const signStr = sign > 0 ? "+" : sign < 0 ? "-" : " "
-
-	if (!useColor) {
-		return `${signStr}${absValue}`
-	}
-
-	if (sign > 0) {
-		return chalk.green(`${signStr}${absValue}`)
-	}
-	if (sign < 0) {
-		return chalk.red(`${signStr}${absValue}`)
-	}
-	return chalk.gray(`${signStr}${absValue}`)
-}

evals/analysis/src/metrics.ts

@@ -1,186 +0,0 @@
-/**
- * Metrics calculation for nondeterministic AI testing
- *
- * Implements:
- * - pass@k: P(at least 1 of k trials passes) - solution finding capability
- * - pass^k: P(all k trials pass) - reliability measure
- * - Flakiness score: Entropy-based variance measurement
- *
- * References:
- * - HumanEval paper: https://arxiv.org/abs/2107.03374
- * - pass@k methodology: https://github.com/openai/human-eval
- */
-
-export class MetricsCalculator {
-	/**
-	 * Calculate pass@k: Probability that at least 1 of k trials succeeds
-	 *
-	 * Formula: 1 - C(n-c, k) / C(n, k)
-	 * where n = total trials, c = number of passes, k = sample size
-	 *
-	 * Interpretation: "Can this model solve the problem?"
-	 *
-	 * @param trials Array of boolean trial results (true = pass, false = fail)
-	 * @param k Number of trials to sample
-	 * @returns Probability [0, 1]
-	 */
-	passAtK(trials: boolean[], k: number): number {
-		const n = trials.length
-		const c = trials.filter(Boolean).length
-
-		if (n < k) {
-			throw new Error(`Cannot calculate pass@${k} with only ${n} trials`)
-		}
-
-		// If we have at least k passes, probability is 100%
-		if (c >= k) {
-			return 1.0
-		}
-
-		// Calculate: 1 - C(n-c, k) / C(n, k)
-		const numerator = this.binomial(n - c, k)
-		const denominator = this.binomial(n, k)
-
-		return 1 - numerator / denominator
-	}
-
-	/**
-	 * Calculate pass^k: Probability that ALL k trials succeed
-	 *
-	 * Formula: C(c, k) / C(n, k)
-	 * where n = total trials, c = number of passes, k = sample size
-	 *
-	 * Interpretation: "Can I rely on this model?" (reliability metric)
-	 *
-	 * @param trials Array of boolean trial results
-	 * @param k Number of trials that must all pass
-	 * @returns Probability [0, 1]
-	 */
-	passCaretK(trials: boolean[], k: number): number {
-		const n = trials.length
-		const c = trials.filter(Boolean).length
-
-		if (n < k) {
-			throw new Error(`Cannot calculate pass^${k} with only ${n} trials`)
-		}
-
-		// If we have fewer than k passes, probability is 0%
-		if (c < k) {
-			return 0.0
-		}
-
-		// Calculate: C(c, k) / C(n, k)
-		const numerator = this.binomial(c, k)
-		const denominator = this.binomial(n, k)
-
-		return numerator / denominator
-	}
-
-	/**
-	 * Calculate flakiness score: Entropy-based measure of variance
-	 *
-	 * Formula: -p*log2(p) - (1-p)*log2(1-p)
-	 * where p = pass rate
-	 *
-	 * Returns:
-	 * - 0.0: No variance (all pass or all fail)
-	 * - 1.0: Maximum variance (50% pass rate)
-	 *
-	 * Interpretation: How unpredictable/inconsistent is this task?
-	 *
-	 * @param trials Array of boolean trial results
-	 * @returns Flakiness score [0, 1]
-	 */
-	flakinessScore(trials: boolean[]): number {
-		const passRate = trials.filter(Boolean).length / trials.length
-
-		// No variance if all pass or all fail
-		if (passRate === 0 || passRate === 1) {
-			return 0
-		}
-
-		// Binary entropy
-		const entropy = -passRate * Math.log2(passRate) - (1 - passRate) * Math.log2(1 - passRate)
-
-		return entropy // Already in [0, 1] range
-	}
-
-	/**
-	 * Binomial coefficient C(n, k) = n! / (k! * (n-k)!)
-	 *
-	 * Uses iterative calculation to avoid factorial overflow
-	 *
-	 * @param n Total items
-	 * @param k Items to choose
-	 * @returns Number of ways to choose k items from n
-	 */
-	private binomial(n: number, k: number): number {
-		if (k > n) {
-			return 0
-		}
-		if (k === 0 || k === n) {
-			return 1
-		}
-
-		// Optimize by using smaller k
-		if (k > n - k) {
-			k = n - k
-		}
-
-		let result = 1
-		for (let i = 1; i <= k; i++) {
-			result *= n - i + 1
-			result /= i
-		}
-
-		return result
-	}
-
-	/**
-	 * Calculate all metrics for a task's trials
-	 *
-	 * @param trials Array of boolean trial results
-	 * @returns Object with pass@1, pass@3, pass^3, and flakiness scores
-	 */
-	calculateTaskMetrics(trials: boolean[]): {
-		passAt1: number
-		passAt3: number
-		passCaret3: number
-		flakinessScore: number
-	} {
-		if (trials.length === 0) {
-			throw new Error("Cannot calculate metrics with no trials")
-		}
-
-		// Calculate pass@k and pass^k for available trials
-		const passAt1 = trials.length >= 1 ? this.passAtK(trials, 1) : 0
-		const passAt3 = trials.length >= 3 ? this.passAtK(trials, 3) : 0
-		const passCaret3 = trials.length >= 3 ? this.passCaretK(trials, 3) : 0
-
-		return {
-			passAt1,
-			passAt3,
-			passCaret3,
-			flakinessScore: this.flakinessScore(trials),
-		}
-	}
-
-	/**
-	 * Determine task status based on trial results
-	 *
-	 * @param trials Array of boolean trial results
-	 * @returns "pass" | "fail" | "flaky"
-	 */
-	getTaskStatus(trials: boolean[]): "pass" | "fail" | "flaky" {
-		const passCount = trials.filter(Boolean).length
-		const totalCount = trials.length
-
-		if (passCount === totalCount) {
-			return "pass"
-		}
-		if (passCount === 0) {
-			return "fail"
-		}
-		return "flaky"
-	}
-}

evals/analysis/src/parsers/harbor.ts

@@ -1,301 +0,0 @@
-/**
- * Parser for Harbor framework job output
- *
- * Parses jobs/ directory structure created by Harbor to extract:
- * - Trial results (pass/fail, duration, cost, tokens)
- * - Task groupings and metrics
- * - Failure classifications
- */
-
-import * as fs from "fs"
-import * as path from "path"
-import { FailureClassifier } from "../classifier"
-import { MetricsCalculator } from "../metrics"
-import type {
-	AnalysisMetadata,
-	AnalysisOutputV1,
-	AnalysisSummary,
-	FailureAnalysis,
-	TaskResultV1,
-	TrialResultV1,
-} from "../schemas"
-
-export interface HarborParserOptions {
-	patternsPath?: string
-}
-
-export class HarborParser {
-	private classifier: FailureClassifier
-	private metrics: MetricsCalculator
-
-	constructor(options: HarborParserOptions = {}) {
-		this.classifier = new FailureClassifier(options.patternsPath)
-		this.metrics = new MetricsCalculator()
-	}
-
-	/**
-	 * Parse a complete Harbor job directory
-	 *
-	 * @param jobDir Path to job directory (e.g., jobs/2025-01-25__10-30-00/)
-	 * @returns Structured analysis output with schema version 1.0
-	 */
-	parseJob(jobDir: string): AnalysisOutputV1 {
-		const configPath = path.join(jobDir, "config.json")
-		const resultPath = path.join(jobDir, "result.json")
-
-		if (!fs.existsSync(configPath) || !fs.existsSync(resultPath)) {
-			throw new Error(`Invalid Harbor job directory: ${jobDir}`)
-		}
-
-		const config = JSON.parse(fs.readFileSync(configPath, "utf-8"))
-		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"))
-
-		// Find all trial directories
-		const trialDirs = this.findTrialDirectories(jobDir)
-		const trials = trialDirs.map((dir) => this.parseTrialDirectory(dir))
-
-		// Group trials by task ID
-		const taskResults = this.groupTrialsByTask(trials)
-
-		// Calculate aggregate metrics
-		const summary = this.calculateSummary(taskResults)
-
-		// Analyze failures
-		const failures = this.analyzeFailures(taskResults)
-
-		const metadata: AnalysisMetadata = {
-			generated_at: new Date().toISOString(),
-			analysis_version: "1.0.0", // TODO: Get from package.json
-			job_id: path.basename(jobDir),
-			model: config.model,
-			agent: config.agent || "cline-cli",
-			environment: config.environment || "docker",
-		}
-
-		return {
-			schema_version: "1.0",
-			metadata,
-			summary,
-			tasks: taskResults,
-			failures,
-		}
-	}
-
-	/**
-	 * Find all trial directories in a job
-	 */
-	private findTrialDirectories(jobDir: string): string[] {
-		const entries = fs.readdirSync(jobDir, { withFileTypes: true })
-
-		return entries
-			.filter((entry) => entry.isDirectory())
-			.filter((entry) => {
-				// Trial dirs have format: 01k7a12s...disco__fhSEuhr
-				const configExists = fs.existsSync(path.join(jobDir, entry.name, "config.json"))
-				return configExists
-			})
-			.map((entry) => path.join(jobDir, entry.name))
-	}
-
-	/**
-	 * Parse a single trial directory
-	 */
-	private parseTrialDirectory(trialDir: string): ParsedTrial {
-		const configPath = path.join(trialDir, "config.json")
-		const resultPath = path.join(trialDir, "result.json")
-		const rewardPath = path.join(trialDir, "verifier", "reward.txt")
-		const logsPath = path.join(trialDir, "agent", "cline.txt")
-		const testOutputPath = path.join(trialDir, "verifier", "test-stdout.txt")
-
-		const config = JSON.parse(fs.readFileSync(configPath, "utf-8"))
-		const result = JSON.parse(fs.readFileSync(resultPath, "utf-8"))
-		const reward = fs.readFileSync(rewardPath, "utf-8").trim()
-		const logs = fs.existsSync(logsPath) ? fs.readFileSync(logsPath, "utf-8") : ""
-		const testOutput = fs.existsSync(testOutputPath) ? fs.readFileSync(testOutputPath, "utf-8") : ""
-
-		const passed = reward === "1"
-		const failures = passed ? [] : this.classifier.classify(logs)
-
-		return {
-			taskId: config.task_id,
-			trialHash: path.basename(trialDir).split("__")[1] || "",
-			passed,
-			duration: result.duration_sec || 0,
-			cost: result.cost_usd || 0,
-			tokensIn: result.tokens_in,
-			tokensOut: result.tokens_out,
-			logs,
-			testOutput,
-			failures,
-		}
-	}
-
-	/**
-	 * Group trials by task ID and calculate metrics
-	 */
-	private groupTrialsByTask(trials: ParsedTrial[]): TaskResultV1[] {
-		const taskMap = new Map<string, ParsedTrial[]>()
-
-		// Group trials by task ID
-		for (const trial of trials) {
-			const existing = taskMap.get(trial.taskId) || []
-			existing.push(trial)
-			taskMap.set(trial.taskId, existing)
-		}
-
-		// Convert to TaskResultV1 format
-		const taskResults: TaskResultV1[] = []
-
-		for (const [taskId, taskTrials] of taskMap.entries()) {
-			const trialResults: TrialResultV1[] = taskTrials.map((trial, index) => ({
-				trial_index: index,
-				trial_hash: trial.trialHash,
-				passed: trial.passed,
-				duration_sec: trial.duration,
-				cost_usd: trial.cost,
-				tokens_in: trial.tokensIn,
-				tokens_out: trial.tokensOut,
-				failures: trial.failures,
-			}))
-
-			const passResults = taskTrials.map((t) => t.passed)
-			const metrics = this.metrics.calculateTaskMetrics(passResults)
-			const status = this.metrics.getTaskStatus(passResults)
-
-			const totalCost = taskTrials.reduce((sum, t) => sum + t.cost, 0)
-			const avgDuration = taskTrials.reduce((sum, t) => sum + t.duration, 0) / taskTrials.length
-
-			// Extract readable task name from ID
-			const taskName = this.extractTaskName(taskId)
-
-			taskResults.push({
-				task_id: taskId,
-				task_name: taskName,
-				trials: trialResults,
-				metrics,
-				status,
-				total_cost_usd: totalCost,
-				avg_duration_sec: avgDuration,
-			})
-		}
-
-		return taskResults.sort((a, b) => a.task_name.localeCompare(b.task_name))
-	}
-
-	/**
-	 * Extract human-readable task name from task ID
-	 * Example: 01k7a12sd1nk15j08e6x0x7v9e-discord-trivia-approval-keyerror → discord-trivia
-	 */
-	private extractTaskName(taskId: string): string {
-		const parts = taskId.split("-")
-		if (parts.length > 1) {
-			// Remove the ID prefix and get first 2-3 meaningful words
-			const words = parts.slice(1, 4)
-			return words.join("-")
-		}
-		return taskId
-	}
-
-	/**
-	 * Calculate aggregate summary metrics
-	 */
-	private calculateSummary(taskResults: TaskResultV1[]): AnalysisSummary {
-		const totalTasks = taskResults.length
-		const totalTrials = taskResults.reduce((sum, task) => sum + task.trials.length, 0)
-
-		// Calculate overall pass@k metrics
-		const allTrials = taskResults.flatMap((task) => task.trials.map((t) => t.passed))
-		let passAt1 = 0
-		let passAt3 = 0
-		let passCaret3 = 0
-
-		if (allTrials.length >= 1) {
-			passAt1 = this.metrics.passAtK(allTrials, 1)
-		}
-		if (allTrials.length >= 3) {
-			passAt3 = this.metrics.passAtK(allTrials, 3)
-			passCaret3 = this.metrics.passCaretK(allTrials, 3)
-		}
-
-		const totalCost = taskResults.reduce((sum, task) => sum + task.total_cost_usd, 0)
-		const totalDuration = taskResults.reduce((sum, task) => sum + task.avg_duration_sec * task.trials.length, 0)
-
-		const flakyTaskCount = taskResults.filter((task) => task.status === "flaky").length
-
-		return {
-			total_tasks: totalTasks,
-			total_trials: totalTrials,
-			pass_at_1: passAt1,
-			pass_at_3: passAt3,
-			pass_caret_3: passCaret3,
-			total_cost_usd: totalCost,
-			total_duration_sec: totalDuration,
-			flaky_task_count: flakyTaskCount,
-		}
-	}
-
-	/**
-	 * Analyze failure patterns across all tasks
-	 */
-	private analyzeFailures(taskResults: TaskResultV1[]): FailureAnalysis {
-		const categoryCount = new Map<string, number>()
-		const patternCount = new Map<string, { count: number; issue_url?: string; examples: any[] }>()
-
-		for (const task of taskResults) {
-			for (const trial of task.trials) {
-				if (!trial.passed) {
-					for (const failure of trial.failures) {
-						// Count by category
-						categoryCount.set(failure.category, (categoryCount.get(failure.category) || 0) + 1)
-
-						// Count by pattern
-						const existing = patternCount.get(failure.name) || {
-							count: 0,
-							issue_url: failure.issue_url,
-							examples: [],
-						}
-						existing.count++
-
-						// Add example if not too many
-						if (existing.examples.length < 3) {
-							existing.examples.push({
-								task_id: task.task_id,
-								trial_index: trial.trial_index,
-								excerpt: failure.excerpt,
-							})
-						}
-
-						patternCount.set(failure.name, existing)
-					}
-				}
-			}
-		}
-
-		const byCategory: Record<string, number> = {}
-		for (const [category, count] of categoryCount.entries()) {
-			byCategory[category] = count
-		}
-
-		const byPattern = Array.from(patternCount.entries()).map(([name, data]) => ({
-			name,
-			count: data.count,
-			issue_url: data.issue_url,
-			examples: data.examples,
-		}))
-
-		return { by_category: byCategory as any, by_pattern: byPattern }
-	}
-}
-
-interface ParsedTrial {
-	taskId: string
-	trialHash: string
-	passed: boolean
-	duration: number
-	cost: number
-	tokensIn?: number
-	tokensOut?: number
-	logs: string
-	testOutput: string
-	failures: any[]
-}

evals/analysis/src/parsers/index.ts

@@ -1,8 +0,0 @@
-/**
- * Parser exports for Cline Analysis Framework
- *
- * Parsers for different benchmark types:
- * - Harbor: Real-world tasks via cline-bench
- */
-
-export * from "./harbor"

evals/analysis/src/reporters/index.ts

@@ -1,10 +0,0 @@
-/**
- * Reporter exports for Cline Analysis Framework
- *
- * Available reporters:
- * - JsonReporter: Structured JSON output with schema validation
- * - MarkdownReporter: Human-readable terminal reports
- */
-
-export * from "./json"
-export * from "./markdown"