.dockerignore

@@ -1,5 +1,3 @@
-# Do NOT exclude LICENSE or .github — scripts/copydir.go uses them as repo-root anchors
-# during `go generate`, which runs inside `make build` in the Dockerfile.
 .git
 .gitignore
 build/
@@ -8,4 +6,5 @@ config/
 .env
 .env.example
 *.md
+LICENSE
 assets/

.env.example

@@ -5,18 +5,16 @@
 # ANTHROPIC_API_KEY=sk-ant-xxx
 # OPENAI_API_KEY=sk-xxx
 # GEMINI_API_KEY=xxx
-# MODELSCOPE_API_KEY=xxx
+# CEREBRAS_API_KEY=xxx
-# CLAUDE_CODE_OAUTH=xxx
+
 # ── Chat Channel ──────────────────────────
 # TELEGRAM_BOT_TOKEN=123456:ABC...
 # DISCORD_BOT_TOKEN=xxx
-# Feishu (飞书)
+# LINE_CHANNEL_SECRET=xxx
-# PICOCLAW_CHANNELS_FEISHU_APP_ID=cli_xxx
+# LINE_CHANNEL_ACCESS_TOKEN=xxx
-# PICOCLAW_CHANNELS_FEISHU_APP_SECRET=xxx
-# PICOCLAW_CHANNELS_FEISHU_RANDOM_REACTION_EMOJI=Typing,OneSecond
 
 # ── Web Search (optional) ────────────────
 # BRAVE_SEARCH_API_KEY=BSA...
 
 # ── Timezone ──────────────────────────────
-TZ=Asia/Shanghai
+TZ=Asia/Tokyo

.gitattributes

@@ -1,3 +0,0 @@
-# Ensure shell scripts always use LF line endings regardless of OS.
-*.sh text eol=lf
-docker/entrypoint.sh text eol=lf

.github/dependabot.yml

@@ -1,27 +0,0 @@
-version: 2
-
-updates:
-
-  # Go dependencies (entire repo)
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    labels:
-      - "dependencies"
-      - "go"
-
-  # Frontend dependencies
-  - package-ecosystem: "npm"
-    directory: "/web/frontend"
-    schedule:
-      interval: "weekly"
-    labels:
-      - "dependencies"
-      - "frontend"
-
-  # GitHub Actions
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "weekly"

.github/workflows/build.yml

@@ -5,18 +5,7 @@ on:
     branches: [ "main" ]
 
 jobs:
-  integration:
-    name: Integration Tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Run Docker-backed integration suites
-        run: bash ./scripts/run-integration-tests.sh
-
   build:
-    needs: integration
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
@@ -27,5 +16,5 @@ jobs:
         with:
           go-version-file: go.mod
 
-      - name: Build core binaries
+      - name: Build
         run: make build-all

.github/workflows/create-tag.yml

@@ -1,60 +0,0 @@
-name: Create Tag
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Tag name (required, e.g. v0.2.0)"
-        required: true
-        type: string
-      commit:
-        description: "Target commit SHA (leave empty for latest main)"
-        required: false
-        type: string
-        default: ""
-
-jobs:
-  create-tag:
-    name: Create Git Tag
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-          ref: main
-
-      - name: Validate commit exists
-        if: ${{ inputs.commit != '' }}
-        shell: bash
-        run: |
-          if ! git cat-file -t "${{ inputs.commit }}" &>/dev/null; then
-            echo "::error::Commit '${{ inputs.commit }}' does not exist."
-            exit 1
-          fi
-
-      - name: Check tag does not already exist
-        shell: bash
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          if gh api "repos/${{ github.repository }}/git/ref/tags/${{ inputs.tag }}" --silent 2>/dev/null; then
-            echo "::error::Tag '${{ inputs.tag }}' already exists."
-            exit 1
-          fi
-
-      - name: Create and push tag
-        shell: bash
-        run: |
-          TARGET="${{ inputs.commit || 'HEAD' }}"
-          COMMIT_SHA=$(git rev-parse "$TARGET")
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git tag -a "${{ inputs.tag }}" "$COMMIT_SHA" -m "Release ${{ inputs.tag }}"
-          git push origin "${{ inputs.tag }}"
-          echo "### Tag Created" >> "$GITHUB_STEP_SUMMARY"
-          echo "- **Tag:** \`${{ inputs.tag }}\`" >> "$GITHUB_STEP_SUMMARY"
-          echo "- **Commit:** \`${COMMIT_SHA}\`" >> "$GITHUB_STEP_SUMMARY"
-          echo "- **Branch:** \`$(git branch -r --contains "$COMMIT_SHA" | head -1 | xargs)\`" >> "$GITHUB_STEP_SUMMARY"

.github/workflows/create_dmg.yml

@@ -1,71 +0,0 @@
-name: Create macOS DMG
-on:
-  workflow_dispatch:
-
-jobs:
-  build:
-    name: Build ${{ matrix.arch }}
-    runs-on: macos-latest
-    strategy:
-      matrix:
-        # This creates two parallel jobs
-        arch: [arm64, amd64]
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          ref: main
-
-      # 1. Install Go from go.mod
-      - name: Setup Go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: go.mod
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10.33.0
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 22
-          cache: pnpm
-          cache-dependency-path: web/frontend/pnpm-lock.yaml
-
-      # 3. Build the application bundle
-      - name: Build with Make
-        run: make build ARCH=${{ matrix.arch }} && make build-macos-app ARCH=${{ matrix.arch }}
-
-      # 4. Apply ad-hoc signing
-      - name: Ad-hoc Sign
-        run: codesign --force --deep --sign - "build/PicoClaw Launcher.app"
-
-      # 5. Install the DMG packaging tool
-      - name: Install create-dmg
-        run: brew install create-dmg
-
-      # 6. Create the DMG
-      - name: Create DMG
-        run: |
-          mkdir -p dist
-          create-dmg \
-            --volname "PicoClaw Installer" \
-            --window-pos 200 120 \
-            --window-size 800 400 \
-            --icon-size 100 \
-            --icon "PicoClaw Launcher.app" 200 190 \
-            --hide-extension "PicoClaw Launcher.app" \
-            --app-drop-link 600 185 \
-            "dist/picoclaw-${{ matrix.arch }}.dmg" \
-            "build/PicoClaw Launcher.app"
-
-      # 7. Upload the DMG as a GitHub artifact
-      - name: Upload DMG
-        uses: actions/upload-artifact@v7
-        with:
-          name: macos-dmg-${{ matrix.arch }}
-          path: dist/*.dmg

.github/workflows/docker-build.yml

@@ -31,11 +31,11 @@ jobs:
 
       # ── Docker Buildx ─────────────────────────
       - name: 🔧 Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
 
       # ── Login to GHCR ─────────────────────────
       - name: 🔑 Login to GitHub Container Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ${{ env.GHCR_REGISTRY }}
           username: ${{ github.actor }}
@@ -43,7 +43,7 @@ jobs:
 
       # ── Login to Docker Hub ────────────────────
       - name: 🔑 Login to Docker Hub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ${{ env.DOCKERHUB_REGISTRY }}
           username: ${{ secrets.DOCKERHUB_USERNAME }}
@@ -62,7 +62,7 @@ jobs:
 
       # ── Build & Push ──────────────────────────
       - name: 🚀 Build and push Docker image
-        uses: docker/build-push-action@v7
+        uses: docker/build-push-action@v6
         with:
           context: .
           push: true

.github/workflows/nightly.yml

@@ -1,146 +0,0 @@
-name: Nightly Build
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  nightly:
-    name: Nightly Build
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      packages: write
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - name: Compute version
-        id: version
-        run: |
-          DATE=$(date -u +%Y%m%d)
-          SHA=$(git rev-parse --short=8 HEAD)
-          BASE_VERSION=$(git describe --tags --match "v*" --exclude "*nightly*" --abbrev=0 2>/dev/null || true)
-          if [ -z "$BASE_VERSION" ] || [ "$BASE_VERSION" = "v0.0.0" ]; then
-            VERSION="v0.0.0-nightly.${DATE}.${SHA}"
-          else
-            VERSION="${BASE_VERSION}-nightly.${DATE}.${SHA}"
-          fi
-
-          COMPARE_URL="https://github.com/${{ github.repository }}/commits/main"
-          if [ -n "$BASE_VERSION" ] && [ "$BASE_VERSION" != "v0.0.0" ]; then
-            COMPARE_URL="https://github.com/${{ github.repository }}/compare/${BASE_VERSION}...main"
-          fi
-
-          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
-          echo "changelog=**Full Changelog**: $COMPARE_URL" >> "$GITHUB_OUTPUT"
-
-      - name: Setup Go from go.mod
-        id: setup-go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: go.mod
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10.33.0
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 22
-          cache: pnpm
-          cache-dependency-path: web/frontend/pnpm-lock.yaml
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Login to Docker Hub
-        uses: docker/login-action@v4
-        with:
-          registry: docker.io
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Install zip
-        run: sudo apt-get install -y zip
-
-      - name: Create local tag for GoReleaser
-        run: git tag "${{ steps.version.outputs.version }}"
-
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v7
-        with:
-          distribution: goreleaser
-          version: ~> v2
-          args: release --clean
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
-          DOCKERHUB_IMAGE_NAME: ${{ vars.DOCKERHUB_REPOSITORY }}
-          GOVERSION: ${{ steps.setup-go.outputs.go-version }}
-          GORELEASER_CURRENT_TAG: ${{ steps.version.outputs.version }}
-          INCLUDE_ANDROID_BUNDLE: "true"
-          NIGHTLY_BUILD: "true"
-          MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }}
-          MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }}
-          MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }}
-          MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }}
-          MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }}
-
-      - name: Update nightly release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          VERSION: ${{ steps.version.outputs.version }}
-        run: |
-          CHANGELOG='${{ steps.version.outputs.changelog }}'
-          NOTES=$(cat <<EOF
-          Nightly build for **${VERSION}**
-
-          This is an automated build and may be unstable. Use with caution.
-
-          ${CHANGELOG}
-          EOF
-          )
-
-          # Delete existing nightly release and tag
-          gh release delete nightly --cleanup-tag -y 2>/dev/null || true
-
-          # Force-update nightly tag to current HEAD
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git tag -fa nightly -m "Nightly build ${VERSION}"
-          git push origin nightly
-
-          # Collect release artifacts from goreleaser dist/
-          ASSETS=()
-          for f in dist/*.tar.gz dist/*.zip dist/*.deb dist/*.rpm dist/checksums.txt build/picoclaw-android-universal.zip; do
-            [ -f "$f" ] && ASSETS+=("$f")
-          done
-
-          # Create nightly release (prerelease, NOT latest)
-          gh release create nightly \
-            --title "Nightly Build" \
-            --notes "$NOTES" \
-            --target "${{ github.sha }}" \
-            --prerelease \
-            --latest=false \
-            "${ASSETS[@]}"

.github/workflows/pr.yml

@@ -23,29 +23,6 @@ jobs:
         uses: golangci/golangci-lint-action@v9
         with:
           version: v2.10.1
-          args: --build-tags=goolm,stdjson
-
-  vuln_check:
-    name: Security Check
-    runs-on: ubuntu-latest
-    env:
-      GOFLAGS: -tags=goolm,stdjson
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-        with:
-          persist-credentials: false
-
-      - name: Setup Go
-        uses: actions/setup-go@v6
-        with:
-          go-version-file: go.mod
-
-      - name: Install govulncheck
-        run: go install golang.org/x/vuln/cmd/govulncheck@v1.1.4
-
-      - name: Run Govulncheck
-        run: govulncheck -C . -format text ./...
 
   test:
     name: Tests
@@ -63,14 +40,4 @@ jobs:
         run: go generate ./...
 
       - name: Run go test
-        run: go test -tags goolm,stdjson ./...
+        run: go test ./...
-
-  integration:
-    name: Integration Tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Run Docker-backed integration suites
-        run: bash ./scripts/run-integration-tests.sh

.github/workflows/release.yml

@@ -1,10 +1,10 @@
-name: Release
+name: Create Tag and Release
 
 on:
   workflow_dispatch:
     inputs:
       tag:
-        description: "Existing tag to release (e.g. v0.2.0)"
+        description: "Release tag (required, e.g. v0.2.0)"
         required: true
         type: string
       prerelease:
@@ -17,30 +17,37 @@ on:
         required: false
         type: boolean
         default: false
-      upload_tos:
-        description: "Upload to Volcengine TOS"
-        required: false
-        type: boolean
-        default: true
 
 jobs:
+  create-tag:
+    name: Create Git Tag
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Create and push tag
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ inputs.tag }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag -a "$RELEASE_TAG" -m "Release $RELEASE_TAG"
+          git push origin "$RELEASE_TAG"
+
   release:
     name: GoReleaser Release
+    needs: create-tag
     runs-on: ubuntu-latest
     permissions:
       contents: write
       packages: write
     steps:
-      - name: Verify tag exists
-        shell: bash
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          if ! gh api "repos/${{ github.repository }}/git/ref/tags/${{ inputs.tag }}" --silent 2>/dev/null; then
-            echo "::error::Tag '${{ inputs.tag }}' does not exist. Create it first using the 'Create Tag' workflow."
-            exit 1
-          fi
-
       - name: Checkout tag
         uses: actions/checkout@v6
         with:
@@ -53,44 +60,28 @@ jobs:
         with:
           go-version-file: go.mod
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v6
-        with:
-          version: 10.33.0
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 22
-          cache: pnpm
-          cache-dependency-path: web/frontend/pnpm-lock.yaml
-
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Login to Docker Hub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
         with:
           registry: docker.io
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Install zip
-        run: sudo apt-get install -y zip
-
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v7
+        uses: goreleaser/goreleaser-action@v6
         with:
           distribution: goreleaser
           version: ~> v2
@@ -100,12 +91,6 @@ jobs:
           GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
           DOCKERHUB_IMAGE_NAME: ${{ vars.DOCKERHUB_REPOSITORY }}
           GOVERSION: ${{ steps.setup-go.outputs.go-version }}
-          INCLUDE_ANDROID_BUNDLE: "true"
-          MACOS_SIGN_P12: ${{ secrets.MACOS_SIGN_P12 }}
-          MACOS_SIGN_PASSWORD: ${{ secrets.MACOS_SIGN_PASSWORD }}
-          MACOS_NOTARY_ISSUER_ID: ${{ secrets.MACOS_NOTARY_ISSUER_ID }}
-          MACOS_NOTARY_KEY_ID: ${{ secrets.MACOS_NOTARY_KEY_ID }}
-          MACOS_NOTARY_KEY: ${{ secrets.MACOS_NOTARY_KEY }}
 
       - name: Apply release flags
         shell: bash
@@ -115,12 +100,3 @@ jobs:
           gh release edit "${{ inputs.tag }}" \
             --draft=${{ inputs.draft }} \
             --prerelease=${{ inputs.prerelease }}
-
-  upload-tos:
-    name: Upload to TOS
-    needs: release
-    if: ${{ inputs.upload_tos }}
-    uses: ./.github/workflows/upload-tos.yml
-    with:
-      tag: ${{ inputs.tag }}
-    secrets: inherit

.github/workflows/stale.yml

@@ -1,64 +0,0 @@
-name: Close stale issues and PRs
-
-on:
-  schedule:
-    # Run daily at 03:00 JST (18:00 UTC)
-    - cron: "0 18 * * *"
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Mark and close stale issues and PRs
-        uses: actions/stale@v10
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-
-          # ── Issue: 7 days inactive → stale; 7 more days → close ──
-          days-before-issue-stale: 7
-          days-before-issue-close: 7
-          stale-issue-label: "stale"
-          stale-issue-message: >
-            This issue has had no activity for 7 days and has been marked as stale.
-            If it is still relevant, please reply or update; otherwise it will be
-            closed automatically in 7 days.
-          close-issue-message: >
-            This issue has been closed after 14 days of inactivity.
-            If it is still needed, feel free to reopen it anytime.
-          close-issue-reason: "not_planned"
-
-          # ── PR: 7 days inactive → stale; 7 more days → close ──
-          days-before-pr-stale: 7
-          days-before-pr-close: 7
-          stale-pr-label: "stale"
-          stale-pr-message: >
-            This PR has had no activity for 7 days and has been marked as stale.
-            If you are still working on it, please push an update or leave a comment;
-            otherwise it will be closed automatically in 7 days.
-          close-pr-message: >
-            This PR has been closed after 14 days of inactivity.
-            If you would like to continue, feel free to reopen it or submit a new PR.
-
-          # ── Protected labels (exempt from stale processing) ──
-          exempt-issue-labels: "pinned,keep-open,wip,do-not-close,type: roadmap"
-          exempt-pr-labels: "pinned,keep-open,wip,do-not-close,type: roadmap"
-
-          # ── Exempt draft PRs ──
-          exempt-draft-pr: true
-
-          # ── Remove stale label when activity resumes ──
-          remove-stale-when-updated: true
-          remove-issue-stale-when-updated: true
-          remove-pr-stale-when-updated: true
-
-          # ── Scan oldest items first so old stale items are not starved ──
-          ascending: true
-
-          # ── Throttle: max operations per run ──
-          operations-per-run: 500

.github/workflows/upload-tos.yml

@@ -1,49 +0,0 @@
-name: Upload to Volcengine TOS
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "Release tag to download and upload (e.g. v0.2.0)"
-        required: true
-        type: string
-  workflow_call:
-    inputs:
-      tag:
-        description: "Release tag to download and upload"
-        required: true
-        type: string
-
-jobs:
-  upload-tos:
-    name: Upload to Volcengine TOS
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download release assets
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          mkdir -p artifacts
-          gh release download "${{ inputs.tag }}" \
-            --repo "${{ github.repository }}" \
-            --dir artifacts \
-            --pattern "*.tar.gz" \
-            --pattern "*.zip" \
-            --pattern "*.rpm" \
-            --pattern "*.deb"
-
-      - name: Upload to Volcengine TOS
-        env:
-          AWS_ACCESS_KEY_ID: ${{ secrets.VOLC_TOS_ACCESS_KEY }}
-          AWS_SECRET_ACCESS_KEY: ${{ secrets.VOLC_TOS_SECRET_KEY }}
-          AWS_DEFAULT_REGION: cn-beijing
-        run: |
-          aws configure set default.s3.addressing_style virtual
-          TOS_ENDPOINT="https://tos-s3-cn-beijing.volces.com"
-          # Upload to versioned directory
-          aws s3 sync artifacts/ "s3://picoclaw-downloads/${{ inputs.tag }}/" \
-            --endpoint-url "$TOS_ENDPOINT"
-          # Upload to latest (overwrite)
-          aws s3 sync artifacts/ "s3://picoclaw-downloads/latest/" \
-            --endpoint-url "$TOS_ENDPOINT" \
-            --delete

.gitignore

@@ -25,9 +25,6 @@ build/
 # Secrets & Config (keep templates, ignore actual secrets)
 .env
 config/config.json
-.security.yml
-onboard
-
 
 # Test
 coverage.txt
@@ -41,35 +38,9 @@ ralph/
 .ralph/
 tasks/
 
-# Plans
-docs/plans/
-docs/superpowers/
-
 # Editors
 .vscode/
 .idea/
 
 # Added by goreleaser init:
 dist/
-*.vite/
-
-# Windows Application Icon/Resource
-*.syso
-.cache/
-web/frontend/.pnpm-store/
-_tmp_*
-web/frontend/_tmp_*
-
-# Test telegram integration
-cmd/telegram/
-
-# Keep embedded backend dist directory placeholder in VCS
-!web/backend/dist/
-web/backend/dist/*
-!web/backend/dist/.gitkeep
-
-.claude/
-
-docker/data
-
-.omc/

.golangci.yaml

@@ -7,12 +7,12 @@ linters:
     - containedctx
     - cyclop
     - depguard
+    - dupl
     - dupword
     - err113
     - exhaustruct
     - funcorder
     - gochecknoglobals
-    - gosmopolitan  # Project legitimately uses CJK text in tests (FTS5, token counting)
     - godot
     - intrange
     - ireturn
@@ -62,9 +62,6 @@ linters:
     - usestdlibvars
     - usetesting
   settings:
-    gomoddirectives:
-      replace-allow-list:
-        - github.com/bwmarrin/discordgo
     errcheck:
       check-type-assertions: true
       check-blank: true

.goreleaser.yaml

@@ -2,103 +2,40 @@
 # vim: set ts=2 sw=2 tw=0 fo=cnqoj
 version: 2
 
-git:
-  ignore_tags:
-    - nightly
-    - ".*-nightly.*"
-
 before:
   hooks:
-    - go generate ./...
+    - go mod tidy
-    - sh -c 'cd web/frontend && CI=true pnpm install --frozen-lockfile && pnpm build:backend'
+    - go generate ./cmd/picoclaw/...
-    - sh -c 'GOBIN="$(go env GOPATH)/bin"; mkdir -p "$GOBIN"; go install github.com/tc-hib/go-winres@v0.3.3 && "$GOBIN/go-winres" make --in web/backend/winres/winres.json --out web/backend/rsrc --product-version={{ .Version }} --file-version={{ .Version }}'
-    - sh -c 'if [ "${INCLUDE_ANDROID_BUNDLE:-}" = "true" ]; then make build-android-bundle; fi'
 
 builds:
   - id: picoclaw
     env:
       - CGO_ENABLED=0
     tags:
-      - goolm
       - stdjson
     ldflags:
       - -s -w
-      - -X github.com/sipeed/picoclaw/pkg/config.Version={{ .Version }}
+      - -X github.com/sipeed/picoclaw/cmd/picoclaw/internal.version={{ .Version }}
-      - -X github.com/sipeed/picoclaw/pkg/config.GitCommit={{ .ShortCommit }}
+      - -X github.com/sipeed/picoclaw/cmd/picoclaw/internal.gitCommit={{ .ShortCommit }}
-      - -X github.com/sipeed/picoclaw/pkg/config.BuildTime={{ .Date }}
+      - -X github.com/sipeed/picoclaw/cmd/picoclaw/internal.buildTime={{ .Date }}
-      - -X github.com/sipeed/picoclaw/pkg/config.GoVersion={{ with index .Env "GOVERSION" }}{{ . }}{{ else }}unknown{{ end }}
+      - -X github.com/sipeed/picoclaw/cmd/picoclaw/internal.goVersion={{ .Env.GOVERSION }}
     goos:
       - linux
       - windows
       - darwin
       - freebsd
-      - netbsd
     goarch:
       - amd64
       - arm64
       - riscv64
       - loong64
       - arm
-      - s390x
-      - mipsle
     goarm:
-      - "6"
       - "7"
-    gomips:
-      - softfloat
     main: ./cmd/picoclaw
     ignore:
       - goos: windows
         goarch: arm
-      - goos: netbsd
-        goarch: s390x
-      - goos: netbsd
-        goarch: mips64
-      - goos: netbsd
-        goarch: arm
-
-  - id: picoclaw-launcher
-    binary: picoclaw-launcher
-    env:
-      - CGO_ENABLED=0
-    tags:
-      - goolm
-      - stdjson
-    ldflags:
-      - -s -w
-      - -X github.com/sipeed/picoclaw/pkg/config.Version={{ .Version }}
-      - -X github.com/sipeed/picoclaw/pkg/config.GitCommit={{ .ShortCommit }}
-      - -X github.com/sipeed/picoclaw/pkg/config.BuildTime={{ .Date }}
-      - -X github.com/sipeed/picoclaw/pkg/config.GoVersion={{ with index .Env "GOVERSION" }}{{ . }}{{ else }}unknown{{ end }}
-    goos:
-      - linux
-      - windows
-      - darwin
-      - freebsd
-      - netbsd
-    goarch:
-      - amd64
-      - arm64
-      - riscv64
-      - loong64
-      - arm
-      - s390x
-      - mipsle
-    goarm:
-      - "6"
-      - "7"
-    gomips:
-      - softfloat
-    main: ./web/backend
-    ignore:
-      - goos: windows
-        goarch: arm
-      - goos: netbsd
-        goarch: s390x
-      - goos: netbsd
-        goarch: mips64
-      - goos: netbsd
-        goarch: arm
 
 dockers_v2:
   - id: picoclaw
@@ -109,47 +46,15 @@ dockers_v2:
       - picoclaw
     images:
       - "ghcr.io/{{ .Env.GITHUB_REPOSITORY_OWNER }}/picoclaw"
-      - 'docker.io/{{ .Env.DOCKERHUB_IMAGE_NAME }}'
+      - "docker.io/{{ .Env.DOCKERHUB_IMAGE_NAME }}"
     tags:
-      - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly{{ else }}{{ .Tag }}{{ end }}'
+      - "{{ .Tag }}"
-      - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly{{ else }}latest{{ end }}'
+      - "latest"
     platforms:
       - linux/amd64
       - linux/arm64
       - linux/riscv64
 
-  - id: picoclaw-launcher
-    dockerfile: docker/Dockerfile.goreleaser.launcher
-    ids:
-      - picoclaw
-      - picoclaw-launcher
-    images:
-      - "ghcr.io/{{ .Env.GITHUB_REPOSITORY_OWNER }}/picoclaw"
-      - 'docker.io/{{ .Env.DOCKERHUB_IMAGE_NAME }}'
-    tags:
-      - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly-launcher{{ else }}{{ .Tag }}-launcher{{ end }}'
-      - '{{ if isEnvSet "NIGHTLY_BUILD" }}nightly-launcher{{ else }}launcher{{ end }}'
-    platforms:
-      - linux/amd64
-      - linux/arm64
-      - linux/riscv64
-
-notarize:
-  macos:
-    - enabled: '{{ isEnvSet "MACOS_SIGN_P12" }}'
-      ids:
-        - picoclaw
-        - picoclaw-launcher
-      sign:
-        certificate: "{{.Env.MACOS_SIGN_P12}}"
-        password: "{{.Env.MACOS_SIGN_PASSWORD}}"
-      notarize:
-        issuer_id: "{{.Env.MACOS_NOTARY_ISSUER_ID}}"
-        key_id: "{{.Env.MACOS_NOTARY_KEY_ID}}"
-        key: "{{.Env.MACOS_NOTARY_KEY}}"
-        wait: true
-        timeout: 20m
-
 archives:
   - formats: [tar.gz]
     # this name template makes the OS and Arch compatible with the results of `uname`.
@@ -167,9 +72,6 @@ archives:
 
 nfpms:
   - id: picoclaw
-    ids:
-      - picoclaw
-      - picoclaw-launcher
     package_name: picoclaw
     file_name_template: >-
       {{ .PackageName }}_
@@ -186,11 +88,6 @@ nfpms:
       - rpm
       - deb
     bindir: /usr/bin
-    contents:
-      - src: web/picoclaw-launcher.desktop
-        dst: /usr/share/applications/picoclaw-launcher.desktop
-      - src: web/picoclaw-launcher.png
-        dst: /usr/share/icons/hicolor/512x512/apps/picoclaw-launcher.png
 
 changelog:
   sort: asc
@@ -205,9 +102,6 @@ changelog:
 #      lzma: true
 
 release:
-  disable: '{{ isEnvSet "NIGHTLY_BUILD" }}'
-  extra_files:
-    - glob: ./build/picoclaw-android-universal.zip
   footer: >-
 
     ---

CONTRIBUTING.md

@@ -35,8 +35,6 @@ We are committed to maintaining a welcoming and respectful community. Be kind, c
 
 For substantial new features, please open an issue first to discuss the design before writing code. This prevents wasted effort and ensures alignment with the project's direction.
 
-For documentation contributions, prefer the layout and naming conventions in [`docs/README.md`](docs/README.md). Run `make lint-docs` after adding or moving Markdown files to catch common consistency issues early.
-
 ---
 
 ## Getting Started
@@ -66,30 +64,26 @@ For documentation contributions, prefer the layout and naming conventions in [`d
 ```bash
 make build       # Build binary (runs go generate first)
 make generate    # Run go generate only
-make check       # Full pre-commit check: deps + fmt + vet + test + docs consistency checks
+make check       # Full pre-commit check: deps + fmt + vet + test
 ```
 
 ### Running Tests
 
 ```bash
 make test                                    # Run all tests
-make integration-test                        # Run Docker-backed integration suites
 go test -run TestName -v ./pkg/session/      # Run a single test
 go test -bench=. -benchmem -run='^$' ./...  # Run benchmarks
 ```
 
-Docker-backed integration suites are auto-discovered from [`integration/suites/`](integration/suites/). See [`integration/README.md`](integration/README.md) for the suite layout and the conventions used by CI.
-
 ### Code Style
 
 ```bash
 make fmt   # Format code
 make vet   # Static analysis
 make lint  # Full linter run
-make lint-docs  # Check common documentation layout and naming conventions
 ```
 
-All CI checks must pass before a PR can be merged. Run `make check` locally before pushing to catch issues early, including the common docs consistency checks from `make lint-docs`.
+All CI checks must pass before a PR can be merged. Run `make check` locally before pushing to catch issues early.
 
 ---
 
@@ -114,7 +108,7 @@ Use descriptive branch names, e.g. `fix/telegram-timeout`, `feat/ollama-provider
 - Reference the related issue when relevant: `Fix session leak (#123)`.
 - Keep commits focused. One logical change per commit is preferred.
 - For minor cleanups or typo fixes, squash them into a single commit before opening a PR.
-- Refer to [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/)
+- Refer to https://www.conventionalcommits.org/zh-hans/v1.0.0/
 
 ### Keeping Up to Date
 
@@ -275,8 +269,8 @@ Once your PR is submitted, you can reach out to the assigned reviewers listed in
 |Function| Reviewer|
 |---     |---      |
 |Provider|@yinwm   |
-|Channel |@yinwm/@alexhoshina   |
+|Channel |@yinwm   |
-|Agent   |@lxowalle/@Zhaoyikaiii|
+|Agent   |@lxowalle|
 |Tools   |@lxowalle|
 |SKill   ||
 |MCP     ||

CONTRIBUTING.zh.md

@@ -108,7 +108,7 @@ git checkout -b 你的功能分支名
 - 有关联 Issue 时请引用：`Fix session leak (#123)`。
 - 保持 commit 专注，每个 commit 只做一件事。
 - 对于小的清理或拼写修正，提 PR 前请将其合并为一个 commit。
-- 按照 [Conventional Commits](https://www.conventionalcommits.org/zh-hans/v1.0.0/) 规范来撰写
+- 按照 https://www.conventionalcommits.org/zh-hans/v1.0.0/ 规范来撰写
 
 ### 保持与上游同步
 
@@ -268,8 +268,8 @@ Release 分支的保护级别高于 `main`，在任何情况下均不允许直
 |Function| Reviewer|
 |---     |---      |
 |Provider|@yinwm   |
-|Channel |@yinwm/@alexhoshina   |
+|Channel |@yinwm   |
-|Agent   |@lxowalle/@Zhaoyikaiii|
+|Agent   |@lxowalle|
 |Tools   |@lxowalle|
 |SKill   ||
 |MCP     ||

LICENSE

@@ -19,3 +19,7 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+---
+
+PicoClaw is heavily inspired by and based on [nanobot](https://github.com/HKUDS/nanobot) by HKUDS.

Makefile

@@ -1,83 +1,22 @@
-.PHONY: all build install uninstall clean help test integration-test build-all lint-docs
+.PHONY: all build install uninstall clean help test
 
 # Build variables
 BINARY_NAME=picoclaw
 BUILD_DIR=build
 CMD_DIR=cmd/$(BINARY_NAME)
 MAIN_GO=$(CMD_DIR)/main.go
-EXT=
-
-ifeq ($(OS),Windows_NT)
-	POWERSHELL=powershell -NoProfile -Command
-	WINDOWS_GOARCH_RAW:=$(strip $(shell go env GOARCH 2>NUL))
-endif
 
 # Version
-ifeq ($(OS),Windows_NT)
+VERSION?=$(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
-	VERSION_RAW:=$(strip $(shell git describe --tags --always --dirty 2>NUL))
+GIT_COMMIT=$(shell git rev-parse --short=8 HEAD 2>/dev/null || echo "dev")
-	GIT_COMMIT_RAW:=$(strip $(shell git rev-parse --short=8 HEAD 2>NUL))
+BUILD_TIME=$(shell date +%FT%T%z)
-	BUILD_TIME_RAW:=$(strip $(shell powershell -NoProfile -Command "Get-Date -Format 'yyyy-MM-ddTHH:mm:ssK'"))
+GO_VERSION=$(shell $(GO) version | awk '{print $$3}')
-	GO_VERSION_RAW:=$(strip $(shell go env GOVERSION 2>NUL))
+INTERNAL=github.com/sipeed/picoclaw/cmd/picoclaw/internal
-else
+LDFLAGS=-ldflags "-X $(INTERNAL).version=$(VERSION) -X $(INTERNAL).gitCommit=$(GIT_COMMIT) -X $(INTERNAL).buildTime=$(BUILD_TIME) -X $(INTERNAL).goVersion=$(GO_VERSION) -s -w"
-	VERSION_RAW:=$(strip $(shell git describe --tags --always --dirty 2>/dev/null))
-	GIT_COMMIT_RAW:=$(strip $(shell git rev-parse --short=8 HEAD 2>/dev/null))
-	BUILD_TIME_RAW:=$(strip $(shell date +%FT%T%z))
-	GO_VERSION_RAW:=$(strip $(shell go env GOVERSION 2>/dev/null))
-endif
-VERSION?=$(if $(VERSION_RAW),$(VERSION_RAW),dev)
-GIT_COMMIT=$(if $(GIT_COMMIT_RAW),$(GIT_COMMIT_RAW),dev)
-BUILD_TIME=$(if $(BUILD_TIME_RAW),$(BUILD_TIME_RAW),dev)
-GO_VERSION=$(if $(GO_VERSION_RAW),$(GO_VERSION_RAW),unknown)
-CONFIG_PKG=github.com/sipeed/picoclaw/pkg/config
-LDFLAGS=-X $(CONFIG_PKG).Version=$(VERSION) -X $(CONFIG_PKG).GitCommit=$(GIT_COMMIT) -X $(CONFIG_PKG).BuildTime=$(BUILD_TIME) -X $(CONFIG_PKG).GoVersion=$(GO_VERSION) -s -w
 
 # Go variables
-GO?=go
+GO?=CGO_ENABLED=0 go
-WEB_GO?=$(GO)
+GOFLAGS?=-v -tags stdjson
-CGO_ENABLED?=0
-GO_BUILD_TAGS?=goolm,stdjson
-GOFLAGS?=-v -tags $(GO_BUILD_TAGS)
-GOCACHE?=$(CURDIR)/.cache/go-build
-GOMODCACHE?=$(CURDIR)/.cache/go-mod
-GOTOOLCHAIN?=local
-export CGO_ENABLED
-export GOCACHE
-export GOMODCACHE
-export GOTOOLCHAIN
-comma:=,
-empty:=
-space:=$(empty) $(empty)
-GO_BUILD_TAGS_NO_GOOLM:=$(subst $(space),$(comma),$(strip $(filter-out goolm,$(subst $(comma),$(space),$(GO_BUILD_TAGS)))))
-GOFLAGS_NO_GOOLM?=-v -tags $(GO_BUILD_TAGS_NO_GOOLM)
-
-# Patch MIPS LE ELF e_flags (offset 36) for NaN2008-only kernels (e.g. Ingenic X2600).
-#
-# Bytes (octal): \004 \024 \000 \160  →  little-endian 0x70001404
-#   0x70000000  EF_MIPS_ARCH_32R2   MIPS32 Release 2
-#   0x00001000  EF_MIPS_ABI_O32     O32 ABI
-#   0x00000400  EF_MIPS_NAN2008     IEEE 754-2008 NaN encoding
-#   0x00000004  EF_MIPS_CPIC        PIC calling sequence
-#
-# Go's GOMIPS=softfloat emits no FP instructions, so the NaN mode is irrelevant
-# at runtime — this is purely an ELF metadata fix to satisfy the kernel's check.
-# patchelf cannot modify e_flags; dd at a fixed offset is the most portable way.
-#
-# Ref: https://codebrowser.dev/linux/linux/arch/mips/include/asm/elf.h.html
-define PATCH_MIPS_FLAGS
-	@if [ -f "$(1)" ]; then \
-		printf '\004\024\000\160' | dd of=$(1) bs=1 seek=36 count=4 conv=notrunc 2>/dev/null || \
-		{ echo "Error: failed to patch MIPS e_flags for $(1)"; exit 1; }; \
-	else \
-		echo "Error: $(1) not found, cannot patch MIPS e_flags"; exit 1; \
-	fi
-endef
-
-# Patch creack/pty for loong64 support (upstream doesn't have ztypes_loong64.go)
-PTY_PATCH_LOONG64=pty_dir=$$(go env GOMODCACHE)/github.com/creack/pty@v1.1.9; \
-	if [ -d "$$pty_dir" ] && [ ! -f "$$pty_dir/ztypes_loong64.go" ]; then \
-		chmod +w "$$pty_dir" 2>/dev/null || true; \
-		printf '//go:build linux && loong64\npackage pty\ntype (_C_int int32; _C_uint uint32)\n' > "$$pty_dir/ztypes_loong64.go"; \
-	fi
 
 # Golangci-lint
 GOLANGCI_LINT?=golangci-lint
@@ -94,24 +33,9 @@ WORKSPACE_DIR?=$(PICOCLAW_HOME)/workspace
 WORKSPACE_SKILLS_DIR=$(WORKSPACE_DIR)/skills
 BUILTIN_SKILLS_DIR=$(CURDIR)/skills
 
-LNCMD=ln -sf
-
 # OS detection
-ifeq ($(OS),Windows_NT)
+UNAME_S:=$(shell uname -s)
-	UNAME_S=Windows
+UNAME_M:=$(shell uname -m)
-	ifeq ($(WINDOWS_GOARCH_RAW),amd64)
-		UNAME_M=x86_64
-	else ifeq ($(WINDOWS_GOARCH_RAW),arm64)
-		UNAME_M=arm64
-	else ifeq ($(WINDOWS_GOARCH_RAW),386)
-		UNAME_M=x86
-	else
-		UNAME_M=$(if $(WINDOWS_GOARCH_RAW),$(WINDOWS_GOARCH_RAW),x86_64)
-	endif
-else
-	UNAME_S?=$(shell uname -s)
-	UNAME_M?=$(shell uname -m)
-endif
 
 # Platform-specific settings
 ifeq ($(UNAME_S),Linux)
@@ -126,61 +50,21 @@ ifeq ($(UNAME_S),Linux)
 		ARCH=loong64
 	else ifeq ($(UNAME_M),riscv64)
 		ARCH=riscv64
-	else ifeq ($(UNAME_M),mipsel)
-		ARCH=mipsle
 	else
 		ARCH=$(UNAME_M)
 	endif
 else ifeq ($(UNAME_S),Darwin)
 	PLATFORM=darwin
-	WEB_GO=CGO_LDFLAGS="-mmacosx-version-min=10.11" CGO_CFLAGS="-mmacosx-version-min=10.11" CGO_ENABLED=1 go
 	ifeq ($(UNAME_M),x86_64)
-		ARCH?=amd64
+		ARCH=amd64
 	else ifeq ($(UNAME_M),arm64)
-		ARCH?=arm64
+		ARCH=arm64
 	else
-		ARCH?=$(UNAME_M)
+		ARCH=$(UNAME_M)
 	endif
 else
 	PLATFORM=$(UNAME_S)
-	ifeq ($(UNAME_M),x86_64)
+	ARCH=$(UNAME_M)
-		ARCH?=amd64
-	else
-	    ARCH?=$(UNAME_M)
-	endif
-	# Detect Windows (Git Bash / MSYS2)
-    IS_WINDOWS:=$(if $(findstring MINGW,$(UNAME_S)),yes,$(if $(findstring MSYS,$(UNAME_S)),yes,$(if $(findstring CYGWIN,$(UNAME_S)),yes,no)))
-	ifeq ($(IS_WINDOWS),yes)
-	    EXT=.exe
-	    LNCMD=cp
-	else ifeq ($(UNAME_S),windows) # failsafe for force windows build in other OS using UNAME_S=windows
-		EXT=.exe
-	endif
-
-endif
-
-ifeq ($(OS),Windows_NT)
-	PLATFORM=windows
-	ifeq ($(UNAME_M),x86_64)
-		ARCH?=amd64
-	else ifeq ($(UNAME_M),arm64)
-		ARCH?=arm64
-	else
-		ARCH?=$(UNAME_M)
-	endif
-	EXT=.exe
-endif
-
-ifneq ($(strip $(GOOS)),)
-	PLATFORM:=$(GOOS)
-endif
-
-ifneq ($(strip $(GOARCH)),)
-	ARCH:=$(GOARCH)
-endif
-
-ifeq ($(PLATFORM),windows)
-	EXT=.exe
 endif
 
 BINARY_PATH=$(BUILD_DIR)/$(BINARY_NAME)-$(PLATFORM)-$(ARCH)
@@ -191,66 +75,31 @@ all: build
 ## generate: Run generate
 generate:
 	@echo "Run generate..."
-ifeq ($(OS),Windows_NT)
-	@$(POWERSHELL) "if (Test-Path -LiteralPath './$(CMD_DIR)/workspace') { Remove-Item -LiteralPath './$(CMD_DIR)/workspace' -Recurse -Force }"
-	@$(POWERSHELL) "$$env:GOOS=''; $$env:GOARCH=''; $(GO) generate ./..."
-else
 	@rm -r ./$(CMD_DIR)/workspace 2>/dev/null || true
-	@GOOS=$$($(GO) env GOHOSTOS) GOARCH=$$($(GO) env GOHOSTARCH) $(GO) generate ./...
+	@$(GO) generate ./...
-endif
 	@echo "Run generate complete"
 
 ## build: Build the picoclaw binary for current platform
 build: generate
-	@echo "Building $(BINARY_NAME)$(EXT) for $(PLATFORM)/$(ARCH)..."
+	@echo "Building $(BINARY_NAME) for $(PLATFORM)/$(ARCH)..."
-ifeq ($(OS),Windows_NT)
-	@$(POWERSHELL) "New-Item -ItemType Directory -Force -Path '$(BUILD_DIR)' | Out-Null"
-	@$(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_PATH)$(EXT) ./$(CMD_DIR)
-	@$(POWERSHELL) "Copy-Item -LiteralPath '$(BINARY_PATH)$(EXT)' -Destination '$(BUILD_DIR)/$(BINARY_NAME)$(EXT)' -Force"
-else
 	@mkdir -p $(BUILD_DIR)
-	@GOOS=$(PLATFORM) GOARCH=$(ARCH) $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_PATH)$(EXT) ./$(CMD_DIR)
+	@$(GO) build $(GOFLAGS) $(LDFLAGS) -o $(BINARY_PATH) ./$(CMD_DIR)
-	@echo "Build complete: $(BINARY_PATH)$(EXT)"
+	@echo "Build complete: $(BINARY_PATH)"
-	@$(LNCMD) $(BINARY_NAME)-$(PLATFORM)-$(ARCH)$(EXT) $(BUILD_DIR)/$(BINARY_NAME)$(EXT)
+	@ln -sf $(BINARY_NAME)-$(PLATFORM)-$(ARCH) $(BUILD_DIR)/$(BINARY_NAME)
-endif
-	@echo "Build complete: $(BUILD_DIR)/$(BINARY_NAME)$(EXT)"
-
-## build-launcher: Build the picoclaw-launcher (web console) binary
-build-launcher:
-	@echo "Building picoclaw-launcher for $(PLATFORM)/$(ARCH)..."
-ifeq ($(OS),Windows_NT)
-	@$(POWERSHELL) "New-Item -ItemType Directory -Force -Path '$(BUILD_DIR)' | Out-Null"
-	@$(MAKE) -C web build PLATFORM="$(PLATFORM)" ARCH="$(ARCH)" EXT="$(EXT)" OUTPUT="$(CURDIR)/$(BUILD_DIR)/picoclaw-launcher-$(PLATFORM)-$(ARCH)$(EXT)" GO_BUILD_TAGS="$(GO_BUILD_TAGS)"
-	@$(POWERSHELL) "Copy-Item -LiteralPath '$(BUILD_DIR)/picoclaw-launcher-$(PLATFORM)-$(ARCH)$(EXT)' -Destination '$(BUILD_DIR)/picoclaw-launcher$(EXT)' -Force"
-else
-	@mkdir -p $(BUILD_DIR)
-	@GOOS=$(PLATFORM) GOARCH=$(ARCH) $(MAKE) -C web build \
-		OUTPUT="$(CURDIR)/$(BUILD_DIR)/picoclaw-launcher-$(PLATFORM)-$(ARCH)$(EXT)" \
-		WEB_GO='$(WEB_GO)' \
-		GO_BUILD_TAGS='$(GO_BUILD_TAGS)' \
-		LDFLAGS='$(LDFLAGS)'
-	@$(LNCMD) picoclaw-launcher-$(PLATFORM)-$(ARCH)$(EXT) $(BUILD_DIR)/picoclaw-launcher$(EXT)
-endif
-	@echo "Build complete: $(BUILD_DIR)/picoclaw-launcher$(EXT)"
-
-build-launcher-frontend:
-	@$(MAKE) -C web build-frontend
 
 ## build-whatsapp-native: Build with WhatsApp native (whatsmeow) support; larger binary
 build-whatsapp-native: generate
 ## @echo "Building $(BINARY_NAME) with WhatsApp native for $(PLATFORM)/$(ARCH)..."
 	@echo "Building for multiple platforms..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=amd64 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=amd64 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=arm GOARM=7 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm GOARM=7 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm ./$(CMD_DIR)
-	GOOS=linux GOARCH=arm64 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm64 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=loong64 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-loong64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=loong64 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-loong64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=riscv64 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-riscv64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=riscv64 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-riscv64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=mipsle GOMIPS=softfloat $(GO) build -tags $(GO_BUILD_TAGS_NO_GOOLM),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle ./$(CMD_DIR)
+	GOOS=darwin GOARCH=arm64 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 ./$(CMD_DIR)
-	$(call PATCH_MIPS_FLAGS,$(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle)
+	GOOS=windows GOARCH=amd64 $(GO) build -tags whatsapp_native $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe ./$(CMD_DIR)
-	GOOS=darwin GOARCH=arm64 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 ./$(CMD_DIR)
+## @$(GO) build $(GOFLAGS) -tags whatsapp_native $(LDFLAGS) -o $(BINARY_PATH) ./$(CMD_DIR)
-	GOOS=windows GOARCH=amd64 $(GO) build -tags $(GO_BUILD_TAGS),whatsapp_native -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe ./$(CMD_DIR)
-## @$(GO) build $(GOFLAGS) -tags whatsapp_native -ldflags "$(LDFLAGS)" -o $(BINARY_PATH) ./$(CMD_DIR)
 	@echo "Build complete"
 ##	@ln -sf $(BINARY_NAME)-$(PLATFORM)-$(ARCH) $(BUILD_DIR)/$(BINARY_NAME)
 
@@ -258,79 +107,33 @@ build-whatsapp-native: generate
 build-linux-arm: generate
 	@echo "Building for linux/arm (GOARM=7)..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=arm GOARM=7 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm GOARM=7 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm ./$(CMD_DIR)
 	@echo "Build complete: $(BUILD_DIR)/$(BINARY_NAME)-linux-arm"
 
 ## build-linux-arm64: Build for Linux ARM64 (e.g. Raspberry Pi Zero 2 W 64-bit)
 build-linux-arm64: generate
 	@echo "Building for linux/arm64..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=arm64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./$(CMD_DIR)
 	@echo "Build complete: $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64"
 
-## build-linux-mipsle: Build for Linux MIPS32 LE
-build-linux-mipsle: generate
-	@echo "Building for linux/mipsle (softfloat)..."
-	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=mipsle GOMIPS=softfloat $(GO) build $(GOFLAGS_NO_GOOLM) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle ./$(CMD_DIR)
-	$(call PATCH_MIPS_FLAGS,$(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle)
-	@echo "Build complete: $(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle"
-
-## build-android-arm64: Build core for Android ARM64
-build-android-arm64: generate
-	@echo "Building for android/arm64..."
-	@mkdir -p $(BUILD_DIR)
-	GOOS=android GOARCH=arm64 $(GO) build -tags stdjson -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-android-arm64 ./$(CMD_DIR)
-	@echo "Build complete: $(BUILD_DIR)/$(BINARY_NAME)-android-arm64"
-
-## build-launcher-android-arm64: Build launcher for Android ARM64
-build-launcher-android-arm64:
-	@echo "Building picoclaw-launcher for android/arm64..."
-	@mkdir -p $(BUILD_DIR)
-	@$(MAKE) -C web build-android-arm64 \
-		OUTPUT_ANDROID_ARM64="$(CURDIR)/$(BUILD_DIR)/picoclaw-launcher-android-arm64" \
-		GO='$(GO)' \
-		LDFLAGS='$(LDFLAGS)'
-	@echo "Build complete: $(BUILD_DIR)/picoclaw-launcher-android-arm64"
-
-## build-android-bundle: Build core and launcher for all Android architectures and package as universal zip
-build-android-bundle: generate
-	@echo "Building core for all Android architectures..."
-	@mkdir -p $(BUILD_DIR)
-	GOOS=android GOARCH=arm64 $(GO) build -tags stdjson -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-android-arm64 ./$(CMD_DIR)
-	@echo "Building launcher for Android arm64..."
-	@$(MAKE) build-launcher-android-arm64
-	@echo "Staging JNI libs..."
-	@rm -rf $(BUILD_DIR)/android-staging
-	@mkdir -p $(BUILD_DIR)/android-staging/arm64-v8a
-	@cp $(BUILD_DIR)/$(BINARY_NAME)-android-arm64 $(BUILD_DIR)/android-staging/arm64-v8a/libpicoclaw.so
-	@cp $(BUILD_DIR)/picoclaw-launcher-android-arm64 $(BUILD_DIR)/android-staging/arm64-v8a/libpicoclaw-web.so
-	@cd $(BUILD_DIR)/android-staging && zip -r ../picoclaw-android-universal.zip .
-	@rm -rf $(BUILD_DIR)/android-staging
-	@echo "All Android builds complete: $(BUILD_DIR)/picoclaw-android-universal.zip"
-
 ## build-pi-zero: Build for Raspberry Pi Zero 2 W (32-bit and 64-bit)
 build-pi-zero: build-linux-arm build-linux-arm64
 	@echo "Pi Zero 2 W builds: $(BUILD_DIR)/$(BINARY_NAME)-linux-arm (32-bit), $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 (64-bit)"
 
-## build-all: Build the picoclaw core binary for all Makefile-managed platforms
+## build-all: Build picoclaw for all platforms
 build-all: generate
 	@echo "Building for multiple platforms..."
 	@mkdir -p $(BUILD_DIR)
-	GOOS=linux GOARCH=amd64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=amd64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-amd64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=arm GOARM=7 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm GOARM=7 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm ./$(CMD_DIR)
-	GOOS=linux GOARCH=arm64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-arm64 ./$(CMD_DIR)
-	@$(PTY_PATCH_LOONG64)
+	GOOS=linux GOARCH=loong64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-loong64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=loong64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-loong64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=riscv64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-riscv64 ./$(CMD_DIR)
-	GOOS=linux GOARCH=riscv64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-riscv64 ./$(CMD_DIR)
+	GOOS=linux GOARCH=arm GOARM=7 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-linux-armv7 ./$(CMD_DIR)
-	GOOS=linux GOARCH=mipsle GOMIPS=softfloat $(GO) build $(GOFLAGS_NO_GOOLM) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle ./$(CMD_DIR)
+	GOOS=darwin GOARCH=arm64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 ./$(CMD_DIR)
-	$(call PATCH_MIPS_FLAGS,$(BUILD_DIR)/$(BINARY_NAME)-linux-mipsle)
+	GOOS=windows GOARCH=amd64 $(GO) build $(LDFLAGS) -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe ./$(CMD_DIR)
-	GOOS=linux GOARCH=arm GOARM=7 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-linux-armv7 ./$(CMD_DIR)
+	@echo "All builds complete"
-	GOOS=darwin GOARCH=arm64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-darwin-arm64 ./$(CMD_DIR)
-	GOOS=windows GOARCH=amd64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-windows-amd64.exe ./$(CMD_DIR)
-	GOOS=netbsd GOARCH=amd64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-netbsd-amd64 ./$(CMD_DIR)
-	GOOS=netbsd GOARCH=arm64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BUILD_DIR)/$(BINARY_NAME)-netbsd-arm64 ./$(CMD_DIR)
-	@echo "Core builds complete"
 
 ## install: Install picoclaw to system and copy builtin skills
 install: build
@@ -361,44 +164,28 @@ uninstall-all:
 ## clean: Remove build artifacts
 clean:
 	@echo "Cleaning build artifacts..."
-ifeq ($(OS),Windows_NT)
-	@$(POWERSHELL) "if (Test-Path -LiteralPath '$(BUILD_DIR)') { Remove-Item -LiteralPath '$(BUILD_DIR)' -Recurse -Force }"
-else
 	@rm -rf $(BUILD_DIR)
-endif
 	@echo "Clean complete"
 
 ## vet: Run go vet for static analysis
-vet: generate
+vet:
-	@packages="$$($(GO) list $(GOFLAGS) ./...)" && \
+	@$(GO) vet ./...
-		$(GO) vet $(GOFLAGS) $$(printf '%s\n' "$$packages" | grep -v '^github.com/sipeed/picoclaw/web/')
-	@cd web/backend && $(WEB_GO) vet ./...
 
 ## test: Test Go code
-test: generate
+test:
-	@$(GO) test $(GOFLAGS) $$($(GO) list $(GOFLAGS) ./... | grep -v github.com/sipeed/picoclaw/web/)
+	@$(GO) test ./...
-	@cd web && make test
-
-## integration-test: Run Docker-backed integration test suites
-integration-test:
-	@bash ./scripts/run-integration-tests.sh
 
 ## fmt: Format Go code
 fmt:
 	@$(GOLANGCI_LINT) fmt
 
-## lint-docs: Check common documentation layout and naming conventions
-lint-docs:
-	@./scripts/lint-docs.sh
-
 ## lint: Run linters
 lint:
-	@$(GOLANGCI_LINT) run --build-tags $(GO_BUILD_TAGS)
+	@$(GOLANGCI_LINT) run
-	@./scripts/lint-docs.sh
 
 ## fix: Fix linting issues
 fix:
-	@$(GOLANGCI_LINT) run --fix --build-tags $(GO_BUILD_TAGS)
+	@$(GOLANGCI_LINT) run --fix
 
 ## deps: Download dependencies
 deps:
@@ -410,81 +197,13 @@ update-deps:
 	@$(GO) get -u ./...
 	@$(GO) mod tidy
 
-## check: Run deps, fmt, vet, tests, and docs consistency checks
+## check: Run vet, fmt, and verify dependencies
-check: deps fmt vet test lint-docs
+check: deps fmt vet test
 
 ## run: Build and run picoclaw
 run: build
 	@$(BUILD_DIR)/$(BINARY_NAME) $(ARGS)
 
-## docker-build: Build Docker image (minimal Alpine-based)
-docker-build:
-	@echo "Building minimal Docker image (Alpine-based)..."
-	docker compose -f docker/docker-compose.yml build picoclaw-agent picoclaw-gateway
-
-## docker-build-full: Build Docker image with full MCP support (Node.js 24)
-docker-build-full:
-	@echo "Building full-featured Docker image (Node.js 24)..."
-	docker compose -f docker/docker-compose.full.yml build picoclaw-agent picoclaw-gateway
-
-## docker-test: Test MCP tools in Docker container
-docker-test:
-	@echo "Testing MCP tools in Docker..."
-	@chmod +x scripts/test-docker-mcp.sh
-	@./scripts/test-docker-mcp.sh
-
-## docker-run: Run picoclaw gateway in Docker (Alpine-based)
-docker-run:
-	docker compose -f docker/docker-compose.yml --profile gateway up
-
-## docker-run-full: Run picoclaw gateway in Docker (full-featured)
-docker-run-full:
-	docker compose -f docker/docker-compose.full.yml --profile gateway up
-
-## docker-run-agent: Run picoclaw agent in Docker (interactive, Alpine-based)
-docker-run-agent:
-	docker compose -f docker/docker-compose.yml run --rm picoclaw-agent
-
-## docker-run-agent-full: Run picoclaw agent in Docker (interactive, full-featured)
-docker-run-agent-full:
-	docker compose -f docker/docker-compose.full.yml run --rm picoclaw-agent
-
-## docker-clean: Clean Docker images and volumes
-docker-clean:
-	docker compose -f docker/docker-compose.yml down -v
-	docker compose -f docker/docker-compose.full.yml down -v
-	docker rmi picoclaw:latest picoclaw:full 2>/dev/null || true
-
-
-## build-macos-app: Build PicoClaw macOS .app bundle (no terminal window)
-build-macos-app:build-launcher
-	@echo "Building macOS .app bundle..."
-	@if [ "$(UNAME_S)" != "Darwin" ]; then \
-		echo "Error: This target is only available on macOS"; \
-		exit 1; \
-	fi
-	@./scripts/build-macos-app.sh $(PLATFORM)-$(ARCH)
-	@echo "macOS .app bundle created: $(BUILD_DIR)/PicoClaw.app"
-
-## mem: Build membench, download LOCOMO data (if needed), run benchmark, and show results
-mem:
-	@echo "Building membench..."
-	@mkdir -p $(BUILD_DIR)
-	@$(GO) build -o $(BUILD_DIR)/membench ./cmd/membench
-	@echo "Build complete: $(BUILD_DIR)/membench"
-	@if [ ! -f $(BUILD_DIR)/memdata/locomo10.json ]; then \
-		echo "Downloading LOCOMO dataset..."; \
-		mkdir -p $(BUILD_DIR)/memdata; \
-		curl -sfL "https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json" \
-			-o $(BUILD_DIR)/memdata/locomo10.json && [ -s $(BUILD_DIR)/memdata/locomo10.json ] || { echo "Error: LOCOMO download failed"; exit 1; }; \
-		echo "Download complete"; \
-	else \
-		echo "LOCOMO dataset already exists, skipping download"; \
-	fi
-	@echo "Running benchmark..."
-	@rm -rf $(BUILD_DIR)/memout
-	@$(BUILD_DIR)/membench run --data $(BUILD_DIR)/memdata --out $(BUILD_DIR)/memout --budget 4000
-
 ## help: Show this help message
 help:
 	@echo "picoclaw Makefile"
@@ -500,8 +219,6 @@ help:
 	@echo "  make install            # Install to ~/.local/bin"
 	@echo "  make uninstall          # Remove from /usr/local/bin"
 	@echo "  make install-skills     # Install skills to workspace"
-	@echo "  make docker-build       # Build minimal Docker image"
-	@echo "  make docker-test        # Test MCP tools in Docker"
 	@echo ""
 	@echo "Environment Variables:"
 	@echo "  INSTALL_PREFIX          # Installation prefix (default: ~/.local)"

README.zh.md

@@ -0,0 +1,822 @@
+<div align="center">
+<img src="assets/logo.jpg" alt="PicoClaw" width="512">
+
+<h1>PicoClaw: 基于Go语言的超高效 AI 助手</h1>
+
+<h3>10$硬件 · 10MB内存 · 1秒启动 · 皮皮虾，我们走！</h3>
+
+  <p>
+    <img src="https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go&logoColor=white" alt="Go">
+    <img src="https://img.shields.io/badge/Arch-x86__64%2C%20ARM64%2C%20RISC--V-blue" alt="Hardware">
+    <img src="https://img.shields.io/badge/license-MIT-green" alt="License">
+    <br>
+    <a href="https://picoclaw.io"><img src="https://img.shields.io/badge/Website-picoclaw.io-blue?style=flat&logo=google-chrome&logoColor=white" alt="Website"></a>
+    <a href="https://x.com/SipeedIO"><img src="https://img.shields.io/badge/X_(Twitter)-SipeedIO-black?style=flat&logo=x&logoColor=white" alt="Twitter"></a>
+  </p>
+
+**中文** | [日本語](README.ja.md) | [Português](README.pt-br.md) | [Tiếng Việt](README.vi.md) | [Français](README.fr.md) | [English](README.md)
+
+</div>
+
+---
+
+🦐 **PicoClaw** 是一个受 [nanobot](https://github.com/HKUDS/nanobot) 启发的超轻量级个人 AI 助手。它采用 **Go 语言** 从零重构，经历了一个“自举”过程——即由 AI Agent 自身驱动了整个架构迁移和代码优化。
+
+⚡️ **极致轻量**：可在 **10 美元** 的硬件上运行，内存占用 **<10MB**。这意味着比 OpenClaw 节省 99% 的内存，比 Mac mini 便宜 98%！
+
+<table align="center">
+<tr align="center">
+<td align="center" valign="top">
+<p align="center">
+<img src="assets/picoclaw_mem.gif" width="360" height="240">
+</p>
+</td>
+<td align="center" valign="top">
+<p align="center">
+<img src="assets/licheervnano.png" width="400" height="240">
+</p>
+</td>
+</tr>
+</table>
+
+注意：人手有限，中文文档可能略有滞后，请优先查看英文文档。
+
+> [!CAUTION]
+> **🚨 SECURITY & OFFICIAL CHANNELS / 安全声明**
+>
+> - **无加密货币 (NO CRYPTO):** PicoClaw **没有** 发行任何官方代币、Token 或虚拟货币。所有在 `pump.fun` 或其他交易平台上的相关声称均为 **诈骗**。
+> - **官方域名:** 唯一的官方网站是 **[picoclaw.io](https://picoclaw.io)**，公司官网是 **[sipeed.com](https://sipeed.com)**。
+> - **警惕:** 许多 `.ai/.org/.com/.net/...` 后缀的域名被第三方抢注，请勿轻信。
+> - **注意:** picoclaw正在初期的快速功能开发阶段，可能有尚未修复的网络安全问题，在1.0正式版发布前，请不要将其部署到生产环境中
+> - **注意:** picoclaw最近合并了大量PRs，近期版本可能内存占用较大(10~20MB)，我们将在功能较为收敛后进行资源占用优化.
+
+## 📢 新闻 (News)
+
+2026-02-16 🎉 PicoClaw 在一周内突破了12K star! 感谢大家的关注！PicoClaw 的成长速度超乎我们预期. 由于PR数量的快速膨胀，我们亟需社区开发者参与维护. 我们需要的志愿者角色和roadmap已经发布到了[这里](docs/ROADMAP.md), 期待你的参与！
+
+2026-02-13 🎉 **PicoClaw 在 4 天内突破 5000 Stars！** 感谢社区的支持！由于正值中国春节假期，PR 和 Issue 涌入较多，我们正在利用这段时间敲定 **项目路线图 (Roadmap)** 并组建 **开发者群组**，以便加速 PicoClaw 的开发。
+🚀 **行动号召：** 请在 GitHub Discussions 中提交您的功能请求 (Feature Requests)。我们将在接下来的周会上进行审查和优先级排序。
+
+2026-02-09 🎉 **PicoClaw 正式发布！** 仅用 1 天构建，旨在将 AI Agent 带入 10 美元硬件与 <10MB 内存的世界。🦐 PicoClaw（皮皮虾），我们走！
+
+## ✨ 特性
+
+🪶 **超轻量级**: 核心功能内存占用 <10MB — 比 Clawdbot 小 99%。
+
+💰 **极低成本**: 高效到足以在 10 美元的硬件上运行 — 比 Mac mini 便宜 98%。
+
+⚡️ **闪电启动**: 启动速度快 400 倍，即使在 0.6GHz 单核处理器上也能在 1 秒内启动。
+
+🌍 **真正可移植**: 跨 RISC-V、ARM 和 x86 架构的单二进制文件，一键运行！
+
+🤖 **AI 自举**: 纯 Go 语言原生实现 — 95% 的核心代码由 Agent 生成，并经由“人机回环 (Human-in-the-loop)”微调。
+
+|                                | OpenClaw      | NanoBot                  | **PicoClaw**                           |
+| ------------------------------ | ------------- | ------------------------ | -------------------------------------- |
+| **语言**                       | TypeScript    | Python                   | **Go**                                 |
+| **RAM**                        | >1GB          | >100MB                   | **< 10MB**                             |
+| **启动时间**</br>(0.8GHz core) | >500s         | >30s                     | **<1s**                                |
+| **成本**                       | Mac Mini $599 | 大多数 Linux 开发板 ~$50 | **任意 Linux 开发板**</br>**低至 $10** |
+
+<img src="assets/compare.jpg" alt="PicoClaw" width="512">
+
+## 🦾 演示
+
+### 🛠️ 标准助手工作流
+
+<table align="center">
+<tr align="center">
+<th><p align="center">🧩 全栈工程师模式</p></th>
+<th><p align="center">🗂️ 日志与规划管理</p></th>
+<th><p align="center">🔎 网络搜索与学习</p></th>
+</tr>
+<tr>
+<td align="center"><p align="center"><img src="assets/picoclaw_code.gif" width="240" height="180"></p></td>
+<td align="center"><p align="center"><img src="assets/picoclaw_memory.gif" width="240" height="180"></p></td>
+<td align="center"><p align="center"><img src="assets/picoclaw_search.gif" width="240" height="180"></p></td>
+</tr>
+<tr>
+<td align="center">开发 • 部署 • 扩展</td>
+<td align="center">日程 • 自动化 • 记忆</td>
+<td align="center">发现 • 洞察 • 趋势</td>
+</tr>
+</table>
+
+### 📱 在手机上轻松运行
+
+picoclaw 可以将你10年前的老旧手机废物利用，变身成为你的AI助理！快速指南:
+
+1. 先去应用商店下载安装Termux
+2. 打开后执行指令
+
+```bash
+# 注意: 下面的v0.1.1 可以换为你实际看到的最新版本
+wget https://github.com/sipeed/picoclaw/releases/download/v0.1.1/picoclaw-linux-arm64
+chmod +x picoclaw-linux-arm64
+pkg install proot
+termux-chroot ./picoclaw-linux-arm64 onboard
+```
+
+然后跟随下面的“快速开始”章节继续配置picoclaw即可使用！  
+<img src="assets/termux.jpg" alt="PicoClaw" width="512">
+
+### 🐜 创新的低占用部署
+
+PicoClaw 几乎可以部署在任何 Linux 设备上！
+
+- $9.9 [LicheeRV-Nano](https://www.aliexpress.com/item/1005006519668532.html) E(网口) 或 W(WiFi6) 版本，用于极简家庭助手。
+- $30~50 [NanoKVM](https://www.aliexpress.com/item/1005007369816019.html)，或 $100 [NanoKVM-Pro](https://www.aliexpress.com/item/1005010048471263.html)，用于自动化服务器运维。
+- $50 [MaixCAM](https://www.aliexpress.com/item/1005008053333693.html) 或 $100 [MaixCAM2](https://www.kickstarter.com/projects/zepan/maixcam2-build-your-next-gen-4k-ai-camera)，用于智能监控。
+
+[https://private-user-images.githubusercontent.com/83055338/547056448-e7b031ff-d6f5-4468-bcca-5726b6fecb5c.mp4](https://private-user-images.githubusercontent.com/83055338/547056448-e7b031ff-d6f5-4468-bcca-5726b6fecb5c.mp4)
+
+🌟 更多部署案例敬请期待！
+
+## 📦 安装
+
+### 使用预编译二进制文件安装
+
+从 [Release 页面](https://github.com/sipeed/picoclaw/releases) 下载适用于您平台的固件。
+
+### 从源码安装（获取最新特性，开发推荐）
+
+```bash
+git clone https://github.com/sipeed/picoclaw.git
+
+cd picoclaw
+make deps
+
+# 构建（无需安装）
+make build
+
+# 为多平台构建
+make build-all
+
+# 构建并安装
+make install
+
+```
+
+## 🐳 Docker Compose
+
+您也可以使用 Docker Compose 运行 PicoClaw，无需在本地安装任何环境。
+
+```bash
+# 1. 克隆仓库
+git clone https://github.com/sipeed/picoclaw.git
+cd picoclaw
+
+# 2. 首次运行 — 自动生成 docker/data/config.json 后退出
+docker compose -f docker/docker-compose.yml --profile gateway up
+# 容器打印 "First-run setup complete." 后自动停止
+
+# 3. 填写 API Key 等配置
+vim docker/data/config.json   # 设置 provider API key、Bot Token 等
+
+# 4. 正式启动
+docker compose -f docker/docker-compose.yml --profile gateway up -d
+```
+
+> [!TIP]
+> **Docker 用户**: 默认情况下, Gateway 监听 `127.0.0.1`，该端口不会暴露到容器外。如果需要通过端口映射访问健康检查接口，请在环境变量中设置 `PICOCLAW_GATEWAY_HOST=0.0.0.0` 或修改 `config.json`。
+
+```bash
+# 5. 查看日志
+docker compose -f docker/docker-compose.yml logs -f picoclaw-gateway
+
+# 6. 停止
+docker compose -f docker/docker-compose.yml --profile gateway down
+```
+
+### Agent 模式 (一次性运行)
+
+```bash
+# 提问
+docker compose -f docker/docker-compose.yml run --rm picoclaw-agent -m "2+2 等于几？"
+
+# 交互模式
+docker compose -f docker/docker-compose.yml run --rm picoclaw-agent
+```
+
+### 更新镜像
+
+```bash
+docker compose -f docker/docker-compose.yml pull
+docker compose -f docker/docker-compose.yml --profile gateway up -d
+```
+
+### 🚀 快速开始
+
+> [!TIP]
+> 在 `~/.picoclaw/config.json` 中设置您的 API Key。
+> 获取 API Key: [OpenRouter](https://openrouter.ai/keys) (LLM) · [Zhipu (智谱)](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) (LLM)
+> 网络搜索是 **可选的** - 获取免费的 [Tavily API](https://tavily.com) (每月 1000 次免费查询) 或 [Brave Search API](https://brave.com/search/api) (每月 2000 次免费查询)
+
+**1. 初始化 (Initialize)**
+
+```bash
+picoclaw onboard
+
+```
+
+**2. 配置 (Configure)** (`~/.picoclaw/config.json`)
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "workspace": "~/.picoclaw/workspace",
+      "model_name": "gpt4",
+      "max_tokens": 8192,
+      "temperature": 0.7,
+      "max_tool_iterations": 20
+    }
+  },
+  "model_list": [
+    {
+      "model_name": "gpt4",
+      "model": "openai/gpt-5.2",
+      "api_key": "your-api-key",
+      "request_timeout": 300
+    },
+    {
+      "model_name": "claude-sonnet-4.6",
+      "model": "anthropic/claude-sonnet-4.6",
+      "api_key": "your-anthropic-key"
+    }
+  ],
+  "tools": {
+    "web": {
+      "brave": {
+        "enabled": false,
+        "api_key": "YOUR_BRAVE_API_KEY",
+        "max_results": 5
+      },
+      "tavily": {
+        "enabled": false,
+        "api_key": "YOUR_TAVILY_API_KEY",
+        "max_results": 5
+      }
+    },
+    "cron": {
+      "exec_timeout_minutes": 5
+    }
+  }
+}
+```
+
+> **新功能**: `model_list` 配置格式支持零代码添加 provider。详见[模型配置](#模型配置-model_list)章节。
+> `request_timeout` 为可选项，单位为秒。若省略或设置为 `<= 0`，PicoClaw 使用默认超时（120 秒）。
+
+**3. 获取 API Key**
+
+* **LLM 提供商**: [OpenRouter](https://openrouter.ai/keys) · [Zhipu](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) · [Anthropic](https://console.anthropic.com) · [OpenAI](https://platform.openai.com) · [Gemini](https://aistudio.google.com/api-keys)
+* **网络搜索** (可选): [Tavily](https://tavily.com) - 专为 AI Agent 优化 (1000 请求/月) · [Brave Search](https://brave.com/search/api) - 提供免费层级 (2000 请求/月)
+
+> **注意**: 完整的配置模板请参考 `config.example.json`。
+
+**4. 对话 (Chat)**
+
+```bash
+picoclaw agent -m "2+2 等于几？"
+
+```
+
+就是这样！您在 2 分钟内就拥有了一个可工作的 AI 助手。
+
+---
+
+## 💬 聊天应用集成 (Chat Apps)
+
+PicoClaw 支持多种聊天平台，使您的 Agent 能够连接到任何地方。
+
+### 核心渠道
+
+| 渠道                 | 设置难度    | 特性说明                                  | 文档链接                                                                                                        |
+| -------------------- | ----------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| **Telegram**         | ⭐ 简单     | 推荐，支持语音转文字，长轮询无需公网      | [查看文档](docs/channels/telegram/README.zh.md)                                                                 |
+| **Discord**          | ⭐ 简单     | Socket Mode，支持群组/私信，Bot 生态成熟  | [查看文档](docs/channels/discord/README.zh.md)                                                                  |
+| **Slack**            | ⭐ 简单     | **Socket Mode** (无需公网 IP)，企业级支持 | [查看文档](docs/channels/slack/README.zh.md)                                                                    |
+| **QQ**               | ⭐⭐ 中等   | 官方机器人 API，适合国内社群              | [查看文档](docs/channels/qq/README.zh.md)                                                                       |
+| **钉钉 (DingTalk)**  | ⭐⭐ 中等   | Stream 模式无需公网，企业办公首选         | [查看文档](docs/channels/dingtalk/README.zh.md)                                                                 |
+| **企业微信 (WeCom)** | ⭐⭐⭐ 较难 | 支持群机器人(Webhook)和自建应用(API)      | [Bot 文档](docs/channels/wecom/wecom_bot/README.zh.md) / [App 文档](docs/channels/wecom/wecom_app/README.zh.md) |
+| **飞书 (Feishu)**    | ⭐⭐⭐ 较难 | 企业级协作，功能丰富                      | [查看文档](docs/channels/feishu/README.zh.md)                                                                   |
+| **Line**             | ⭐⭐⭐ 较难 | 需要 HTTPS Webhook                        | [查看文档](docs/channels/line/README.zh.md)                                                                     |
+| **OneBot**           | ⭐⭐ 中等   | 兼容 NapCat/Go-CQHTTP，社区生态丰富       | [查看文档](docs/channels/onebot/README.zh.md)                                                                   |
+| **MaixCam**          | ⭐ 简单     | 专为 AI 摄像头设计的硬件集成通道          | [查看文档](docs/channels/maixcam/README.zh.md)                                                                  |
+
+## <img src="assets/clawdchat-icon.png" width="24" height="24" alt="ClawdChat"> 加入 Agent 社交网络
+
+只需通过 CLI 或任何集成的聊天应用发送一条消息，即可将 PicoClaw 连接到 Agent 社交网络。
+
+\*\*阅读 `https://clawdchat.ai/skill.md` 并按照说明加入 [ClawdChat.ai](https://clawdchat.ai)
+
+## ⚙️ 配置详解
+
+配置文件路径: `~/.picoclaw/config.json`
+
+### 工作区布局 (Workspace Layout)
+
+PicoClaw 将数据存储在您配置的工作区中（默认：`~/.picoclaw/workspace`）：
+
+```
+~/.picoclaw/workspace/
+├── sessions/          # 对话会话和历史
+├── memory/           # 长期记忆 (MEMORY.md)
+├── state/            # 持久化状态 (最后一次频道等)
+├── cron/             # 定时任务数据库
+├── skills/           # 自定义技能
+├── AGENTS.md         # Agent 行为指南
+├── HEARTBEAT.md      # 周期性任务提示词 (每 30 分钟检查一次)
+├── IDENTITY.md       # Agent 身份设定
+├── SOUL.md           # Agent 灵魂/性格
+├── TOOLS.md          # 工具描述
+└── USER.md           # 用户偏好
+
+```
+
+### 心跳 / 周期性任务 (Heartbeat)
+
+PicoClaw 可以自动执行周期性任务。在工作区创建 `HEARTBEAT.md` 文件：
+
+```markdown
+# Periodic Tasks
+
+- Check my email for important messages
+- Review my calendar for upcoming events
+- Check the weather forecast
+```
+
+Agent 将每隔 30 分钟（可配置）读取此文件，并使用可用工具执行任务。
+
+#### 使用 Spawn 的异步任务
+
+对于耗时较长的任务（网络搜索、API 调用），使用 `spawn` 工具创建一个 **子 Agent (subagent)**：
+
+```markdown
+# Periodic Tasks
+
+## Quick Tasks (respond directly)
+
+- Report current time
+
+## Long Tasks (use spawn for async)
+
+- Search the web for AI news and summarize
+- Check email and report important messages
+```
+
+**关键行为：**
+
+| 特性             | 描述                                     |
+| ---------------- | ---------------------------------------- |
+| **spawn**        | 创建异步子 Agent，不阻塞主心跳进程       |
+| **独立上下文**   | 子 Agent 拥有独立上下文，无会话历史      |
+| **message tool** | 子 Agent 通过 message 工具直接与用户通信 |
+| **非阻塞**       | spawn 后，心跳继续处理下一个任务         |
+
+#### 子 Agent 通信原理
+
+```
+心跳触发 (Heartbeat triggers)
+    ↓
+Agent 读取 HEARTBEAT.md
+    ↓
+对于长任务: spawn 子 Agent
+    ↓                           ↓
+继续下一个任务               子 Agent 独立工作
+    ↓                           ↓
+所有任务完成                 子 Agent 使用 "message" 工具
+    ↓                           ↓
+响应 HEARTBEAT_OK            用户直接收到结果
+
+```
+
+子 Agent 可以访问工具（message, web_search 等），并且无需通过主 Agent 即可独立与用户通信。
+
+**配置：**
+
+```json
+{
+  "heartbeat": {
+    "enabled": true,
+    "interval": 30
+  }
+}
+```
+
+| 选项       | 默认值 | 描述                         |
+| ---------- | ------ | ---------------------------- |
+| `enabled`  | `true` | 启用/禁用心跳                |
+| `interval` | `30`   | 检查间隔，单位分钟 (最小: 5) |
+
+**环境变量:**
+
+- `PICOCLAW_HEARTBEAT_ENABLED=false` 禁用
+- `PICOCLAW_HEARTBEAT_INTERVAL=60` 更改间隔
+
+### 提供商 (Providers)
+
+> [!NOTE]
+> Groq 通过 Whisper 提供免费的语音转录。如果配置了 Groq，Telegram 语音消息将被自动转录为文字。
+
+| 提供商               | 用途                         | 获取 API Key                                                         |
+| -------------------- | ---------------------------- | -------------------------------------------------------------------- |
+| `gemini`             | LLM (Gemini 直连)            | [aistudio.google.com](https://aistudio.google.com)                   |
+| `zhipu`              | LLM (智谱直连)               | [bigmodel.cn](bigmodel.cn)                                           |
+| `openrouter(待测试)` | LLM (推荐，可访问所有模型)   | [openrouter.ai](https://openrouter.ai)                               |
+| `anthropic(待测试)`  | LLM (Claude 直连)            | [console.anthropic.com](https://console.anthropic.com)               |
+| `openai(待测试)`     | LLM (GPT 直连)               | [platform.openai.com](https://platform.openai.com)                   |
+| `deepseek(待测试)`   | LLM (DeepSeek 直连)          | [platform.deepseek.com](https://platform.deepseek.com)               |
+| `qwen`               | LLM (通义千问)               | [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com) |
+| `groq`               | LLM + **语音转录** (Whisper) | [console.groq.com](https://console.groq.com)                         |
+| `cerebras`           | LLM (Cerebras 直连)          | [cerebras.ai](https://cerebras.ai)                                   |
+
+### 模型配置 (model_list)
+
+> **新功能！** PicoClaw 现在采用**以模型为中心**的配置方式。只需使用 `厂商/模型` 格式（如 `zhipu/glm-4.7`）即可添加新的 provider——**无需修改任何代码！**
+
+该设计同时支持**多 Agent 场景**，提供灵活的 Provider 选择：
+
+- **不同 Agent 使用不同 Provider**：每个 Agent 可以使用自己的 LLM provider
+- **模型回退（Fallback）**：配置主模型和备用模型，提高可靠性
+- **负载均衡**：在多个 API 端点之间分配请求
+- **集中化配置**：在一个地方管理所有 provider
+
+#### 📋 所有支持的厂商
+
+| 厂商                | `model` 前缀      | 默认 API Base                                       | 协议      | 获取 API Key                                                      |
+| ------------------- | ----------------- | --------------------------------------------------- | --------- | ----------------------------------------------------------------- |
+| **OpenAI**          | `openai/`         | `https://api.openai.com/v1`                         | OpenAI    | [获取密钥](https://platform.openai.com)                           |
+| **Anthropic**       | `anthropic/`      | `https://api.anthropic.com/v1`                      | Anthropic | [获取密钥](https://console.anthropic.com)                         |
+| **智谱 AI (GLM)**   | `zhipu/`          | `https://open.bigmodel.cn/api/paas/v4`              | OpenAI    | [获取密钥](https://open.bigmodel.cn/usercenter/proj-mgmt/apikeys) |
+| **DeepSeek**        | `deepseek/`       | `https://api.deepseek.com/v1`                       | OpenAI    | [获取密钥](https://platform.deepseek.com)                         |
+| **Google Gemini**   | `gemini/`         | `https://generativelanguage.googleapis.com/v1beta`  | OpenAI    | [获取密钥](https://aistudio.google.com/api-keys)                  |
+| **Groq**            | `groq/`           | `https://api.groq.com/openai/v1`                    | OpenAI    | [获取密钥](https://console.groq.com)                              |
+| **Moonshot**        | `moonshot/`       | `https://api.moonshot.cn/v1`                        | OpenAI    | [获取密钥](https://platform.moonshot.cn)                          |
+| **通义千问 (Qwen)** | `qwen/`           | `https://dashscope.aliyuncs.com/compatible-mode/v1` | OpenAI    | [获取密钥](https://dashscope.console.aliyun.com)                  |
+| **NVIDIA**          | `nvidia/`         | `https://integrate.api.nvidia.com/v1`               | OpenAI    | [获取密钥](https://build.nvidia.com)                              |
+| **Ollama**          | `ollama/`         | `http://localhost:11434/v1`                         | OpenAI    | 本地（无需密钥）                                                  |
+| **OpenRouter**      | `openrouter/`     | `https://openrouter.ai/api/v1`                      | OpenAI    | [获取密钥](https://openrouter.ai/keys)                            |
+| **VLLM**            | `vllm/`           | `http://localhost:8000/v1`                          | OpenAI    | 本地                                                              |
+| **Cerebras**        | `cerebras/`       | `https://api.cerebras.ai/v1`                        | OpenAI    | [获取密钥](https://cerebras.ai)                                   |
+| **火山引擎**        | `volcengine/`     | `https://ark.cn-beijing.volces.com/api/v3`          | OpenAI    | [获取密钥](https://console.volcengine.com)                        |
+| **神算云**          | `shengsuanyun/`   | `https://router.shengsuanyun.com/api/v1`            | OpenAI    | -                                                                 |
+| **Antigravity**     | `antigravity/`    | Google Cloud                                        | 自定义    | 仅 OAuth                                                          |
+| **GitHub Copilot**  | `github-copilot/` | `localhost:4321`                                    | gRPC      | -                                                                 |
+
+#### 基础配置示例
+
+```json
+{
+  "model_list": [
+    {
+      "model_name": "gpt-5.2",
+      "model": "openai/gpt-5.2",
+      "api_key": "sk-your-openai-key"
+    },
+    {
+      "model_name": "claude-sonnet-4.6",
+      "model": "anthropic/claude-sonnet-4.6",
+      "api_key": "sk-ant-your-key"
+    },
+    {
+      "model_name": "glm-4.7",
+      "model": "zhipu/glm-4.7",
+      "api_key": "your-zhipu-key"
+    }
+  ],
+  "agents": {
+    "defaults": {
+      "model": "gpt-5.2"
+    }
+  }
+}
+```
+
+#### 各厂商配置示例
+
+**OpenAI**
+
+```json
+{
+  "model_name": "gpt-5.2",
+  "model": "openai/gpt-5.2",
+  "api_key": "sk-..."
+}
+```
+
+**智谱 AI (GLM)**
+
+```json
+{
+  "model_name": "glm-4.7",
+  "model": "zhipu/glm-4.7",
+  "api_key": "your-key"
+}
+```
+
+**DeepSeek**
+
+```json
+{
+  "model_name": "deepseek-chat",
+  "model": "deepseek/deepseek-chat",
+  "api_key": "sk-..."
+}
+```
+
+**Anthropic (使用 OAuth)**
+
+```json
+{
+  "model_name": "claude-sonnet-4.6",
+  "model": "anthropic/claude-sonnet-4.6",
+  "auth_method": "oauth"
+}
+```
+
+> 运行 `picoclaw auth login --provider anthropic` 来设置 OAuth 凭证。
+
+**Ollama (本地)**
+
+```json
+{
+  "model_name": "llama3",
+  "model": "ollama/llama3"
+}
+```
+
+**自定义代理/API**
+
+```json
+{
+  "model_name": "my-custom-model",
+  "model": "openai/custom-model",
+  "api_base": "https://my-proxy.com/v1",
+  "api_key": "sk-...",
+  "request_timeout": 300
+}
+```
+
+#### 负载均衡
+
+为同一个模型名称配置多个端点——PicoClaw 会自动在它们之间轮询：
+
+```json
+{
+  "model_list": [
+    {
+      "model_name": "gpt-5.2",
+      "model": "openai/gpt-5.2",
+      "api_base": "https://api1.example.com/v1",
+      "api_key": "sk-key1"
+    },
+    {
+      "model_name": "gpt-5.2",
+      "model": "openai/gpt-5.2",
+      "api_base": "https://api2.example.com/v1",
+      "api_key": "sk-key2"
+    }
+  ]
+}
+```
+
+#### 从旧的 `providers` 配置迁移
+
+旧的 `providers` 配置格式**已弃用**，但为向后兼容仍支持。
+
+**旧配置（已弃用）：**
+
+```json
+{
+  "providers": {
+    "zhipu": {
+      "api_key": "your-key",
+      "api_base": "https://open.bigmodel.cn/api/paas/v4"
+    }
+  },
+  "agents": {
+    "defaults": {
+      "provider": "zhipu",
+      "model": "glm-4.7"
+    }
+  }
+}
+```
+
+**新配置（推荐）：**
+
+```json
+{
+  "model_list": [
+    {
+      "model_name": "glm-4.7",
+      "model": "zhipu/glm-4.7",
+      "api_key": "your-key"
+    }
+  ],
+  "agents": {
+    "defaults": {
+      "model": "glm-4.7"
+    }
+  }
+}
+```
+
+详细的迁移指南请参考 [docs/migration/model-list-migration.md](docs/migration/model-list-migration.md)。
+
+<details>
+<summary><b>智谱 (Zhipu) 配置示例</b></summary>
+
+**1. 获取 API key 和 base URL**
+
+- 获取 [API key](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)
+
+**2. 配置**
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "workspace": "~/.picoclaw/workspace",
+      "model": "glm-4.7",
+      "max_tokens": 8192,
+      "temperature": 0.7,
+      "max_tool_iterations": 20
+    }
+  },
+  "providers": {
+    "zhipu": {
+      "api_key": "Your API Key",
+      "api_base": "https://open.bigmodel.cn/api/paas/v4"
+    }
+  }
+}
+```
+
+**3. 运行**
+
+```bash
+picoclaw agent -m "你好"
+
+```
+
+</details>
+
+<details>
+<summary><b>完整配置示例</b></summary>
+
+```json
+{
+  "agents": {
+    "defaults": {
+      "model": "anthropic/claude-opus-4-5"
+    }
+  },
+  "providers": {
+    "openrouter": {
+      "api_key": "sk-or-v1-xxx"
+    },
+    "groq": {
+      "api_key": "gsk_xxx"
+    }
+  },
+  "channels": {
+    "telegram": {
+      "enabled": true,
+      "token": "123456:ABC...",
+      "allow_from": ["123456789"]
+    },
+    "discord": {
+      "enabled": true,
+      "token": "",
+      "allow_from": [""]
+    },
+    "whatsapp": {
+      "enabled": false
+    },
+    "feishu": {
+      "enabled": false,
+      "app_id": "cli_xxx",
+      "app_secret": "xxx",
+      "encrypt_key": "",
+      "verification_token": "",
+      "allow_from": []
+    },
+    "qq": {
+      "enabled": false,
+      "app_id": "",
+      "app_secret": "",
+      "allow_from": []
+    }
+  },
+  "tools": {
+    "web": {
+      "brave": {
+        "enabled": false,
+        "api_key": "YOUR_BRAVE_API_KEY",
+        "max_results": 5
+      },
+      "duckduckgo": {
+        "enabled": true,
+        "max_results": 5
+      }
+    },
+    "cron": {
+      "exec_timeout_minutes": 5
+    }
+  },
+  "heartbeat": {
+    "enabled": true,
+    "interval": 30
+  }
+}
+```
+
+</details>
+
+## CLI 命令行参考
+
+| 命令                      | 描述               |
+| ------------------------- | ------------------ |
+| `picoclaw onboard`        | 初始化配置和工作区 |
+| `picoclaw agent -m "..."` | 与 Agent 对话      |
+| `picoclaw agent`          | 交互式聊天模式     |
+| `picoclaw gateway`        | 启动网关 (Gateway) |
+| `picoclaw status`         | 显示状态           |
+| `picoclaw cron list`      | 列出所有定时任务   |
+| `picoclaw cron add ...`   | 添加定时任务       |
+
+### 定时任务 / 提醒 (Scheduled Tasks)
+
+PicoClaw 通过 `cron` 工具支持定时提醒和重复任务：
+
+- **一次性提醒**: "Remind me in 10 minutes" (10分钟后提醒我) → 10分钟后触发一次
+- **重复任务**: "Remind me every 2 hours" (每2小时提醒我) → 每2小时触发
+- **Cron 表达式**: "Remind me at 9am daily" (每天上午9点提醒我) → 使用 cron 表达式
+
+任务存储在 `~/.picoclaw/workspace/cron/` 中并自动处理。
+
+## 🤝 贡献与路线图 (Roadmap)
+
+欢迎提交 PR！代码库刻意保持小巧和可读。🤗
+
+路线图即将发布...
+
+开发者群组正在组建中，入群门槛：至少合并过 1 个 PR。
+
+用户群组：
+
+Discord: [https://discord.gg/V4sAZ9XWpN](https://discord.gg/V4sAZ9XWpN)
+
+<img src="assets/wechat.png" alt="PicoClaw" width="512">
+
+## 🐛 疑难解答 (Troubleshooting)
+
+### 网络搜索提示 "API 配置问题"
+
+如果您尚未配置搜索 API Key，这是正常的。PicoClaw 会提供手动搜索的帮助链接。
+
+启用网络搜索：
+
+1. 在 [https://tavily.com](https://tavily.com) (1000 次免费) 或 [https://brave.com/search/api](https://brave.com/search/api) 获取免费 API Key (2000 次免费)
+2. 添加到 `~/.picoclaw/config.json`:
+
+```json
+{
+  "tools": {
+    "web": {
+      "brave": {
+        "enabled": false,
+        "api_key": "YOUR_BRAVE_API_KEY",
+        "max_results": 5
+      },
+      "duckduckgo": {
+        "enabled": true,
+        "max_results": 5
+      }
+    }
+  }
+}
+```
+
+### 遇到内容过滤错误 (Content Filtering Errors)
+
+某些提供商（如智谱）有严格的内容过滤。尝试改写您的问题或使用其他模型。
+
+### Telegram bot 提示 "Conflict: terminated by other getUpdates"
+
+这表示有另一个机器人实例正在运行。请确保同一时间只有一个 `picoclaw gateway` 进程在运行。
+
+---
+
+## 📝 API Key 对比
+
+| 服务 | 免费层级 | 适用场景 |
+| --- | --- | --- |
+| **OpenRouter** | 200K tokens/月 | 多模型聚合 (Claude, GPT-4 等) |
+| **智谱 (Zhipu)** | 200K tokens/月 | 最适合中国用户 |
+| **Brave Search** | 2000 次查询/月 | 网络搜索功能 |
+| **Tavily** | 1000 次查询/月 | AI Agent 搜索优化 |
+| **Groq** | 提供免费层级 | 极速推理 (Llama, Mixtral) |

cmd/membench/eval.go

@@ -1,412 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/sipeed/picoclaw/pkg/seahorse"
-)
-
-// EvalResult holds per-sample evaluation results for one mode.
-type EvalResult struct {
-	Mode      string     `json:"mode"`
-	SampleID  string     `json:"sampleId"`
-	QAResults []QAResult `json:"qaResults"`
-	Agg       AggMetrics `json:"aggregated"`
-}
-
-// QAResult holds metrics for a single QA pair.
-type QAResult struct {
-	Question   string  `json:"question"`
-	Category   int     `json:"category"`
-	GoldAnswer string  `json:"goldAnswer"`
-	TokenF1    float64 `json:"tokenF1"`
-	HitRate    float64 `json:"hitRate"`
-}
-
-// AggMetrics holds aggregated evaluation metrics.
-type AggMetrics struct {
-	OverallF1      float64             `json:"overallF1"`
-	OverallHitRate float64             `json:"overallHitRate"`
-	ByCategory     map[int]*CatMetrics `json:"byCategory"`
-	TotalQuestions int                 `json:"totalQuestions"`
-	ValidF1Count   int                 `json:"validF1Count"`
-}
-
-// CatMetrics holds metrics for a single category.
-type CatMetrics struct {
-	F1            float64 `json:"f1"`
-	HitRate       float64 `json:"hitRate"`
-	QuestionCount int     `json:"questionCount"`
-	ValidF1Count  int     `json:"validF1Count"`
-}
-
-// EvalLegacy evaluates using legacy session store (raw history + budget truncation).
-func EvalLegacy(
-	ctx context.Context,
-	samples []LocomoSample,
-	legacy *LegacyStore,
-	budgetTokens int,
-) []EvalResult {
-	results := make([]EvalResult, 0, len(samples))
-	for si := range samples {
-		sample := &samples[si]
-		history := legacy.GetHistory(sample.SampleID)
-
-		// Convert messages to content strings
-		allContent := make([]string, 0, len(history))
-		for _, msg := range history {
-			allContent = append(allContent, msg.Content)
-		}
-
-		qaResults := make([]QAResult, 0, len(sample.QA))
-		for qi := range sample.QA {
-			qa := &sample.QA[qi]
-			// Budget truncate the full history
-			truncated, _ := BudgetTruncate(allContent, budgetTokens)
-			context := StringListToContent(truncated)
-
-			f1 := TokenOverlapF1(context, qa.AnswerString())
-			hitRate := RecallHitRate(qa.Evidence, sample, context)
-
-			qaResults = append(qaResults, QAResult{
-				Question:   qa.Question,
-				Category:   qa.Category,
-				GoldAnswer: qa.AnswerString(),
-				TokenF1:    f1,
-				HitRate:    hitRate,
-			})
-		}
-
-		results = append(results, EvalResult{
-			Mode:      "legacy",
-			SampleID:  sample.SampleID,
-			QAResults: qaResults,
-			Agg:       aggregateMetrics(qaResults),
-		})
-	}
-	return results
-}
-
-// EvalSeahorse evaluates using seahorse short memory (per-keyword search + expand).
-func EvalSeahorse(
-	ctx context.Context,
-	samples []LocomoSample,
-	ir *SeahorseIngestResult,
-	budgetTokens int,
-) []EvalResult {
-	store := ir.Engine.GetRetrieval().Store()
-	retrieval := ir.Engine.GetRetrieval()
-
-	results := make([]EvalResult, 0, len(samples))
-	for si := range samples {
-		sample := &samples[si]
-		convID, ok := ir.ConvMap[sample.SampleID]
-		if !ok {
-			log.Printf("WARN: no conversation ID for sample %s", sample.SampleID)
-			continue
-		}
-
-		qaResults := make([]QAResult, 0, len(sample.QA))
-		for qi := range sample.QA {
-			qa := &sample.QA[qi]
-			keywords := ExtractKeywords(qa.Question)
-
-			// Search each keyword individually and union results,
-			// tracking best BM25 rank per message for relevance sorting.
-			bestRank := map[int64]float64{}
-			for _, kw := range keywords {
-				searchResults, err := store.SearchMessages(ctx, seahorse.SearchInput{
-					Pattern:        kw,
-					ConversationID: convID,
-					Limit:          20,
-				})
-				if err != nil {
-					log.Printf("WARN: search failed for keyword %q: %v", kw, err)
-					continue
-				}
-				for _, sr := range searchResults {
-					if sr.MessageID > 0 {
-						if prev, ok := bestRank[sr.MessageID]; !ok || sr.Rank < prev {
-							bestRank[sr.MessageID] = sr.Rank
-						}
-					}
-				}
-			}
-			// Sort messageIDs by rank ascending (best/most-negative first).
-			// BudgetTruncate walks from the front, keeping best-ranked messages.
-			// Note: SQLite FTS5 bm25() returns negative values where more
-			// negative = better match.
-			messageIDs := make([]int64, 0, len(bestRank))
-			for id := range bestRank {
-				messageIDs = append(messageIDs, id)
-			}
-			sort.Slice(messageIDs, func(i, j int) bool {
-				return bestRank[messageIDs[i]] < bestRank[messageIDs[j]]
-			})
-
-			// Expand messages to get full content
-			var contentParts []string
-			if len(messageIDs) > 0 {
-				expandResult, err := retrieval.ExpandMessages(ctx, messageIDs)
-				if err != nil {
-					log.Printf("WARN: expand failed for sample %s: %v", sample.SampleID, err)
-				} else {
-					for _, msg := range expandResult.Messages {
-						contentParts = append(contentParts, msg.Content)
-					}
-				}
-			}
-
-			if len(contentParts) == 0 {
-				qaResults = append(qaResults, QAResult{
-					Question:   qa.Question,
-					Category:   qa.Category,
-					GoldAnswer: qa.AnswerString(),
-					TokenF1:    0.0,
-					HitRate:    0.0,
-				})
-				continue
-			}
-
-			// Budget truncate (drop worst-ranked)
-			truncated, _ := BudgetTruncate(contentParts, budgetTokens)
-			context := StringListToContent(truncated)
-
-			f1 := TokenOverlapF1(context, qa.AnswerString())
-			hitRate := RecallHitRate(qa.Evidence, sample, context)
-
-			qaResults = append(qaResults, QAResult{
-				Question:   qa.Question,
-				Category:   qa.Category,
-				GoldAnswer: qa.AnswerString(),
-				TokenF1:    f1,
-				HitRate:    hitRate,
-			})
-		}
-
-		results = append(results, EvalResult{
-			Mode:      "seahorse",
-			SampleID:  sample.SampleID,
-			QAResults: qaResults,
-			Agg:       aggregateMetrics(qaResults),
-		})
-	}
-	return results
-}
-
-// aggregateMetrics computes overall and per-category metrics.
-func aggregateMetrics(qaResults []QAResult) AggMetrics {
-	type catAccum struct {
-		f1Sum        float64
-		f1Count      int
-		hitRateSum   float64
-		hitRateCount int
-	}
-	byCatAcc := map[int]*catAccum{}
-	totalF1 := 0.0
-	totalHitRate := 0.0
-	validF1Count := 0
-	for _, qr := range qaResults {
-		// Skip sentinel -1.0 scores (LLM API/parse failures) from F1 averaging.
-		if qr.TokenF1 >= 0 {
-			totalF1 += qr.TokenF1
-			validF1Count++
-		}
-		totalHitRate += qr.HitRate
-		acc, ok := byCatAcc[qr.Category]
-		if !ok {
-			acc = &catAccum{}
-			byCatAcc[qr.Category] = acc
-		}
-		if qr.TokenF1 >= 0 {
-			acc.f1Sum += qr.TokenF1
-			acc.f1Count++
-		}
-		acc.hitRateSum += qr.HitRate
-		acc.hitRateCount++
-	}
-	nHit := len(qaResults)
-	if nHit == 0 {
-		nHit = 1
-	}
-	byCat := map[int]*CatMetrics{}
-	for cat, acc := range byCatAcc {
-		cm := &CatMetrics{
-			QuestionCount: acc.hitRateCount,
-			ValidF1Count:  acc.f1Count,
-		}
-		if acc.f1Count > 0 {
-			cm.F1 = acc.f1Sum / float64(acc.f1Count)
-		}
-		if acc.hitRateCount > 0 {
-			cm.HitRate = acc.hitRateSum / float64(acc.hitRateCount)
-		}
-		byCat[cat] = cm
-	}
-	var overallF1 float64
-	if validF1Count > 0 {
-		overallF1 = totalF1 / float64(validF1Count)
-	}
-	return AggMetrics{
-		OverallF1:      overallF1,
-		OverallHitRate: totalHitRate / float64(nHit),
-		ByCategory:     byCat,
-		TotalQuestions: len(qaResults),
-		ValidF1Count:   validF1Count,
-	}
-}
-
-// SaveResults writes per-sample eval results to JSON files.
-func SaveResults(results []EvalResult, outDir string) error {
-	if err := os.MkdirAll(outDir, 0o755); err != nil {
-		return fmt.Errorf("create output dir: %w", err)
-	}
-	for _, r := range results {
-		path := filepath.Join(outDir, fmt.Sprintf("eval_%s_%s.json", r.Mode, r.SampleID))
-		data, err := json.MarshalIndent(r, "", "  ")
-		if err != nil {
-			return fmt.Errorf("marshal result: %w", err)
-		}
-		if err := os.WriteFile(path, data, 0o644); err != nil {
-			return fmt.Errorf("write result: %w", err)
-		}
-	}
-	return nil
-}
-
-// SaveAggregated writes a combined results.json with all modes.
-func SaveAggregated(results []EvalResult, outDir string) error {
-	byMode := map[string][]EvalResult{}
-	for _, r := range results {
-		byMode[r.Mode] = append(byMode[r.Mode], r)
-	}
-
-	aggMap := map[string]AggMetrics{}
-	for mode, modeResults := range byMode {
-		aggMap[mode] = computeModeAgg(modeResults)
-	}
-
-	data, err := json.MarshalIndent(aggMap, "", "  ")
-	if err != nil {
-		return err
-	}
-	return os.WriteFile(filepath.Join(outDir, "results.json"), data, 0o644)
-}
-
-// computeModeAgg aggregates results for a single mode using weighted averaging
-// (weighted by question count per sample). All modes must have the same Mode field.
-func computeModeAgg(results []EvalResult) AggMetrics {
-	agg := AggMetrics{ByCategory: map[int]*CatMetrics{}}
-	for _, r := range results {
-		// Backward compat: old eval JSON (token mode) without ValidF1Count → use TotalQuestions.
-		// LLM modes may legitimately have ValidF1Count==0 (all failures).
-		vf1 := r.Agg.ValidF1Count
-		if vf1 == 0 && r.Agg.TotalQuestions > 0 && !strings.HasSuffix(r.Mode, "-llm") {
-			vf1 = r.Agg.TotalQuestions
-		}
-		agg.OverallF1 += r.Agg.OverallF1 * float64(vf1)
-		agg.OverallHitRate += r.Agg.OverallHitRate * float64(r.Agg.TotalQuestions)
-		agg.TotalQuestions += r.Agg.TotalQuestions
-		agg.ValidF1Count += vf1
-		for cat, cm := range r.Agg.ByCategory {
-			existing, ok := agg.ByCategory[cat]
-			if !ok {
-				existing = &CatMetrics{}
-				agg.ByCategory[cat] = existing
-			}
-			cvf1 := cm.ValidF1Count
-			if cvf1 == 0 && cm.QuestionCount > 0 && !strings.HasSuffix(r.Mode, "-llm") {
-				cvf1 = cm.QuestionCount
-			}
-			existing.F1 += cm.F1 * float64(cvf1)
-			existing.HitRate += cm.HitRate * float64(cm.QuestionCount)
-			existing.QuestionCount += cm.QuestionCount
-			existing.ValidF1Count += cvf1
-		}
-	}
-	if agg.ValidF1Count > 0 {
-		agg.OverallF1 /= float64(agg.ValidF1Count)
-	}
-	if agg.TotalQuestions > 0 {
-		agg.OverallHitRate /= float64(agg.TotalQuestions)
-	}
-	for _, cat := range agg.ByCategory {
-		if cat.ValidF1Count > 0 {
-			cat.F1 /= float64(cat.ValidF1Count)
-		}
-		if cat.QuestionCount > 0 {
-			cat.HitRate /= float64(cat.QuestionCount)
-		}
-	}
-	return agg
-}
-
-// printSection prints a single comparison table section.
-func printSection(title string, results []EvalResult) {
-	fmt.Printf("\n--- %s ---\n", title)
-	byMode := map[string][]EvalResult{}
-	for _, r := range results {
-		byMode[r.Mode] = append(byMode[r.Mode], r)
-	}
-
-	modes := map[string]AggMetrics{}
-	for mode, modeResults := range byMode {
-		modes[mode] = computeModeAgg(modeResults)
-	}
-
-	modeKeys := make([]string, 0, len(modes))
-	for k := range modes {
-		modeKeys = append(modeKeys, k)
-	}
-	sort.Strings(modeKeys)
-
-	// Collect all category keys across modes
-	catSet := map[int]bool{}
-	for _, agg := range modes {
-		for cat := range agg.ByCategory {
-			catSet[cat] = true
-		}
-	}
-	cats := make([]int, 0, len(catSet))
-	for cat := range catSet {
-		cats = append(cats, cat)
-	}
-	sort.Ints(cats)
-
-	fmt.Printf("%-10s %-8s %-8s", "Mode", "HitRate", "F1")
-	for _, cat := range cats {
-		fmt.Printf(" %-7s", fmt.Sprintf("C%d", cat))
-	}
-	fmt.Println()
-	fmt.Println(strings.Repeat("-", 10+8+8+7*len(cats)+8))
-
-	for _, mode := range modeKeys {
-		agg := modes[mode]
-		fmt.Printf("%-10s %-8.4f %-8.4f", mode, agg.OverallHitRate, agg.OverallF1)
-		for _, cat := range cats {
-			if cm, ok := agg.ByCategory[cat]; ok {
-				fmt.Printf(" %-7.4f", cm.HitRate)
-			} else {
-				fmt.Printf(" %-7s", "N/A")
-			}
-		}
-		fmt.Println()
-	}
-}
-
-// PrintComparison outputs a human-readable comparison table to stdout.
-func PrintComparison(results []EvalResult, llmResults []EvalResult) {
-	if len(results) > 0 {
-		printSection("No LLM generation", results)
-	}
-	if len(llmResults) > 0 {
-		printSection("With LLM", llmResults)
-	}
-}

cmd/membench/eval_llm.go

@@ -1,346 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/sipeed/picoclaw/pkg/seahorse"
-)
-
-const answerSystemPrompt = `You are a helpful assistant. Given conversation context, answer the question concisely and accurately. If the answer is not in the context, say "I don't know". Answer in 1-3 sentences maximum.`
-
-const judgeSystemPrompt = `You are an impartial judge evaluating answer quality.
-Compare the candidate answer against the reference answer.
-Consider semantic equivalence — different wording expressing the same meaning should score high.
-
-Output ONLY a single integer score from 1 to 5:
-1 = completely wrong or irrelevant
-2 = partially related but mostly incorrect
-3 = partially correct, missing key details
-4 = mostly correct with minor omissions
-5 = fully correct, semantically equivalent
-
-Output ONLY the number, nothing else.`
-
-// generateAnswer asks the LLM to answer a question given retrieved context.
-func generateAnswer(ctx context.Context, client *LLMClient, contextText, question string) (string, error) {
-	// Truncate context to avoid exceeding model limits while preserving valid UTF-8.
-	contextRunes := []rune(contextText)
-	if len(contextRunes) > 6000 {
-		contextText = string(contextRunes[:6000]) + "\n... [truncated]"
-	}
-
-	userPrompt := fmt.Sprintf("## Conversation Context\n\n%s\n\n## Question\n\n%s", contextText, question)
-	return client.Complete(ctx, answerSystemPrompt, userPrompt)
-}
-
-// scoreRe matches the first standalone integer 1-5 in the judge response.
-var scoreRe = regexp.MustCompile(`\b([1-5])\b`)
-
-// judgeAnswer asks the LLM to score the candidate answer vs the gold answer.
-// Returns a score from 0.0 to 1.0, or -1.0 on parse failure.
-func judgeAnswer(
-	ctx context.Context,
-	judgeClient *LLMClient,
-	question, goldAnswer, candidateAnswer string,
-) (float64, error) {
-	userPrompt := fmt.Sprintf(
-		"Question: %s\n\nReference Answer: %s\n\nCandidate Answer: %s\n\nScore:",
-		question, goldAnswer, candidateAnswer,
-	)
-
-	response, err := judgeClient.Complete(ctx, judgeSystemPrompt, userPrompt)
-	if err != nil {
-		return -1.0, err
-	}
-
-	response = strings.TrimSpace(response)
-	if m := scoreRe.FindStringSubmatch(response); len(m) == 2 {
-		score, _ := strconv.Atoi(m[1])
-		return float64(score-1) / 4.0, nil // Normalize 1-5 to 0.0-1.0
-	}
-	log.Printf("WARNING: could not parse judge score from: %q, returning -1", response)
-	return -1.0, nil
-}
-
-// qaWork describes one QA evaluation unit.
-type qaWork struct {
-	sampleID    string
-	qaIndex     int
-	globalIndex int
-	totalQA     int
-	qa          *LocomoQA
-	contextText string
-	sample      *LocomoSample
-}
-
-// qaResult collects one QA evaluation output.
-type qaResultOut struct {
-	index  int // position in the flat QA list for ordering
-	result QAResult
-	answer string
-	score  float64
-}
-
-// evalQAWorker processes a single QA item: generate answer + judge score.
-func evalQAWorker(
-	ctx context.Context,
-	w qaWork,
-	answerClient, judgeClient *LLMClient,
-	logPrefix string,
-) qaResultOut {
-	llmAnswer, err := generateAnswer(ctx, answerClient, w.contextText, w.qa.Question)
-	if err != nil {
-		log.Printf("WARN: LLM generation failed for sample %s Q%d: %v", w.sampleID, w.qaIndex, err)
-		llmAnswer = ""
-	}
-
-	score := -1.0
-	if llmAnswer != "" {
-		score, err = judgeAnswer(ctx, judgeClient, w.qa.Question, w.qa.AnswerString(), llmAnswer)
-		if err != nil {
-			log.Printf("WARN: LLM judge failed for sample %s Q%d: %v", w.sampleID, w.qaIndex, err)
-		}
-	}
-
-	hitRate := RecallHitRate(w.qa.Evidence, w.sample, w.contextText)
-
-	log.Printf("[%s] sample=%s q=%d/%d score=%.2f answer=%q",
-		logPrefix, w.sampleID, w.globalIndex, w.totalQA, score, truncateStr(llmAnswer, 80))
-
-	return qaResultOut{
-		index: w.globalIndex,
-		result: QAResult{
-			Question:   w.qa.Question,
-			Category:   w.qa.Category,
-			GoldAnswer: w.qa.AnswerString(),
-			TokenF1:    score,
-			HitRate:    hitRate,
-		},
-		answer: llmAnswer,
-		score:  score,
-	}
-}
-
-// EvalLegacyLLM evaluates legacy store using LLM generation + LLM-as-Judge.
-func EvalLegacyLLM(
-	ctx context.Context,
-	samples []LocomoSample,
-	legacy *LegacyStore,
-	budgetTokens int,
-	answerClient, judgeClient *LLMClient,
-	concurrency int,
-) []EvalResult {
-	if concurrency < 1 {
-		concurrency = 1
-	}
-	totalQA := countTotalQA(samples)
-	results := make([]EvalResult, 0, len(samples))
-
-	for si := range samples {
-		sample := &samples[si]
-		history := legacy.GetHistory(sample.SampleID)
-
-		allContent := make([]string, 0, len(history))
-		for _, msg := range history {
-			allContent = append(allContent, msg.Content)
-		}
-
-		truncated, _ := BudgetTruncate(allContent, budgetTokens)
-		contextText := StringListToContent(truncated)
-
-		qaResults := make([]QAResult, len(sample.QA))
-
-		if concurrency <= 1 {
-			for qi := range sample.QA {
-				out := evalQAWorker(ctx, qaWork{
-					sampleID: sample.SampleID, qaIndex: qi,
-					globalIndex: si*len(sample.QA) + qi + 1, totalQA: totalQA,
-					qa: &sample.QA[qi], contextText: contextText, sample: sample,
-				}, answerClient, judgeClient, "legacy-llm")
-				qaResults[qi] = out.result
-			}
-		} else {
-			sem := make(chan struct{}, concurrency)
-			var wg sync.WaitGroup
-			for qi := range sample.QA {
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
-					sem <- struct{}{}
-					defer func() { <-sem }()
-					out := evalQAWorker(ctx, qaWork{
-						sampleID: sample.SampleID, qaIndex: qi,
-						globalIndex: si*len(sample.QA) + qi + 1, totalQA: totalQA,
-						qa: &sample.QA[qi], contextText: contextText, sample: sample,
-					}, answerClient, judgeClient, "legacy-llm")
-					qaResults[qi] = out.result // safe: each goroutine writes distinct index
-				}()
-			}
-			wg.Wait()
-		}
-
-		results = append(results, EvalResult{
-			Mode:      "legacy-llm",
-			SampleID:  sample.SampleID,
-			QAResults: qaResults,
-			Agg:       aggregateMetrics(qaResults),
-		})
-	}
-	return results
-}
-
-// buildSeahorseContext retrieves context for a seahorse QA item.
-func buildSeahorseContext(
-	ctx context.Context,
-	ir *SeahorseIngestResult,
-	sample *LocomoSample,
-	qa *LocomoQA,
-	budgetTokens int,
-) string {
-	store := ir.Engine.GetRetrieval().Store()
-	retrieval := ir.Engine.GetRetrieval()
-	convID := ir.ConvMap[sample.SampleID]
-
-	keywords := ExtractKeywords(qa.Question)
-	bestRank := map[int64]float64{}
-	for _, kw := range keywords {
-		searchResults, err := store.SearchMessages(ctx, seahorse.SearchInput{
-			Pattern:        kw,
-			ConversationID: convID,
-			Limit:          20,
-		})
-		if err != nil {
-			continue
-		}
-		for _, sr := range searchResults {
-			if sr.MessageID > 0 {
-				if prev, ok := bestRank[sr.MessageID]; !ok || sr.Rank < prev {
-					bestRank[sr.MessageID] = sr.Rank
-				}
-			}
-		}
-	}
-
-	messageIDs := make([]int64, 0, len(bestRank))
-	for id := range bestRank {
-		messageIDs = append(messageIDs, id)
-	}
-	sort.Slice(messageIDs, func(i, j int) bool {
-		return bestRank[messageIDs[i]] < bestRank[messageIDs[j]]
-	})
-
-	var contentParts []string
-	if len(messageIDs) > 0 {
-		expandResult, err := retrieval.ExpandMessages(ctx, messageIDs)
-		if err == nil {
-			for _, msg := range expandResult.Messages {
-				contentParts = append(contentParts, msg.Content)
-			}
-		}
-	}
-	if len(contentParts) == 0 {
-		return ""
-	}
-	truncated, _ := BudgetTruncate(contentParts, budgetTokens)
-	return StringListToContent(truncated)
-}
-
-// EvalSeahorseLLM evaluates seahorse retrieval using LLM generation + LLM-as-Judge.
-func EvalSeahorseLLM(
-	ctx context.Context,
-	samples []LocomoSample,
-	ir *SeahorseIngestResult,
-	budgetTokens int,
-	answerClient, judgeClient *LLMClient,
-	concurrency int,
-) []EvalResult {
-	if concurrency < 1 {
-		concurrency = 1
-	}
-	totalQA := countTotalQA(samples)
-	results := make([]EvalResult, 0, len(samples))
-
-	for si := range samples {
-		sample := &samples[si]
-		if _, ok := ir.ConvMap[sample.SampleID]; !ok {
-			log.Printf("WARN: no conversation ID for sample %s", sample.SampleID)
-			continue
-		}
-
-		qaResults := make([]QAResult, len(sample.QA))
-
-		evalOne := func(qi int) {
-			qa := &sample.QA[qi]
-			contextText := buildSeahorseContext(ctx, ir, sample, qa, budgetTokens)
-			if contextText == "" {
-				qaResults[qi] = QAResult{
-					Question:   qa.Question,
-					Category:   qa.Category,
-					GoldAnswer: qa.AnswerString(),
-					TokenF1:    0.0,
-					HitRate:    0.0,
-				}
-				log.Printf("[seahorse-llm] sample=%s q=%d/%d score=0.00 answer=(no context)",
-					sample.SampleID, si*len(sample.QA)+qi+1, totalQA)
-				return
-			}
-			out := evalQAWorker(ctx, qaWork{
-				sampleID: sample.SampleID, qaIndex: qi,
-				globalIndex: si*len(sample.QA) + qi + 1, totalQA: totalQA,
-				qa: qa, contextText: contextText, sample: sample,
-			}, answerClient, judgeClient, "seahorse-llm")
-			qaResults[qi] = out.result
-		}
-
-		if concurrency <= 1 {
-			for qi := range sample.QA {
-				evalOne(qi)
-			}
-		} else {
-			sem := make(chan struct{}, concurrency)
-			var wg sync.WaitGroup
-			for qi := range sample.QA {
-				wg.Add(1)
-				go func() {
-					defer wg.Done()
-					sem <- struct{}{}
-					defer func() { <-sem }()
-					evalOne(qi)
-				}()
-			}
-			wg.Wait()
-		}
-
-		results = append(results, EvalResult{
-			Mode:      "seahorse-llm",
-			SampleID:  sample.SampleID,
-			QAResults: qaResults,
-			Agg:       aggregateMetrics(qaResults),
-		})
-	}
-	return results
-}
-
-func countTotalQA(samples []LocomoSample) int {
-	n := 0
-	for i := range samples {
-		n += len(samples[i].QA)
-	}
-	return n
-}
-
-func truncateStr(s string, maxLen int) string {
-	s = strings.ReplaceAll(s, "\n", " ")
-	runes := []rune(s)
-	if len(runes) > maxLen {
-		return string(runes[:maxLen]) + "..."
-	}
-	return s
-}

cmd/membench/eval_test.go

@@ -1,182 +0,0 @@
-package main
-
-import (
-	"math"
-	"testing"
-)
-
-func TestComputeModeAggAllCategories(t *testing.T) {
-	results := []EvalResult{
-		{
-			Mode:     "test",
-			SampleID: "s1",
-			QAResults: []QAResult{
-				{Category: 1, TokenF1: 0.5, HitRate: 0.8},
-				{Category: 2, TokenF1: 0.3, HitRate: 0.6},
-				{Category: 3, TokenF1: 0.1, HitRate: 0.4},
-				{Category: 4, TokenF1: 0.7, HitRate: 0.9},
-				{Category: 5, TokenF1: 0.2, HitRate: 0.1},
-			},
-		},
-	}
-	for i := range results {
-		results[i].Agg = aggregateMetrics(results[i].QAResults)
-	}
-
-	got := computeModeAgg(results)
-
-	// Should have all 5 categories
-	for cat := 1; cat <= 5; cat++ {
-		cm, ok := got.ByCategory[cat]
-		if !ok {
-			t.Errorf("ByCategory missing category %d", cat)
-			continue
-		}
-		if cm.QuestionCount != 1 {
-			t.Errorf("ByCategory[%d].QuestionCount = %d, want 1", cat, cm.QuestionCount)
-		}
-	}
-
-	// Verify specific F1 values per category
-	wantF1 := map[int]float64{1: 0.5, 2: 0.3, 3: 0.1, 4: 0.7, 5: 0.2}
-	for cat, want := range wantF1 {
-		if cm, ok := got.ByCategory[cat]; ok {
-			if math.Abs(cm.F1-want) > 1e-9 {
-				t.Errorf("ByCategory[%d].F1 = %.4f, want %.4f", cat, cm.F1, want)
-			}
-		}
-	}
-}
-
-func TestComputeModeAgg(t *testing.T) {
-	// Two samples with different question counts:
-	//   sample-a: 2 questions, F1 = [0.4, 0.6] → avg 0.5
-	//   sample-b: 8 questions, F1 = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] → avg 0.1
-	//
-	// Unweighted (PrintComparison bug): (0.5 + 0.1) / 2 = 0.3
-	// Weighted (correct):              (0.4+0.6 + 0.1*8) / 10 = 1.8 / 10 = 0.18
-	results := []EvalResult{
-		{
-			Mode:     "test",
-			SampleID: "sample-a",
-			QAResults: []QAResult{
-				{TokenF1: 0.4, HitRate: 0.5},
-				{TokenF1: 0.6, HitRate: 0.7},
-			},
-		},
-		{
-			Mode:     "test",
-			SampleID: "sample-b",
-			QAResults: []QAResult{
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-				{TokenF1: 0.1, HitRate: 0.2},
-			},
-		},
-	}
-	// Compute per-sample aggregates
-	for i := range results {
-		results[i].Agg = aggregateMetrics(results[i].QAResults)
-	}
-
-	got := computeModeAgg(results)
-
-	// Weighted: (0.4+0.6+0.1*8) / 10 = 1.8/10 = 0.18
-	wantF1 := 0.18
-	if math.Abs(got.OverallF1-wantF1) > 1e-9 {
-		t.Errorf("OverallF1 = %.6f, want %.6f (weighted average)", got.OverallF1, wantF1)
-	}
-
-	// Weighted: (0.5+0.7+0.2*8) / 10 = 2.8/10 = 0.28
-	wantRecall := 0.28
-	if math.Abs(got.OverallHitRate-wantRecall) > 1e-9 {
-		t.Errorf("OverallHitRate = %.6f, want %.6f (weighted average)", got.OverallHitRate, wantRecall)
-	}
-
-	if got.TotalQuestions != 10 {
-		t.Errorf("TotalQuestions = %d, want 10", got.TotalQuestions)
-	}
-}
-
-func TestAggregateMetricsSentinel(t *testing.T) {
-	qa := []QAResult{
-		{Category: 1, TokenF1: 0.8, HitRate: 0.5},
-		{Category: 1, TokenF1: -1.0, HitRate: 0.3},
-		{Category: 1, TokenF1: 0.4, HitRate: 0.7},
-	}
-	agg := aggregateMetrics(qa)
-
-	if agg.ValidF1Count != 2 {
-		t.Errorf("ValidF1Count = %d, want 2", agg.ValidF1Count)
-	}
-	if agg.TotalQuestions != 3 {
-		t.Errorf("TotalQuestions = %d, want 3", agg.TotalQuestions)
-	}
-	wantF1 := (0.8 + 0.4) / 2.0
-	if math.Abs(agg.OverallF1-wantF1) > 1e-9 {
-		t.Errorf("OverallF1 = %.6f, want %.6f", agg.OverallF1, wantF1)
-	}
-	wantHR := (0.5 + 0.3 + 0.7) / 3.0
-	if math.Abs(agg.OverallHitRate-wantHR) > 1e-9 {
-		t.Errorf("OverallHitRate = %.6f, want %.6f", agg.OverallHitRate, wantHR)
-	}
-}
-
-func TestAggregateMetricsAllSentinel(t *testing.T) {
-	qa := []QAResult{
-		{Category: 1, TokenF1: -1.0, HitRate: 0.5},
-		{Category: 1, TokenF1: -1.0, HitRate: 0.3},
-	}
-	agg := aggregateMetrics(qa)
-
-	if agg.ValidF1Count != 0 {
-		t.Errorf("ValidF1Count = %d, want 0", agg.ValidF1Count)
-	}
-	if agg.OverallF1 != 0 {
-		t.Errorf("OverallF1 = %.6f, want 0", agg.OverallF1)
-	}
-}
-
-func TestComputeModeAggSentinelWeighting(t *testing.T) {
-	results := []EvalResult{
-		{
-			Mode:     "test",
-			SampleID: "s1",
-			QAResults: []QAResult{
-				{Category: 1, TokenF1: 0.8, HitRate: 0.5},
-				{Category: 1, TokenF1: -1.0, HitRate: 0.3},
-			},
-		},
-		{
-			Mode:     "test",
-			SampleID: "s2",
-			QAResults: []QAResult{
-				{Category: 1, TokenF1: 0.4, HitRate: 0.6},
-				{Category: 1, TokenF1: 0.6, HitRate: 0.8},
-			},
-		},
-	}
-	for i := range results {
-		results[i].Agg = aggregateMetrics(results[i].QAResults)
-	}
-
-	got := computeModeAgg(results)
-
-	// s1: ValidF1Count=1, F1=0.8; s2: ValidF1Count=2, F1=0.5
-	// Weighted: (0.8*1 + 0.5*2) / 3 = 1.8/3 = 0.6
-	wantF1 := 0.6
-	if math.Abs(got.OverallF1-wantF1) > 1e-9 {
-		t.Errorf("OverallF1 = %.6f, want %.6f", got.OverallF1, wantF1)
-	}
-	if got.ValidF1Count != 3 {
-		t.Errorf("ValidF1Count = %d, want 3", got.ValidF1Count)
-	}
-	if got.TotalQuestions != 4 {
-		t.Errorf("TotalQuestions = %d, want 4", got.TotalQuestions)
-	}
-}

cmd/membench/ingest.go

@@ -1,85 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/sipeed/picoclaw/pkg/seahorse"
-)
-
-// ConvMap stores the mapping from sampleID to seahorse ConversationID.
-type ConvMap map[string]int64
-
-// SeahorseIngestResult holds the results of ingesting into seahorse.
-type SeahorseIngestResult struct {
-	Engine  *seahorse.Engine
-	ConvMap ConvMap // sampleID → conversationID
-}
-
-// IngestSeahorse loads all LOCOMO samples into a seahorse Engine.
-// Returns the engine and a mapping from sampleID to conversationID for scoped retrieval.
-func IngestSeahorse(ctx context.Context, samples []LocomoSample, dbPath string) (*SeahorseIngestResult, error) {
-	noopFn := func(ctx context.Context, prompt string, opts seahorse.CompleteOptions) (string, error) {
-		return "", nil
-	}
-
-	engine, err := seahorse.NewEngine(seahorse.Config{
-		DBPath: dbPath,
-	}, noopFn)
-	if err != nil {
-		return nil, fmt.Errorf("create seahorse engine: %w", err)
-	}
-
-	store := engine.GetRetrieval().Store()
-	convMap := make(ConvMap)
-
-	for si := range samples {
-		sample := &samples[si]
-		sessionKey := "locomo-" + sample.SampleID
-
-		// Check if conversation already exists (idempotent)
-		existing, _ := store.GetConversationBySessionKey(ctx, sessionKey)
-		if existing != nil {
-			convMap[sample.SampleID] = existing.ConversationID
-			log.Printf("Skipping existing sample %s: convID=%d", sample.SampleID, existing.ConversationID)
-			continue
-		}
-
-		turns := GetTurns(sample)
-
-		// Convert turns to seahorse messages
-		msgs := make([]seahorse.Message, 0, len(turns))
-		for _, turn := range turns {
-			content := turn.Speaker + ": " + turn.Text
-			msgs = append(msgs, seahorse.Message{
-				Role:       "user",
-				Content:    content,
-				TokenCount: len(turn.Text) / 4,
-			})
-		}
-
-		// Ingest all turns for this sample
-		_, err := engine.Ingest(ctx, sessionKey, msgs)
-		if err != nil {
-			return nil, fmt.Errorf("ingest sample %s: %w", sample.SampleID, err)
-		}
-
-		// Get the conversation ID for scoped retrieval
-		conv, err := store.GetConversationBySessionKey(ctx, sessionKey)
-		if err != nil {
-			return nil, fmt.Errorf("get conversation for %s: %w", sample.SampleID, err)
-		}
-		if conv == nil {
-			return nil, fmt.Errorf("conversation not found for %s after ingest", sample.SampleID)
-		}
-		convMap[sample.SampleID] = conv.ConversationID
-		log.Printf("Ingested sample %s: %d turns, convID=%d", sample.SampleID, len(turns), conv.ConversationID)
-	}
-
-	log.Printf("Seahorse ingestion complete: %d samples, %d conversations", len(samples), len(convMap))
-	return &SeahorseIngestResult{
-		Engine:  engine,
-		ConvMap: convMap,
-	}, nil
-}

cmd/membench/ingest_test.go

@@ -1,79 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"path/filepath"
-	"testing"
-
-	"github.com/sipeed/picoclaw/pkg/seahorse"
-)
-
-func TestIngestSeahorseIdempotent(t *testing.T) {
-	ctx := context.Background()
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "test.db")
-
-	// Minimal test data
-	samples := []LocomoSample{
-		{
-			SampleID: "test-1",
-			Conversation: map[string]json.RawMessage{
-				"session_1": json.RawMessage(`[
-					{"speaker":"A","dia_id":"D1:1","text":"hello world this is a test message"},
-					{"speaker":"B","dia_id":"D1:2","text":"another message for testing purposes"}
-				]`),
-			},
-		},
-	}
-
-	// First ingestion
-	result1, err := IngestSeahorse(ctx, samples, dbPath)
-	if err != nil {
-		t.Fatalf("first ingest failed: %v", err)
-	}
-	convCount1 := len(result1.ConvMap)
-	result1.Engine.Close()
-
-	// Second ingestion on same DB — should reuse existing data
-	result2, err := IngestSeahorse(ctx, samples, dbPath)
-	if err != nil {
-		t.Fatalf("second ingest failed: %v", err)
-	}
-	defer result2.Engine.Close()
-
-	// ConvMap should have same number of entries (no duplicates)
-	if len(result2.ConvMap) != convCount1 {
-		t.Errorf("second ingest convMap has %d entries, want %d (same as first)",
-			len(result2.ConvMap), convCount1)
-	}
-
-	// Verify conversation IDs are the same (reused, not new ones)
-	for id, cid1 := range result1.ConvMap {
-		cid2, ok := result2.ConvMap[id]
-		if !ok {
-			t.Errorf("sample %s missing from second ConvMap", id)
-			continue
-		}
-		if cid2 != cid1 {
-			t.Errorf("sample %s: second ingest got convID %d, want %d (reused)", id, cid2, cid1)
-		}
-	}
-
-	// Verify no duplicate messages by counting
-	store := result2.Engine.GetRetrieval().Store()
-	for _, convID := range result2.ConvMap {
-		msgs, err := store.SearchMessages(ctx, seahorse.SearchInput{
-			Pattern:        "test",
-			ConversationID: convID,
-			Limit:          100,
-		})
-		if err != nil {
-			t.Fatalf("search failed: %v", err)
-		}
-		// Should find exactly 1 message containing "test" (the first turn)
-		if len(msgs) > 2 {
-			t.Errorf("found %d messages for 'test' in conv %d, expected ≤2 (no duplicates)", len(msgs), convID)
-		}
-	}
-}

cmd/membench/legacy_store.go

@@ -1,34 +0,0 @@
-package main
-
-import (
-	"github.com/sipeed/picoclaw/pkg/providers"
-	"github.com/sipeed/picoclaw/pkg/session"
-)
-
-// LegacyStore wraps session.SessionManager for legacy baseline.
-type LegacyStore struct {
-	sm *session.SessionManager
-}
-
-// NewLegacyStore creates a new in-memory session manager.
-func NewLegacyStore() *LegacyStore {
-	return &LegacyStore{
-		sm: session.NewSessionManager(""),
-	}
-}
-
-// IngestSample loads all turns from a LOCOMO sample into the legacy session store.
-func (ls *LegacyStore) IngestSample(sample *LocomoSample) {
-	sessionKey := "locomo-" + sample.SampleID
-	turns := GetTurns(sample)
-	for _, turn := range turns {
-		content := turn.Speaker + ": " + turn.Text
-		ls.sm.AddMessage(sessionKey, "user", content)
-	}
-}
-
-// GetHistory returns all messages for a sample's session.
-func (ls *LegacyStore) GetHistory(sampleID string) []providers.Message {
-	sessionKey := "locomo-" + sampleID
-	return ls.sm.GetHistory(sessionKey)
-}

cmd/membench/llm_client.go

@@ -1,198 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"strings"
-	"time"
-)
-
-// LLMClient wraps an OpenAI-compatible chat completion endpoint.
-type LLMClient struct {
-	BaseURL    string
-	Model      string
-	APIKey     string
-	NoThinking bool // send chat_template_kwargs to disable thinking (llama.cpp specific)
-	MaxRetries int  // max retry attempts for transient errors (0 = no retry)
-	Client     *http.Client
-}
-
-// LLMClientOptions configures the LLM client.
-type LLMClientOptions struct {
-	BaseURL    string
-	Model      string
-	APIKey     string
-	Timeout    time.Duration
-	NoThinking bool
-	MaxRetries int // max retry attempts (default 3)
-}
-
-// NewLLMClient creates a client for an OpenAI-compatible chat completion API.
-func NewLLMClient(opts LLMClientOptions) *LLMClient {
-	if opts.Timeout == 0 {
-		opts.Timeout = 120 * time.Second
-	}
-	maxRetries := opts.MaxRetries
-	if maxRetries < 0 {
-		maxRetries = 3
-	}
-	return &LLMClient{
-		BaseURL:    strings.TrimRight(opts.BaseURL, "/"),
-		Model:      opts.Model,
-		APIKey:     opts.APIKey,
-		NoThinking: opts.NoThinking,
-		MaxRetries: maxRetries,
-		Client: &http.Client{
-			Timeout: opts.Timeout,
-		},
-	}
-}
-
-type chatRequest struct {
-	Model              string         `json:"model"`
-	Messages           []chatMessage  `json:"messages"`
-	Temperature        float64        `json:"temperature"`
-	MaxTokens          int            `json:"max_tokens"`
-	ChatTemplateKwargs map[string]any `json:"chat_template_kwargs,omitempty"` // llama.cpp
-	Think              *bool          `json:"think,omitempty"`                // Ollama
-	Thinking           map[string]any `json:"thinking,omitempty"`             // GLM (智谱)
-}
-
-type chatMessage struct {
-	Role    string `json:"role"`
-	Content string `json:"content"`
-}
-
-type chatResponse struct {
-	Choices []struct {
-		Message struct {
-			Content          string `json:"content"`
-			ReasoningContent string `json:"reasoning_content,omitempty"`
-		} `json:"message"`
-	} `json:"choices"`
-}
-
-// Complete sends a chat completion request and returns the assistant's reply.
-func (c *LLMClient) Complete(ctx context.Context, systemPrompt, userPrompt string) (string, error) {
-	sysContent := systemPrompt
-	if c.NoThinking && sysContent != "" {
-		// Prepend /no_think tag — works with Ollama /v1 endpoint and
-		// Qwen chat templates where the JSON think field is ignored.
-		sysContent = "/no_think\n" + sysContent
-	}
-	messages := []chatMessage{}
-	if sysContent != "" {
-		messages = append(messages, chatMessage{Role: "system", Content: sysContent})
-	}
-	messages = append(messages, chatMessage{Role: "user", Content: userPrompt})
-
-	body := chatRequest{
-		Model:       c.Model,
-		Messages:    messages,
-		Temperature: 0.1,
-		MaxTokens:   512,
-	}
-	if c.NoThinking {
-		// llama.cpp: chat_template_kwargs
-		body.ChatTemplateKwargs = map[string]any{
-			"enable_thinking": false,
-		}
-		// Ollama (0.9+): think field
-		thinkFalse := false
-		body.Think = &thinkFalse
-		// GLM (智谱): thinking field
-		body.Thinking = map[string]any{
-			"type": "disabled",
-		}
-	}
-
-	jsonBody, err := json.Marshal(body)
-	if err != nil {
-		return "", fmt.Errorf("marshal request: %w", err)
-	}
-
-	endpoint := strings.TrimRight(c.BaseURL, "/") + "/chat/completions"
-	req, err := http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewReader(jsonBody))
-	if err != nil {
-		return "", fmt.Errorf("create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	if c.APIKey != "" {
-		req.Header.Set("Authorization", "Bearer "+c.APIKey)
-	}
-
-	var respBody []byte
-	var lastErr error
-	for attempt := 0; attempt <= c.MaxRetries; attempt++ {
-		if attempt > 0 {
-			backoff := time.Duration(1<<(attempt-1)) * time.Second // 1s, 2s, 4s, ...
-			log.Printf("LLM retry %d/%d after %v: %v", attempt, c.MaxRetries, backoff, lastErr)
-			select {
-			case <-ctx.Done():
-				return "", ctx.Err()
-			case <-time.After(backoff):
-			}
-			// Rebuild request (body reader is consumed)
-			req, err = http.NewRequestWithContext(ctx, "POST", endpoint, bytes.NewReader(jsonBody))
-			if err != nil {
-				return "", fmt.Errorf("create request: %w", err)
-			}
-			req.Header.Set("Content-Type", "application/json")
-			if c.APIKey != "" {
-				req.Header.Set("Authorization", "Bearer "+c.APIKey)
-			}
-		}
-
-		var resp *http.Response
-		resp, lastErr = c.Client.Do(req)
-		if lastErr != nil {
-			continue // network/timeout error → retry
-		}
-
-		respBody, lastErr = io.ReadAll(resp.Body)
-		resp.Body.Close()
-		if lastErr != nil {
-			continue
-		}
-
-		if resp.StatusCode == 429 || resp.StatusCode >= 500 {
-			lastErr = fmt.Errorf("API error %d: %s", resp.StatusCode, string(respBody))
-			continue // rate limit or server error → retry
-		}
-		if resp.StatusCode != 200 {
-			return "", fmt.Errorf("API error %d: %s", resp.StatusCode, string(respBody))
-		}
-
-		lastErr = nil
-		break
-	}
-	if lastErr != nil {
-		return "", fmt.Errorf("after %d retries: %w", c.MaxRetries, lastErr)
-	}
-
-	var chatResp chatResponse
-	if err := json.Unmarshal(respBody, &chatResp); err != nil {
-		return "", fmt.Errorf("parse response: %w", err)
-	}
-	if len(chatResp.Choices) == 0 {
-		return "", fmt.Errorf("no choices in response")
-	}
-	content := strings.TrimSpace(chatResp.Choices[0].Message.Content)
-	// Strip any residual <think>...</think> blocks
-	if idx := strings.Index(content, "</think>"); idx >= 0 {
-		content = strings.TrimSpace(content[idx+len("</think>"):])
-	}
-	// Fallback: GLM/DeepSeek put thinking output in reasoning_content when thinking is enabled
-	if content == "" && chatResp.Choices[0].Message.ReasoningContent != "" {
-		content = strings.TrimSpace(chatResp.Choices[0].Message.ReasoningContent)
-	}
-	if content == "" {
-		return "", fmt.Errorf("empty LLM response")
-	}
-	return content, nil
-}

cmd/membench/locomo.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-)
-
-// LocomoSample represents one conversation sample from the LOCOMO dataset.
-type LocomoSample struct {
-	SampleID     string                     `json:"sample_id"`
-	Conversation map[string]json.RawMessage `json:"conversation"`
-	QA           []LocomoQA                 `json:"qa"`
-}
-
-// LocomoTurn represents a single turn in a conversation.
-type LocomoTurn struct {
-	Speaker string `json:"speaker"`
-	DiaID   string `json:"dia_id"`
-	Text    string `json:"text"`
-}
-
-// LocomoQA represents a question-answer pair with evidence.
-type LocomoQA struct {
-	Question          string          `json:"question"`
-	Answer            json.RawMessage `json:"answer"`             // can be string or int (category 1-4)
-	AdversarialAnswer string          `json:"adversarial_answer"` // category 5 only
-	Evidence          []string        `json:"evidence"`
-	Category          int             `json:"category"` // 1=single-hop, 2=multi-hop, 3=open-ended, 5=adversarial
-}
-
-// AnswerString returns the answer as a string, handling both string and int types.
-func (qa *LocomoQA) AnswerString() string {
-	// Prefer answer field (category 1-4)
-	if len(qa.Answer) > 0 {
-		var s string
-		if err := json.Unmarshal(qa.Answer, &s); err == nil {
-			return s
-		}
-		var n json.Number
-		if err := json.Unmarshal(qa.Answer, &n); err == nil {
-			return n.String()
-		}
-		return strings.Trim(string(qa.Answer), `"`)
-	}
-	// Fallback to adversarial_answer (category 5)
-	return qa.AdversarialAnswer
-}
-
-// LoadDataset reads all JSON files from dataDir and returns parsed samples.
-func LoadDataset(dataDir string) ([]LocomoSample, error) {
-	entries, err := os.ReadDir(dataDir)
-	if err != nil {
-		return nil, fmt.Errorf("read data dir %s: %w", dataDir, err)
-	}
-
-	var samples []LocomoSample
-	for _, entry := range entries {
-		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".json") {
-			path := filepath.Join(dataDir, entry.Name())
-			data, err := os.ReadFile(path)
-			if err != nil {
-				return nil, fmt.Errorf("read file %s: %w", path, err)
-			}
-			var batch []LocomoSample
-			if err := json.Unmarshal(data, &batch); err != nil {
-				return nil, fmt.Errorf("parse file %s: %w", path, err)
-			}
-			samples = append(samples, batch...)
-		}
-	}
-	return samples, nil
-}
-
-// GetSessionNames returns sorted session keys (session_1, session_2, ...) from conversation.
-func GetSessionNames(conv map[string]json.RawMessage) []string {
-	var names []string
-	for k := range conv {
-		if strings.HasPrefix(k, "session_") && !strings.Contains(k, "_date_time") {
-			names = append(names, k)
-		}
-	}
-	sort.Slice(names, func(i, j int) bool {
-		ni := sessionNum(names[i])
-		nj := sessionNum(names[j])
-		return ni < nj
-	})
-	return names
-}
-
-func sessionNum(key string) int {
-	// "session_1" → 1, "session_10" → 10
-	parts := strings.SplitN(key, "_", 2)
-	if len(parts) < 2 {
-		return 0
-	}
-	n, _ := strconv.Atoi(parts[1])
-	return n
-}
-
-// GetTurns flattens all sessions' turns in chronological order.
-func GetTurns(sample *LocomoSample) []LocomoTurn {
-	names := GetSessionNames(sample.Conversation)
-	var all []LocomoTurn
-	for _, name := range names {
-		raw, ok := sample.Conversation[name]
-		if !ok {
-			continue
-		}
-		var turns []LocomoTurn
-		if err := json.Unmarshal(raw, &turns); err != nil {
-			log.Printf("WARNING: unmarshal failed for session %q in sample %s: %v", name, sample.SampleID, err)
-			continue
-		}
-		all = append(all, turns...)
-	}
-	return all
-}
-
-// GetTurnByDiaID finds a specific turn by dia_id (e.g. "D1:3").
-func GetTurnByDiaID(sample *LocomoSample, diaID string) *LocomoTurn {
-	turns := GetTurns(sample)
-	for i := range turns {
-		if turns[i].DiaID == diaID {
-			return &turns[i]
-		}
-	}
-	return nil
-}
-
-// GetSpeakers returns the two speaker names from conversation metadata.
-func GetSpeakers(conv map[string]json.RawMessage) (string, string) {
-	var a, b string
-	json.Unmarshal(conv["speaker_a"], &a)
-	json.Unmarshal(conv["speaker_b"], &b)
-	return a, b
-}

cmd/membench/locomo_test.go

@@ -1,67 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func TestAnswerString(t *testing.T) {
-	tests := []struct {
-		name string
-		json string
-		want string
-	}{
-		{
-			"string answer",
-			`{"question":"Q","answer":"Paris","evidence":[],"category":1}`,
-			"Paris",
-		},
-		{
-			"int answer",
-			`{"question":"Q","answer":42,"evidence":[],"category":1}`,
-			"42",
-		},
-		{
-			"adversarial answer (category 5)",
-			`{"question":"Q","evidence":[],"category":5,"adversarial_answer":"self-care is important"}`,
-			"self-care is important",
-		},
-		{
-			"both answer and adversarial_answer present",
-			`{"question":"Q","answer":"normal","evidence":[],"category":5,"adversarial_answer":"adversarial"}`,
-			"normal",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			var qa LocomoQA
-			if err := json.Unmarshal([]byte(tt.json), &qa); err != nil {
-				t.Fatalf("unmarshal: %v", err)
-			}
-			got := qa.AnswerString()
-			if got != tt.want {
-				t.Errorf("AnswerString() = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestGetSessionNames(t *testing.T) {
-	conv := map[string]json.RawMessage{
-		"session_2":           {},
-		"session_1":           {},
-		"session_10":          {},
-		"session_1_date_time": {},
-		"speaker_a":           {},
-	}
-	names := GetSessionNames(conv)
-	want := []string{"session_1", "session_2", "session_10"}
-	if len(names) != len(want) {
-		t.Fatalf("got %v, want %v", names, want)
-	}
-	for i, n := range names {
-		if n != want[i] {
-			t.Errorf("names[%d] = %q, want %q", i, n, want[i])
-		}
-	}
-}

cmd/membench/main.go

@@ -1,361 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/pkg/logger"
-)
-
-var (
-	flagData         string
-	flagOut          string
-	flagMode         string
-	flagBudget       int
-	flagEvalMode     string
-	flagAPIBase      string
-	flagAPIKey       string
-	flagModel        string
-	flagNoThinking   bool
-	flagLimit        int
-	flagTimeout      int
-	flagRetries      int
-	flagJudgeModel   string
-	flagJudgeAPIBase string
-	flagJudgeAPIKey  string
-	flagConcurrency  int
-)
-
-func main() {
-	// Suppress seahorse INFO logs during benchmark
-	logger.SetLevel(logger.WARN)
-
-	rootCmd := &cobra.Command{
-		Use:   "membench",
-		Short: "Memory benchmark tool for picoclaw",
-	}
-
-	ingestCmd := &cobra.Command{
-		Use:   "ingest",
-		Short: "Load LOCOMO data into storage backends",
-		RunE:  runIngest,
-	}
-	ingestCmd.Flags().StringVar(&flagData, "data", "", "LOCOMO dataset directory (required)")
-	ingestCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory")
-	ingestCmd.Flags().StringVar(&flagMode, "mode", "all", "modes to ingest: legacy, seahorse, or all")
-
-	evalCmd := &cobra.Command{
-		Use:   "eval",
-		Short: "Run QA evaluation against ingested data",
-		RunE:  runEval,
-	}
-	evalCmd.Flags().StringVar(&flagData, "data", "", "LOCOMO dataset directory (required)")
-	evalCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory")
-	evalCmd.Flags().StringVar(&flagMode, "mode", "all", "modes to evaluate: legacy, seahorse, or all")
-	evalCmd.Flags().IntVar(&flagBudget, "budget", 4000, "token budget for retrieval")
-	evalCmd.Flags().
-		StringVar(&flagEvalMode, "eval-mode", "token", "evaluation mode: token (direct match) or llm (LLM-as-Judge)")
-	evalCmd.Flags().
-		StringVar(&flagAPIBase, "api-base", "", "API base URL with version path, e.g. http://host/v1 (default: http://127.0.0.1:8080/v1, env: MEMBENCH_API_BASE)")
-	evalCmd.Flags().StringVar(&flagAPIKey, "api-key", "", "API key for the LLM endpoint (env: MEMBENCH_API_KEY)")
-	evalCmd.Flags().StringVar(&flagModel, "model", "", "model name for LLM eval (env: MEMBENCH_MODEL)")
-	evalCmd.Flags().
-		BoolVar(&flagNoThinking, "no-thinking", false, "disable thinking mode via chat_template_kwargs (llama.cpp + Qwen)")
-	evalCmd.Flags().IntVar(&flagLimit, "limit", 0, "max QA questions per sample (0 = all)")
-	evalCmd.Flags().IntVar(&flagTimeout, "timeout", 120, "HTTP timeout in seconds for LLM requests")
-	evalCmd.Flags().IntVar(&flagRetries, "retries", 3, "max retry attempts for transient LLM errors (timeout/5xx/429)")
-	evalCmd.Flags().StringVar(&flagJudgeModel, "judge-model", "", "model for judge scoring (defaults to --model)")
-	evalCmd.Flags().
-		StringVar(&flagJudgeAPIBase, "judge-api-base", "", "API base URL for judge model (defaults to --api-base)")
-	evalCmd.Flags().StringVar(&flagJudgeAPIKey, "judge-api-key", "", "API key for judge model (defaults to --api-key)")
-	evalCmd.Flags().IntVar(&flagConcurrency, "concurrency", 1, "number of concurrent QA evaluations")
-
-	reportCmd := &cobra.Command{
-		Use:   "report",
-		Short: "Output comparison results from evaluation",
-		RunE:  runReport,
-	}
-	reportCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory")
-
-	runCmd := &cobra.Command{
-		Use:   "run",
-		Short: "Convenience: eval + report (ingestion is done inline)",
-		RunE:  runAll,
-	}
-	runCmd.Flags().StringVar(&flagData, "data", "", "LOCOMO dataset directory (required)")
-	runCmd.Flags().StringVar(&flagOut, "out", "./bench-out", "output working directory")
-	runCmd.Flags().StringVar(&flagMode, "mode", "all", "modes to run: legacy, seahorse, or all")
-	runCmd.Flags().IntVar(&flagBudget, "budget", 4000, "token budget for retrieval")
-	runCmd.Flags().
-		StringVar(&flagEvalMode, "eval-mode", "token", "evaluation mode: token (direct match) or llm (LLM-as-Judge)")
-	runCmd.Flags().
-		StringVar(&flagAPIBase, "api-base", "", "API base URL with version path, e.g. http://host/v1 (default: http://127.0.0.1:8080/v1, env: MEMBENCH_API_BASE)")
-	runCmd.Flags().StringVar(&flagAPIKey, "api-key", "", "API key for the LLM endpoint (env: MEMBENCH_API_KEY)")
-	runCmd.Flags().StringVar(&flagModel, "model", "", "model name for LLM eval (env: MEMBENCH_MODEL)")
-	runCmd.Flags().
-		BoolVar(&flagNoThinking, "no-thinking", false, "disable thinking mode via chat_template_kwargs (llama.cpp + Qwen)")
-	runCmd.Flags().IntVar(&flagLimit, "limit", 0, "max QA questions per sample (0 = all)")
-	runCmd.Flags().IntVar(&flagTimeout, "timeout", 120, "HTTP timeout in seconds for LLM requests")
-	runCmd.Flags().IntVar(&flagRetries, "retries", 3, "max retry attempts for transient LLM errors (timeout/5xx/429)")
-	runCmd.Flags().StringVar(&flagJudgeModel, "judge-model", "", "model for judge scoring (defaults to --model)")
-	runCmd.Flags().
-		StringVar(&flagJudgeAPIBase, "judge-api-base", "", "API base URL for judge model (defaults to --api-base)")
-	runCmd.Flags().StringVar(&flagJudgeAPIKey, "judge-api-key", "", "API key for judge model (defaults to --api-key)")
-	runCmd.Flags().IntVar(&flagConcurrency, "concurrency", 1, "number of concurrent QA evaluations")
-
-	rootCmd.AddCommand(ingestCmd, evalCmd, reportCmd, runCmd)
-
-	if err := rootCmd.Execute(); err != nil {
-		os.Exit(1)
-	}
-}
-
-func modesFromFlag() []string {
-	switch strings.ToLower(flagMode) {
-	case "all":
-		return []string{"legacy", "seahorse"}
-	default:
-		return []string{strings.ToLower(flagMode)}
-	}
-}
-
-func runIngest(cmd *cobra.Command, args []string) error {
-	if flagData == "" {
-		return fmt.Errorf("--data is required")
-	}
-	modes := modesFromFlag()
-	if len(modes) == 0 {
-		return nil
-	}
-
-	ctx := context.Background()
-	samples, err := LoadDataset(flagData)
-	if err != nil {
-		return fmt.Errorf("load dataset: %w", err)
-	}
-	log.Printf("Loaded %d samples from %s", len(samples), flagData)
-
-	for _, mode := range modes {
-		switch mode {
-		case "legacy":
-			legacy := NewLegacyStore()
-			for i := range samples {
-				legacy.IngestSample(&samples[i])
-			}
-			log.Printf("legacy: ingested %d samples", len(samples))
-		case "seahorse":
-			dbPath := filepath.Join(flagOut, "seahorse.db")
-			if err := os.MkdirAll(flagOut, 0o755); err != nil {
-				return fmt.Errorf("create out dir: %w", err)
-			}
-			_, err := IngestSeahorse(ctx, samples, dbPath)
-			if err != nil {
-				return fmt.Errorf("ingest seahorse: %w", err)
-			}
-		}
-	}
-	return nil
-}
-
-func runEval(cmd *cobra.Command, args []string) error {
-	if flagData == "" {
-		return fmt.Errorf("--data is required")
-	}
-	modes := modesFromFlag()
-	if len(modes) == 0 {
-		return nil
-	}
-
-	ctx := context.Background()
-	samples, err := LoadDataset(flagData)
-	if err != nil {
-		return fmt.Errorf("load dataset: %w", err)
-	}
-	log.Printf("Loaded %d samples", len(samples))
-
-	if flagLimit > 0 {
-		for i := range samples {
-			if len(samples[i].QA) > flagLimit {
-				samples[i].QA = samples[i].QA[:flagLimit]
-			}
-		}
-		log.Printf("Limited to %d QA per sample", flagLimit)
-	}
-
-	evalMode := strings.ToLower(strings.TrimSpace(flagEvalMode))
-	var useLLM bool
-	switch evalMode {
-	case "token":
-		useLLM = false
-	case "llm":
-		useLLM = true
-	default:
-		return fmt.Errorf("invalid --eval-mode %q: must be token or llm", flagEvalMode)
-	}
-	var answerClient, judgeClient *LLMClient
-	if useLLM {
-		opts, err := buildLLMOptions()
-		if err != nil {
-			return err
-		}
-		answerClient = NewLLMClient(opts)
-		judgeClient = answerClient // default: same client
-		if flagJudgeModel != "" {
-			jOpts := opts // copy base settings
-			jOpts.Model = flagJudgeModel
-			if flagJudgeAPIBase != "" {
-				jOpts.BaseURL = flagJudgeAPIBase
-			}
-			if flagJudgeAPIKey != "" {
-				jOpts.APIKey = flagJudgeAPIKey
-			}
-			judgeClient = NewLLMClient(jOpts)
-			log.Printf("Judge model: model=%s base=%s no-thinking=%v", jOpts.Model, jOpts.BaseURL, jOpts.NoThinking)
-		}
-		log.Printf("LLM eval mode: model=%s base=%s no-thinking=%v concurrency=%d",
-			opts.Model, opts.BaseURL, opts.NoThinking, flagConcurrency)
-	}
-
-	var tokenResults, llmResults []EvalResult
-
-	for _, mode := range modes {
-		switch mode {
-		case "legacy":
-			legacy := NewLegacyStore()
-			for i := range samples {
-				legacy.IngestSample(&samples[i])
-			}
-			if useLLM {
-				results := EvalLegacyLLM(ctx, samples, legacy, flagBudget, answerClient, judgeClient, flagConcurrency)
-				llmResults = append(llmResults, results...)
-				log.Printf("legacy-llm: evaluated %d samples", len(results))
-			} else {
-				results := EvalLegacy(ctx, samples, legacy, flagBudget)
-				tokenResults = append(tokenResults, results...)
-				log.Printf("legacy: evaluated %d samples", len(results))
-			}
-		case "seahorse":
-			dbPath := filepath.Join(flagOut, "seahorse.db")
-			ir, err := IngestSeahorse(ctx, samples, dbPath)
-			if err != nil {
-				return fmt.Errorf("ingest seahorse: %w", err)
-			}
-			if useLLM {
-				results := EvalSeahorseLLM(ctx, samples, ir, flagBudget, answerClient, judgeClient, flagConcurrency)
-				llmResults = append(llmResults, results...)
-				log.Printf("seahorse-llm: evaluated %d samples", len(results))
-			} else {
-				results := EvalSeahorse(ctx, samples, ir, flagBudget)
-				tokenResults = append(tokenResults, results...)
-				log.Printf("seahorse: evaluated %d samples", len(results))
-			}
-		}
-	}
-
-	allResults := append(tokenResults, llmResults...)
-	if err := SaveResults(allResults, flagOut); err != nil {
-		return fmt.Errorf("save results: %w", err)
-	}
-	if err := SaveAggregated(allResults, flagOut); err != nil {
-		return fmt.Errorf("save aggregated: %w", err)
-	}
-
-	PrintComparison(tokenResults, llmResults)
-	return nil
-}
-
-func runReport(cmd *cobra.Command, args []string) error {
-	entries, err := os.ReadDir(flagOut)
-	if err != nil {
-		return fmt.Errorf("read out dir: %w", err)
-	}
-
-	var allResults []EvalResult
-	for _, entry := range entries {
-		if !entry.IsDir() && strings.HasPrefix(entry.Name(), "eval_") && strings.HasSuffix(entry.Name(), ".json") {
-			path := filepath.Join(flagOut, entry.Name())
-			var r EvalResult
-			data, err := os.ReadFile(path)
-			if err != nil {
-				log.Printf("WARN: read %s: %v", path, err)
-				continue
-			}
-			if err := json.Unmarshal(data, &r); err != nil {
-				log.Printf("WARN: parse %s: %v", path, err)
-				continue
-			}
-			allResults = append(allResults, r)
-		}
-	}
-
-	if len(allResults) == 0 {
-		return fmt.Errorf("no eval results found in %s", flagOut)
-	}
-
-	var tokenResults, llmResults []EvalResult
-	for _, r := range allResults {
-		if strings.HasSuffix(r.Mode, "-llm") {
-			llmResults = append(llmResults, r)
-		} else {
-			tokenResults = append(tokenResults, r)
-		}
-	}
-	PrintComparison(tokenResults, llmResults)
-	return nil
-}
-
-func runAll(cmd *cobra.Command, args []string) error {
-	return runEval(cmd, args)
-}
-
-// envOrFlag returns the flag value if non-empty, otherwise falls back to the
-// environment variable.
-func envOrFlag(flag, envKey string) string {
-	if flag != "" {
-		return flag
-	}
-	return os.Getenv(envKey)
-}
-
-// buildLLMOptions resolves LLM client configuration from flags and environment
-// variables. Flag values take precedence over environment variables.
-//
-// Environment variables:
-//
-//	MEMBENCH_API_BASE  – OpenAI-compatible base URL  (default http://127.0.0.1:8080/v1)
-//	MEMBENCH_API_KEY   – Bearer token for the endpoint
-//	MEMBENCH_MODEL     – Model name to send in the request
-func buildLLMOptions() (LLMClientOptions, error) {
-	base := envOrFlag(flagAPIBase, "MEMBENCH_API_BASE")
-	if base == "" {
-		base = "http://127.0.0.1:8080/v1"
-	}
-	model := envOrFlag(flagModel, "MEMBENCH_MODEL")
-	if model == "" {
-		return LLMClientOptions{}, fmt.Errorf(
-			"--model or MEMBENCH_MODEL is required for LLM eval mode",
-		)
-	}
-	apiKey := envOrFlag(flagAPIKey, "MEMBENCH_API_KEY")
-
-	if flagTimeout <= 0 {
-		return LLMClientOptions{}, fmt.Errorf("--timeout must be > 0, got %d", flagTimeout)
-	}
-
-	return LLMClientOptions{
-		BaseURL:    base,
-		Model:      model,
-		APIKey:     apiKey,
-		NoThinking: flagNoThinking,
-		Timeout:    time.Duration(flagTimeout) * time.Second,
-		MaxRetries: flagRetries,
-	}, nil
-}

cmd/membench/metrics.go

@@ -1,227 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-// diaIDRe matches valid dia_id patterns like "D1:3", "D30:5".
-var diaIDRe = regexp.MustCompile(`^D(\d+):(\d+)$`)
-
-// SplitEvidenceIDs splits an evidence string that may contain multiple
-// semicolon-separated or space-separated dia_ids. Only returns valid IDs.
-// Example: "D8:6; D9:17" → ["D8:6", "D9:17"]
-// Example: "D9:1 D4:4 D4:6" → ["D9:1", "D4:4", "D4:6"]
-func SplitEvidenceIDs(evidence string) []string {
-	if evidence == "" {
-		return nil
-	}
-	// Split on semicolons first, then spaces
-	parts := strings.Split(evidence, ";")
-	var ids []string
-	for _, part := range parts {
-		for _, token := range strings.Fields(strings.TrimSpace(part)) {
-			token = strings.TrimSpace(token)
-			if diaIDRe.MatchString(token) {
-				ids = append(ids, NormalizeDiaID(token))
-			}
-		}
-	}
-	if len(ids) == 0 {
-		return nil
-	}
-	return ids
-}
-
-// NormalizeDiaID strips leading zeros from the number parts of a dia_id.
-// "D30:05" → "D30:5", "D10:003" → "D10:3"
-func NormalizeDiaID(id string) string {
-	m := diaIDRe.FindStringSubmatch(id)
-	if m == nil {
-		return id
-	}
-	session, _ := strconv.Atoi(m[1])
-	turn, _ := strconv.Atoi(m[2])
-	return fmt.Sprintf("D%d:%d", session, turn)
-}
-
-// stopwords is a fixed English stopword list for deterministic keyword extraction.
-var stopwords = map[string]struct{}{
-	"a": {}, "an": {}, "the": {},
-	"is": {}, "are": {}, "was": {}, "were": {},
-	"did": {}, "does": {}, "do": {},
-	"when": {}, "where": {}, "what": {}, "who": {},
-	"how": {}, "why": {},
-	"to": {}, "of": {}, "in": {}, "on": {}, "at": {},
-	"for": {}, "and": {}, "or": {}, "but": {}, "not": {},
-	"it": {}, "this": {}, "that": {}, "with": {},
-	"from": {}, "by": {}, "as": {},
-	"if": {}, "then": {}, "than": {}, "so": {},
-	"no": {}, "yes": {},
-	"all": {}, "any": {}, "each": {}, "every": {},
-	"some": {}, "such": {},
-	"about": {}, "into": {}, "over": {},
-	"after": {}, "before": {}, "between": {},
-	"through": {}, "during": {}, "until": {},
-	"would": {}, "could": {}, "should": {},
-	"may": {}, "might": {}, "can": {},
-	"will": {}, "shall": {}, "must": {},
-	"have": {}, "has": {}, "had": {},
-	"been": {}, "being": {}, "be": {},
-	"go": {}, "went": {}, "gone": {},
-	"i": {}, "you": {}, "me": {}, "my": {}, "your": {},
-	"we": {}, "they": {}, "them": {}, "our": {},
-	"its": {}, "their": {}, "he": {}, "she": {},
-	"his": {}, "her": {},
-}
-
-// ExtractKeywords removes stopwords and punctuation, returns individual keywords.
-// Deterministic: uses fixed stopword list, no LLM.
-func ExtractKeywords(question string) []string {
-	// Lowercase and split on whitespace/punctuation
-	lower := strings.ToLower(question)
-	words := strings.FieldsFunc(lower, func(r rune) bool {
-		return !unicode.IsLetter(r) && !unicode.IsDigit(r)
-	})
-
-	var keywords []string
-	for _, w := range words {
-		if w == "" || len(w) < 2 {
-			continue
-		}
-		if _, ok := stopwords[w]; ok {
-			continue
-		}
-		keywords = append(keywords, w)
-		if len(keywords) >= 6 {
-			break
-		}
-	}
-	return keywords
-}
-
-// TokenOverlapF1 computes token-level F1 between prediction and reference.
-// Both strings are lowercased and split on whitespace.
-// NOTE: This metric underestimates quality for multi-hop (cat 2) and
-// open-ended (cat 3) questions where the gold answer uses different phrasing
-// than the source text. LLM-Judge scoring is a v2 follow-up.
-func TokenOverlapF1(prediction, reference string) float64 {
-	predTokens := tokenize(prediction)
-	refTokens := tokenize(reference)
-
-	if len(predTokens) == 0 && len(refTokens) == 0 {
-		return 1.0
-	}
-	if len(predTokens) == 0 || len(refTokens) == 0 {
-		return 0.0
-	}
-
-	// Count matches
-	refCount := map[string]int{}
-	for _, t := range refTokens {
-		refCount[t]++
-	}
-
-	predCount := map[string]int{}
-	for _, t := range predTokens {
-		predCount[t]++
-	}
-
-	var matches float64
-	for token, pc := range predCount {
-		if rc, ok := refCount[token]; ok {
-			matches += float64(min(pc, rc))
-		}
-	}
-
-	precision := matches / float64(len(predTokens))
-	recall := matches / float64(len(refTokens))
-
-	if precision+recall == 0 {
-		return 0.0
-	}
-	return 2 * precision * recall / (precision + recall)
-}
-
-func tokenize(s string) []string {
-	lower := strings.ToLower(s)
-	return strings.Fields(lower)
-}
-
-// RecallHitRate computes fraction of evidence IDs found in retrieved content.
-// For each evidence dia_id, looks up the turn text and checks substring match.
-// Logs a warning for turns with text < 20 chars (higher false-positive risk).
-func RecallHitRate(evidenceIDs []string, sample *LocomoSample, retrievedContent string) float64 {
-	if len(evidenceIDs) == 0 {
-		return 1.0 // no evidence required = perfect
-	}
-
-	// Expand any multi-ID evidence entries (e.g. "D8:6; D9:17" or "D9:1 D4:4")
-	var expanded []string
-	for _, id := range evidenceIDs {
-		split := SplitEvidenceIDs(id)
-		if split != nil {
-			expanded = append(expanded, split...)
-		}
-	}
-	if len(expanded) == 0 {
-		log.Printf("WARNING: no valid dia_ids after expanding evidence %v", evidenceIDs)
-		return float64(0) / float64(len(evidenceIDs))
-	}
-
-	// Build turn index once (avoids re-parsing JSON per ID)
-	turns := GetTurns(sample)
-	turnMap := make(map[string]*LocomoTurn, len(turns))
-	for i := range turns {
-		turnMap[turns[i].DiaID] = &turns[i]
-	}
-
-	lowerRetrieved := strings.ToLower(retrievedContent)
-	found := 0
-	resolvable := 0
-	for _, diaID := range expanded {
-		turn, ok := turnMap[diaID]
-		if !ok {
-			log.Printf("WARNING: dia_id %q not found in sample %s", diaID, sample.SampleID)
-			continue
-		}
-		resolvable++
-		if len(turn.Text) < 20 {
-			log.Printf("WARNING: short turn text (%d chars) for dia_id %s: %q",
-				len(turn.Text), diaID, turn.Text)
-		}
-		if strings.Contains(lowerRetrieved, strings.ToLower(turn.Text)) {
-			found++
-		}
-	}
-	if resolvable == 0 {
-		return 0.0 // no resolvable evidence = can't evaluate
-	}
-	return float64(found) / float64(resolvable)
-}
-
-// BudgetTruncate truncates messages to fit within a token budget.
-// Returns the truncated messages and total token count.
-func BudgetTruncate(messages []string, budgetTokens int) ([]string, int) {
-	var result []string
-	total := 0
-	// Walk from the front (best first) and keep until budget exhausted.
-	for i := 0; i < len(messages); i++ {
-		tokens := len(messages[i]) / 4
-		if total+tokens > budgetTokens && len(result) > 0 {
-			break
-		}
-		result = append(result, messages[i])
-		total += tokens
-	}
-	return result, total
-}
-
-// StringListToContent joins a list of strings into a single content string.
-func StringListToContent(parts []string) string {
-	return strings.Join(parts, "\n")
-}

cmd/membench/metrics_test.go

@@ -1,239 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"math"
-	"testing"
-)
-
-func TestSplitEvidenceIDs(t *testing.T) {
-	tests := []struct {
-		input string
-		want  []string
-	}{
-		{"D1:3", []string{"D1:3"}},
-		{"D8:6; D9:17", []string{"D8:6", "D9:17"}},
-		{"D9:1 D4:4 D4:6", []string{"D9:1", "D4:4", "D4:6"}},
-		{"D22:1 D22:2 D9:10 D9:11", []string{"D22:1", "D22:2", "D9:10", "D9:11"}},
-		{"D21:18 D21:22 D11:15 D11:19", []string{"D21:18", "D21:22", "D11:15", "D11:19"}},
-		{"D30:05", []string{"D30:5"}},
-		{"D", nil},
-		{"D:", nil},
-		{"", nil},
-	}
-	for _, tt := range tests {
-		t.Run(tt.input, func(t *testing.T) {
-			got := SplitEvidenceIDs(tt.input)
-			if len(got) != len(tt.want) {
-				t.Fatalf("SplitEvidenceIDs(%q) = %v, want %v", tt.input, got, tt.want)
-			}
-			for i := range got {
-				if got[i] != tt.want[i] {
-					t.Errorf("[%d] = %q, want %q", i, got[i], tt.want[i])
-				}
-			}
-		})
-	}
-}
-
-func TestNormalizeDiaID(t *testing.T) {
-	tests := []struct {
-		input string
-		want  string
-	}{
-		{"D1:3", "D1:3"},
-		{"D30:05", "D30:5"},
-		{"D10:003", "D10:3"},
-		{"D1:0", "D1:0"},
-	}
-	for _, tt := range tests {
-		got := NormalizeDiaID(tt.input)
-		if got != tt.want {
-			t.Errorf("NormalizeDiaID(%q) = %q, want %q", tt.input, got, tt.want)
-		}
-	}
-}
-
-func TestTokenOverlapF1(t *testing.T) {
-	tests := []struct {
-		name       string
-		prediction string
-		reference  string
-		want       float64
-	}{
-		{"exact match", "hello world", "hello world", 1.0},
-		{"no overlap", "foo bar", "baz qux", 0.0},
-		{"empty both", "", "", 1.0},
-		{"empty prediction", "", "hello", 0.0},
-		{"empty reference", "hello", "", 0.0},
-		{"partial overlap", "the cat sat on the mat", "the cat on the floor", 8.0 / 11.0},
-		{"case insensitive", "Hello World", "hello world", 1.0},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := TokenOverlapF1(tt.prediction, tt.reference)
-			if math.Abs(got-tt.want) > 1e-9 {
-				t.Errorf("TokenOverlapF1(%q, %q) = %.4f, want %.4f",
-					tt.prediction, tt.reference, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestBudgetTruncate(t *testing.T) {
-	t.Run("within budget returns all", func(t *testing.T) {
-		msgs := []string{"short", "message", "here"}
-		result, total := BudgetTruncate(msgs, 1000)
-		if len(result) != 3 {
-			t.Errorf("expected 3 messages, got %d", len(result))
-		}
-		if total == 0 {
-			t.Error("expected non-zero token count")
-		}
-	})
-
-	t.Run("over budget keeps best first", func(t *testing.T) {
-		msgs := []string{
-			"best message that is quite long and takes up tokens",
-			"good message also fairly long content",
-			"worst short",
-		}
-		result, _ := BudgetTruncate(msgs, 5) // very small budget
-		if len(result) == 0 {
-			t.Fatal("expected at least one message")
-		}
-		// Best-ranked (first) should be kept
-		if result[0] != "best message that is quite long and takes up tokens" {
-			t.Errorf("expected best message kept first, got %q", result[0])
-		}
-	})
-
-	t.Run("over budget keeps best ranked first", func(t *testing.T) {
-		// Messages are sorted by bm25 rank ascending (best/most-negative first).
-		// When budget is insufficient, BudgetTruncate must keep the front
-		// (best-ranked) messages, not the tail (worst-ranked).
-		msgs := []string{
-			"best ranked message with some content here",
-			"second best message also has content",
-			"third message here too",
-			"worst ranked short",
-		}
-		// Budget only fits ~1 message (~10 tokens per message, budget=12)
-		result, _ := BudgetTruncate(msgs, 12)
-		if len(result) == 0 {
-			t.Fatal("expected at least one message")
-		}
-		if result[0] != "best ranked message with some content here" {
-			t.Errorf("expected best-ranked (first) message kept, got %q", result[0])
-		}
-		// Worst-ranked (last) must NOT appear
-		for _, m := range result {
-			if m == "worst ranked short" {
-				t.Error("worst-ranked message should have been truncated")
-			}
-		}
-	})
-
-	t.Run("preserves original order", func(t *testing.T) {
-		msgs := []string{"alpha", "beta", "gamma"}
-		result, _ := BudgetTruncate(msgs, 100)
-		for i, got := range result {
-			if got != msgs[i] {
-				t.Errorf("result[%d] = %q, want %q", i, got, msgs[i])
-			}
-		}
-	})
-
-	t.Run("empty input", func(t *testing.T) {
-		result, total := BudgetTruncate(nil, 100)
-		if len(result) != 0 {
-			t.Errorf("expected 0 messages, got %d", len(result))
-		}
-		if total != 0 {
-			t.Errorf("expected 0 tokens, got %d", total)
-		}
-	})
-}
-
-func TestRecallHitRate(t *testing.T) {
-	// Build a sample with known turns
-	sample := &LocomoSample{
-		SampleID: "test-sample",
-		Conversation: map[string]json.RawMessage{
-			"session_1": json.RawMessage(`[
-				{"speaker":"A","dia_id":"D1:1","text":"hello world this is a test message with enough length"},
-				{"speaker":"B","dia_id":"D1:2","text":"another message for testing recall computation purposes here"},
-				{"speaker":"A","dia_id":"D1:3","text":"third turn with some more content to test"}
-			]`),
-		},
-	}
-
-	t.Run("all evidence found", func(t *testing.T) {
-		retrieved := "hello world this is a test message with enough length another message for testing recall computation purposes here"
-		got := RecallHitRate([]string{"D1:1", "D1:2"}, sample, retrieved)
-		if math.Abs(got-1.0) > 1e-9 {
-			t.Errorf("RecallHitRate all found = %.4f, want 1.0", got)
-		}
-	})
-
-	t.Run("partial evidence found", func(t *testing.T) {
-		retrieved := "hello world this is a test message with enough length"
-		got := RecallHitRate([]string{"D1:1", "D1:2"}, sample, retrieved)
-		if math.Abs(got-0.5) > 1e-9 {
-			t.Errorf("RecallHitRate partial = %.4f, want 0.5", got)
-		}
-	})
-
-	t.Run("no evidence required", func(t *testing.T) {
-		got := RecallHitRate(nil, sample, "anything")
-		if got != 1.0 {
-			t.Errorf("RecallHitRate no evidence = %.4f, want 1.0", got)
-		}
-	})
-
-	t.Run("missing turn excluded from denominator", func(t *testing.T) {
-		// D1:1 is found, D99:1 does not exist in sample
-		// Should only count resolvable turns in denominator
-		retrieved := "hello world this is a test message with enough length"
-		got := RecallHitRate([]string{"D1:1", "D99:1"}, sample, retrieved)
-		if math.Abs(got-1.0) > 1e-9 {
-			t.Errorf("RecallHitRate missing turn = %.4f, want 1.0 (unresolvable excluded)", got)
-		}
-	})
-}
-
-func TestExtractKeywords(t *testing.T) {
-	tests := []struct {
-		name  string
-		input string
-		want  []string
-	}{
-		{"simple", "What is the capital of France", []string{"capital", "france"}},
-		{
-			"stops removed",
-			"Who is the president of the United States",
-			[]string{"president", "united", "states"},
-		},
-		{
-			"max 6 keywords",
-			"one two three four five six seven eight nine ten",
-			[]string{"one", "two", "three", "four", "five", "six"},
-		},
-		{"short words filtered", "I am a go to the store", []string{"am", "store"}},
-		{"empty", "", nil},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := ExtractKeywords(tt.input)
-			if len(got) != len(tt.want) {
-				t.Fatalf("ExtractKeywords(%q) = %v (len %d), want %v (len %d)",
-					tt.input, got, len(got), tt.want, len(tt.want))
-			}
-			for i := range got {
-				if got[i] != tt.want[i] {
-					t.Errorf("[%d] = %q, want %q", i, got[i], tt.want[i])
-				}
-			}
-		})
-	}
-}

cmd/picoclaw/dns_noresolv.go

@@ -1,64 +0,0 @@
-package main
-
-import (
-	"context"
-	"net"
-	"net/http"
-	"os"
-	"strings"
-	"sync/atomic"
-	"time"
-)
-
-func init() {
-	// 仅在 /etc/resolv.conf 不存在时才覆盖（即 Android 环境）
-	if _, err := os.Stat("/etc/resolv.conf"); err == nil {
-		return
-	}
-
-	// 从环境变量获取 DNS server 列表，多个用 ; 隔开
-	// 例如: PICOCLAW_DNS_SERVER="8.8.8.8:53;1.1.1.1:53;223.5.5.5:53"
-	dnsEnv := os.Getenv("PICOCLAW_DNS_SERVER")
-	if dnsEnv == "" {
-		dnsEnv = "8.8.8.8:53;1.1.1.1:53"
-	}
-
-	var dnsServers []string
-	for _, s := range strings.Split(dnsEnv, ";") {
-		s = strings.TrimSpace(s)
-		if s != "" {
-			// 如果没有带端口号，自动补上 :53
-			if _, _, err := net.SplitHostPort(s); err != nil {
-				s = s + ":53"
-			}
-			dnsServers = append(dnsServers, s)
-		}
-	}
-
-	// 轮询索引，在多个 DNS 服务器之间轮转
-	var idx uint64
-
-	customResolver := &net.Resolver{
-		PreferGo: true,
-		Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
-			d := net.Dialer{Timeout: 5 * time.Second}
-			// Round-robin: 依次尝试不同的 DNS 服务器
-			server := dnsServers[atomic.AddUint64(&idx, 1)%uint64(len(dnsServers))]
-			return d.DialContext(ctx, "udp", server)
-		},
-	}
-
-	// 覆盖全局 DefaultResolver
-	net.DefaultResolver = customResolver
-
-	// 覆盖 http.DefaultTransport 使用自定义 DNS 解析的 DialContext
-	dialer := &net.Dialer{
-		Timeout:   30 * time.Second,
-		KeepAlive: 30 * time.Second,
-		Resolver:  customResolver,
-	}
-
-	if tr, ok := http.DefaultTransport.(*http.Transport); ok {
-		tr.DialContext = dialer.DialContext
-	}
-}

cmd/picoclaw/internal/agent/helpers.go

@@ -9,7 +9,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/ergochat/readline"
+	"github.com/chzyer/readline"
 
 	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
 	"github.com/sipeed/picoclaw/pkg/agent"
@@ -23,18 +23,16 @@ func agentCmd(message, sessionKey, model string, debug bool) error {
 		sessionKey = "cli:default"
 	}
 
-	cfg, err := internal.LoadConfig()
-	if err != nil {
-		return fmt.Errorf("error loading config: %w", err)
-	}
-
-	logger.ConfigureFromEnv()
-
 	if debug {
 		logger.SetLevel(logger.DEBUG)
 		fmt.Println("🔍 Debug mode enabled")
 	}
 
+	cfg, err := internal.LoadConfig()
+	if err != nil {
+		return fmt.Errorf("error loading config: %w", err)
+	}
+
 	if model != "" {
 		cfg.Agents.Defaults.ModelName = model
 	}
@@ -52,7 +50,6 @@ func agentCmd(message, sessionKey, model string, debug bool) error {
 	msgBus := bus.NewMessageBus()
 	defer msgBus.Close()
 	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
-	defer agentLoop.Close()
 
 	// Print agent startup info (only for interactive mode)
 	startupInfo := agentLoop.GetStartupInfo()

cmd/picoclaw/internal/auth/command.go

@@ -16,8 +16,6 @@ func NewAuthCommand() *cobra.Command {
 		newLogoutCommand(),
 		newStatusCommand(),
 		newModelsCommand(),
-		newWeixinCommand(),
-		newWeComCommand(),
 	)
 
 	return cmd

cmd/picoclaw/internal/auth/command_test.go

@@ -32,8 +32,6 @@ func TestNewAuthCommand(t *testing.T) {
 		"logout",
 		"status",
 		"models",
-		"weixin",
-		"wecom",
 	}
 
 	subcommands := cmd.Commands()

cmd/picoclaw/internal/auth/helpers.go

@@ -1,7 +1,6 @@
 package auth
 
 import (
-	"bufio"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -16,25 +15,22 @@ import (
 	"github.com/sipeed/picoclaw/pkg/providers"
 )
 
-const (
+const supportedProvidersMsg = "supported providers: openai, anthropic, google-antigravity"
-	supportedProvidersMsg = "supported providers: openai, anthropic, google-antigravity, antigravity"
-	defaultAnthropicModel = "claude-sonnet-4.6"
-)
 
-func authLoginCmd(provider string, useDeviceCode bool, useOauth bool, noBrowser bool) error {
+func authLoginCmd(provider string, useDeviceCode bool) error {
 	switch provider {
 	case "openai":
-		return authLoginOpenAI(useDeviceCode, noBrowser)
+		return authLoginOpenAI(useDeviceCode)
 	case "anthropic":
-		return authLoginAnthropic(useOauth)
+		return authLoginPasteToken(provider)
 	case "google-antigravity", "antigravity":
-		return authLoginGoogleAntigravity(noBrowser)
+		return authLoginGoogleAntigravity()
 	default:
 		return fmt.Errorf("unsupported provider: %s (%s)", provider, supportedProvidersMsg)
 	}
 }
 
-func authLoginOpenAI(useDeviceCode bool, noBrowser bool) error {
+func authLoginOpenAI(useDeviceCode bool) error {
 	cfg := auth.OpenAIOAuthConfig()
 
 	var cred *auth.AuthCredential
@@ -43,7 +39,7 @@ func authLoginOpenAI(useDeviceCode bool, noBrowser bool) error {
 	if useDeviceCode {
 		cred, err = auth.LoginDeviceCode(cfg)
 	} else {
-		cred, err = auth.LoginBrowserWithOptions(cfg, auth.LoginBrowserOptions{NoBrowser: noBrowser})
+		cred, err = auth.LoginBrowser(cfg)
 	}
 
 	if err != nil {
@@ -56,10 +52,13 @@ func authLoginOpenAI(useDeviceCode bool, noBrowser bool) error {
 
 	appCfg, err := internal.LoadConfig()
 	if err == nil {
+		// Update Providers (legacy format)
+		appCfg.Providers.OpenAI.AuthMethod = "oauth"
+
 		// Update or add openai in ModelList
 		foundOpenAI := false
 		for i := range appCfg.ModelList {
-			if isOpenAIModel(appCfg.ModelList[i]) {
+			if isOpenAIModel(appCfg.ModelList[i].Model) {
 				appCfg.ModelList[i].AuthMethod = "oauth"
 				foundOpenAI = true
 				break
@@ -68,15 +67,15 @@ func authLoginOpenAI(useDeviceCode bool, noBrowser bool) error {
 
 		// If no openai in ModelList, add it
 		if !foundOpenAI {
-			appCfg.ModelList = append(appCfg.ModelList, &config.ModelConfig{
+			appCfg.ModelList = append(appCfg.ModelList, config.ModelConfig{
-				ModelName:  "gpt-5.4",
+				ModelName:  "gpt-5.2",
-				Model:      "openai/gpt-5.4",
+				Model:      "openai/gpt-5.2",
 				AuthMethod: "oauth",
 			})
 		}
 
 		// Update default model to use OpenAI
-		appCfg.Agents.Defaults.ModelName = "gpt-5.4"
+		appCfg.Agents.Defaults.ModelName = "gpt-5.2"
 
 		if err = config.SaveConfig(internal.GetConfigPath(), appCfg); err != nil {
 			return fmt.Errorf("could not update config: %w", err)
@@ -87,15 +86,15 @@ func authLoginOpenAI(useDeviceCode bool, noBrowser bool) error {
 	if cred.AccountID != "" {
 		fmt.Printf("Account: %s\n", cred.AccountID)
 	}
-	fmt.Println("Default model set to: gpt-5.4")
+	fmt.Println("Default model set to: gpt-5.2")
 
 	return nil
 }
 
-func authLoginGoogleAntigravity(noBrowser bool) error {
+func authLoginGoogleAntigravity() error {
 	cfg := auth.GoogleAntigravityOAuthConfig()
 
-	cred, err := auth.LoginBrowserWithOptions(cfg, auth.LoginBrowserOptions{NoBrowser: noBrowser})
+	cred, err := auth.LoginBrowser(cfg)
 	if err != nil {
 		return fmt.Errorf("login failed: %w", err)
 	}
@@ -127,10 +126,13 @@ func authLoginGoogleAntigravity(noBrowser bool) error {
 
 	appCfg, err := internal.LoadConfig()
 	if err == nil {
+		// Update Providers (legacy format, for backward compatibility)
+		appCfg.Providers.Antigravity.AuthMethod = "oauth"
+
 		// Update or add antigravity in ModelList
 		foundAntigravity := false
 		for i := range appCfg.ModelList {
-			if isAntigravityModel(appCfg.ModelList[i]) {
+			if isAntigravityModel(appCfg.ModelList[i].Model) {
 				appCfg.ModelList[i].AuthMethod = "oauth"
 				foundAntigravity = true
 				break
@@ -139,7 +141,7 @@ func authLoginGoogleAntigravity(noBrowser bool) error {
 
 		// If no antigravity in ModelList, add it
 		if !foundAntigravity {
-			appCfg.ModelList = append(appCfg.ModelList, &config.ModelConfig{
+			appCfg.ModelList = append(appCfg.ModelList, config.ModelConfig{
 				ModelName:  "gemini-flash",
 				Model:      "antigravity/gemini-3-flash",
 				AuthMethod: "oauth",
@@ -161,79 +163,6 @@ func authLoginGoogleAntigravity(noBrowser bool) error {
 	return nil
 }
 
-func authLoginAnthropic(useOauth bool) error {
-	if useOauth {
-		return authLoginAnthropicSetupToken()
-	}
-
-	fmt.Println("Anthropic login method:")
-	fmt.Println("  1) Setup token (from `claude setup-token`) (Recommended)")
-	fmt.Println("  2) API key (from console.anthropic.com)")
-
-	scanner := bufio.NewScanner(os.Stdin)
-	for {
-		fmt.Print("Choose [1]: ")
-		choice := "1"
-		if scanner.Scan() {
-			text := strings.TrimSpace(scanner.Text())
-			if text != "" {
-				choice = text
-			}
-		}
-
-		switch choice {
-		case "1":
-			return authLoginAnthropicSetupToken()
-		case "2":
-			return authLoginPasteToken("anthropic")
-		default:
-			fmt.Printf("Invalid choice: %s. Please enter 1 or 2.\n", choice)
-		}
-	}
-}
-
-func authLoginAnthropicSetupToken() error {
-	cred, err := auth.LoginSetupToken(os.Stdin)
-	if err != nil {
-		return fmt.Errorf("login failed: %w", err)
-	}
-
-	if err = auth.SetCredential("anthropic", cred); err != nil {
-		return fmt.Errorf("failed to save credentials: %w", err)
-	}
-
-	appCfg, err := internal.LoadConfig()
-	if err == nil {
-		found := false
-		for i := range appCfg.ModelList {
-			if isAnthropicModel(appCfg.ModelList[i]) {
-				appCfg.ModelList[i].AuthMethod = "oauth"
-				found = true
-				break
-			}
-		}
-		if !found {
-			appCfg.ModelList = append(appCfg.ModelList, &config.ModelConfig{
-				ModelName:  defaultAnthropicModel,
-				Model:      "anthropic/" + defaultAnthropicModel,
-				AuthMethod: "oauth",
-			})
-			// Only set default model if user has no default configured yet
-			if appCfg.Agents.Defaults.GetModelName() == "" {
-				appCfg.Agents.Defaults.ModelName = defaultAnthropicModel
-			}
-		}
-
-		if err := config.SaveConfig(internal.GetConfigPath(), appCfg); err != nil {
-			return fmt.Errorf("could not update config: %w", err)
-		}
-	}
-
-	fmt.Println("Setup token saved for Anthropic!")
-
-	return nil
-}
-
 func fetchGoogleUserEmail(accessToken string) (string, error) {
 	req, err := http.NewRequest("GET", "https://www.googleapis.com/oauth2/v2/userinfo", nil)
 	if err != nil {
@@ -248,10 +177,7 @@ func fetchGoogleUserEmail(accessToken string) (string, error) {
 	}
 	defer resp.Body.Close()
 
-	body, err := io.ReadAll(resp.Body)
+	body, _ := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("reading userinfo response: %w", err)
-	}
 	if resp.StatusCode != http.StatusOK {
 		return "", fmt.Errorf("userinfo request failed: %s", string(body))
 	}
@@ -279,42 +205,45 @@ func authLoginPasteToken(provider string) error {
 	if err == nil {
 		switch provider {
 		case "anthropic":
+			appCfg.Providers.Anthropic.AuthMethod = "token"
 			// Update ModelList
 			found := false
 			for i := range appCfg.ModelList {
-				if isAnthropicModel(appCfg.ModelList[i]) {
+				if isAnthropicModel(appCfg.ModelList[i].Model) {
 					appCfg.ModelList[i].AuthMethod = "token"
 					found = true
 					break
 				}
 			}
 			if !found {
-				appCfg.ModelList = append(appCfg.ModelList, &config.ModelConfig{
+				appCfg.ModelList = append(appCfg.ModelList, config.ModelConfig{
-					ModelName:  defaultAnthropicModel,
+					ModelName:  "claude-sonnet-4.6",
-					Model:      "anthropic/" + defaultAnthropicModel,
+					Model:      "anthropic/claude-sonnet-4.6",
-					AuthMethod: "token",
-				})
-				appCfg.Agents.Defaults.ModelName = defaultAnthropicModel
-			}
-		case "openai":
-			// Update ModelList
-			found := false
-			for i := range appCfg.ModelList {
-				if isOpenAIModel(appCfg.ModelList[i]) {
-					appCfg.ModelList[i].AuthMethod = "token"
-					found = true
-					break
-				}
-			}
-			if !found {
-				appCfg.ModelList = append(appCfg.ModelList, &config.ModelConfig{
-					ModelName:  "gpt-5.4",
-					Model:      "openai/gpt-5.4",
 					AuthMethod: "token",
 				})
 			}
 			// Update default model
-			appCfg.Agents.Defaults.ModelName = "gpt-5.4"
+			appCfg.Agents.Defaults.ModelName = "claude-sonnet-4.6"
+		case "openai":
+			appCfg.Providers.OpenAI.AuthMethod = "token"
+			// Update ModelList
+			found := false
+			for i := range appCfg.ModelList {
+				if isOpenAIModel(appCfg.ModelList[i].Model) {
+					appCfg.ModelList[i].AuthMethod = "token"
+					found = true
+					break
+				}
+			}
+			if !found {
+				appCfg.ModelList = append(appCfg.ModelList, config.ModelConfig{
+					ModelName:  "gpt-5.2",
+					Model:      "openai/gpt-5.2",
+					AuthMethod: "token",
+				})
+			}
+			// Update default model
+			appCfg.Agents.Defaults.ModelName = "gpt-5.2"
 		}
 		if err := config.SaveConfig(internal.GetConfigPath(), appCfg); err != nil {
 			return fmt.Errorf("could not update config: %w", err)
@@ -342,19 +271,28 @@ func authLogoutCmd(provider string) error {
 			for i := range appCfg.ModelList {
 				switch provider {
 				case "openai":
-					if isOpenAIModel(appCfg.ModelList[i]) {
+					if isOpenAIModel(appCfg.ModelList[i].Model) {
 						appCfg.ModelList[i].AuthMethod = ""
 					}
 				case "anthropic":
-					if isAnthropicModel(appCfg.ModelList[i]) {
+					if isAnthropicModel(appCfg.ModelList[i].Model) {
 						appCfg.ModelList[i].AuthMethod = ""
 					}
 				case "google-antigravity", "antigravity":
-					if isAntigravityModel(appCfg.ModelList[i]) {
+					if isAntigravityModel(appCfg.ModelList[i].Model) {
 						appCfg.ModelList[i].AuthMethod = ""
 					}
 				}
 			}
+			// Clear AuthMethod in Providers (legacy)
+			switch provider {
+			case "openai":
+				appCfg.Providers.OpenAI.AuthMethod = ""
+			case "anthropic":
+				appCfg.Providers.Anthropic.AuthMethod = ""
+			case "google-antigravity", "antigravity":
+				appCfg.Providers.Antigravity.AuthMethod = ""
+			}
 			config.SaveConfig(internal.GetConfigPath(), appCfg)
 		}
 
@@ -373,6 +311,10 @@ func authLogoutCmd(provider string) error {
 		for i := range appCfg.ModelList {
 			appCfg.ModelList[i].AuthMethod = ""
 		}
+		// Clear all AuthMethods in Providers (legacy)
+		appCfg.Providers.OpenAI.AuthMethod = ""
+		appCfg.Providers.Anthropic.AuthMethod = ""
+		appCfg.Providers.Antigravity.AuthMethod = ""
 		config.SaveConfig(internal.GetConfigPath(), appCfg)
 	}
 
@@ -418,16 +360,6 @@ func authStatusCmd() error {
 		if !cred.ExpiresAt.IsZero() {
 			fmt.Printf("    Expires: %s\n", cred.ExpiresAt.Format("2006-01-02 15:04"))
 		}
-
-		if provider == "anthropic" && cred.AuthMethod == "oauth" {
-			usage, err := auth.FetchAnthropicUsage(cred.AccessToken)
-			if err != nil {
-				fmt.Printf("    Usage: unavailable (%v)\n", err)
-			} else {
-				fmt.Printf("    Usage (5h):  %.1f%%\n", usage.FiveHourUtilization*100)
-				fmt.Printf("    Usage (7d):  %.1f%%\n", usage.SevenDayUtilization*100)
-			}
-		}
 	}
 
 	return nil
@@ -484,20 +416,22 @@ func authModelsCmd() error {
 	return nil
 }
 
-// isAntigravityModel checks if a model config belongs to an Antigravity provider.
+// isAntigravityModel checks if a model string belongs to antigravity provider
-func isAntigravityModel(modelCfg *config.ModelConfig) bool {
+func isAntigravityModel(model string) bool {
-	protocol, _ := providers.ExtractProtocol(modelCfg)
+	return model == "antigravity" ||
-	return protocol == "antigravity" || protocol == "google-antigravity"
+		model == "google-antigravity" ||
+		strings.HasPrefix(model, "antigravity/") ||
+		strings.HasPrefix(model, "google-antigravity/")
 }
 
-// isOpenAIModel checks if a model config belongs to the OpenAI provider.
+// isOpenAIModel checks if a model string belongs to openai provider
-func isOpenAIModel(modelCfg *config.ModelConfig) bool {
+func isOpenAIModel(model string) bool {
-	protocol, _ := providers.ExtractProtocol(modelCfg)
+	return model == "openai" ||
-	return protocol == "openai"
+		strings.HasPrefix(model, "openai/")
 }
 
-// isAnthropicModel checks if a model config belongs to the Anthropic provider.
+// isAnthropicModel checks if a model string belongs to anthropic provider
-func isAnthropicModel(modelCfg *config.ModelConfig) bool {
+func isAnthropicModel(model string) bool {
-	protocol, _ := providers.ExtractProtocol(modelCfg)
+	return model == "anthropic" ||
-	return protocol == "anthropic"
+		strings.HasPrefix(model, "anthropic/")
 }

cmd/picoclaw/internal/auth/login.go

@@ -6,8 +6,6 @@ func newLoginCommand() *cobra.Command {
 	var (
 		provider      string
 		useDeviceCode bool
-		useOauth      bool
-		noBrowser     bool
 	)
 
 	cmd := &cobra.Command{
@@ -15,19 +13,12 @@ func newLoginCommand() *cobra.Command {
 		Short: "Login via OAuth or paste token",
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, _ []string) error {
-			return authLoginCmd(provider, useDeviceCode, useOauth, noBrowser)
+			return authLoginCmd(provider, useDeviceCode)
 		},
 	}
 
-	cmd.Flags().StringVarP(
+	cmd.Flags().StringVarP(&provider, "provider", "p", "", "Provider to login with (openai, anthropic)")
-		&provider, "provider", "p", "", "Provider to login with (openai, anthropic, google-antigravity, antigravity)",
-	)
 	cmd.Flags().BoolVar(&useDeviceCode, "device-code", false, "Use device code flow (for headless environments)")
-	cmd.Flags().BoolVar(&noBrowser, "no-browser", false, "Do not auto-open a browser during OAuth login")
-	cmd.Flags().BoolVar(
-		&useOauth, "setup-token", false,
-		"Use setup-token flow for Anthropic (from `claude setup-token`)",
-	)
 	_ = cmd.MarkFlagRequired("provider")
 
 	return cmd

cmd/picoclaw/internal/auth/login_test.go

@@ -18,7 +18,6 @@ func TestNewLoginSubCommand(t *testing.T) {
 	assert.True(t, cmd.HasFlags())
 
 	assert.NotNil(t, cmd.Flags().Lookup("device-code"))
-	assert.NotNil(t, cmd.Flags().Lookup("no-browser"))
 
 	providerFlag := cmd.Flags().Lookup("provider")
 	require.NotNil(t, providerFlag)

cmd/picoclaw/internal/auth/status_test.go

@@ -1,53 +1,12 @@
 package auth
 
 import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
 	"testing"
-	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	pkgauth "github.com/sipeed/picoclaw/pkg/auth"
-	"github.com/sipeed/picoclaw/pkg/config"
 )
 
-func captureAuthStdout(t *testing.T, fn func()) string {
-	t.Helper()
-
-	oldStdout := os.Stdout
-	r, w, err := os.Pipe()
-	require.NoError(t, err)
-	os.Stdout = w
-	t.Cleanup(func() {
-		os.Stdout = oldStdout
-	})
-
-	fn()
-
-	require.NoError(t, w.Close())
-	os.Stdout = oldStdout
-
-	var buf bytes.Buffer
-	_, err = io.Copy(&buf, r)
-	require.NoError(t, err)
-	require.NoError(t, r.Close())
-	return buf.String()
-}
-
-func setAuthStatusTestHome(t *testing.T) string {
-	t.Helper()
-
-	tmpDir := t.TempDir()
-	t.Setenv(config.EnvHome, filepath.Join(tmpDir, ".picoclaw"))
-	return tmpDir
-}
-
 func TestNewStatusSubcommand(t *testing.T) {
 	cmd := newStatusCommand()
 
@@ -57,47 +16,3 @@ func TestNewStatusSubcommand(t *testing.T) {
 
 	assert.False(t, cmd.HasFlags())
 }
-
-func TestAuthStatusCmdShowsCanonicalGoogleAntigravityAfterLegacyRefresh(t *testing.T) {
-	tmpDir := setAuthStatusTestHome(t)
-
-	legacyExpiry := time.Date(2026, 4, 16, 10, 0, 0, 0, time.UTC)
-	legacyStore := map[string]any{
-		"credentials": map[string]any{
-			"antigravity": map[string]any{
-				"access_token": "legacy-token",
-				"expires_at":   legacyExpiry.Format(time.RFC3339),
-				"provider":     "antigravity",
-				"auth_method":  "oauth",
-				"project_id":   "legacy-project",
-			},
-		},
-	}
-	data, err := json.Marshal(legacyStore)
-	require.NoError(t, err)
-
-	authPath := filepath.Join(tmpDir, ".picoclaw", "auth.json")
-	require.NoError(t, os.MkdirAll(filepath.Dir(authPath), 0o755))
-	require.NoError(t, os.WriteFile(authPath, data, 0o600))
-
-	refreshedExpiry := time.Date(2026, 4, 16, 12, 30, 0, 0, time.UTC)
-	err = pkgauth.SetCredential("google-antigravity", &pkgauth.AuthCredential{
-		AccessToken: "fresh-token",
-		ExpiresAt:   refreshedExpiry,
-		Provider:    "google-antigravity",
-		AuthMethod:  "oauth",
-		ProjectID:   "fresh-project",
-	})
-	require.NoError(t, err)
-
-	output := captureAuthStdout(t, func() {
-		require.NoError(t, authStatusCmd())
-	})
-
-	assert.Contains(t, output, "\nAuthenticated Providers:")
-	assert.Contains(t, output, "\n  google-antigravity:\n")
-	assert.NotContains(t, output, "\n  antigravity:\n")
-	assert.Contains(t, output, "    Project: fresh-project")
-	assert.Contains(t, output, "    Expires: 2026-04-16 12:30")
-	assert.Equal(t, 1, strings.Count(output, ":\n    Method: oauth"))
-}

cmd/picoclaw/internal/auth/wecom.go

@@ -1,428 +0,0 @@
-package auth
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/mdp/qrterminal/v3"
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
-)
-
-const (
-	wecomQRSourceID          = "picoclaw"
-	wecomQRGenerateEndpoint  = "https://work.weixin.qq.com/ai/qc/generate"
-	wecomQRQueryEndpoint     = "https://work.weixin.qq.com/ai/qc/query_result"
-	wecomQRPageEndpoint      = "https://work.weixin.qq.com/ai/qc/gen"
-	wecomQRHTTPTimeout       = 15 * time.Second
-	wecomQRPollInterval      = 3 * time.Second
-	wecomQRPollTimeout       = 5 * time.Minute
-	wecomDefaultWebSocketURL = "wss://openws.work.weixin.qq.com"
-)
-
-type wecomQRScanner func(context.Context, wecomQRFlowOptions) (wecomQRBotInfo, error)
-
-type wecomQRFlowOptions struct {
-	HTTPClient    *http.Client
-	GenerateURL   string
-	QueryURL      string
-	QRCodePageURL string
-	SourceID      string
-	PollInterval  time.Duration
-	PollTimeout   time.Duration
-	Writer        io.Writer
-}
-
-type wecomQRBotInfo struct {
-	BotID  string
-	Secret string
-}
-
-type wecomQRSession struct {
-	SCode   string
-	AuthURL string
-}
-
-type wecomQRGenerateResponse struct {
-	ErrCode int    `json:"errcode,omitempty"`
-	ErrMsg  string `json:"errmsg,omitempty"`
-	Data    struct {
-		SCode   string `json:"scode"`
-		AuthURL string `json:"auth_url"`
-	} `json:"data"`
-}
-
-type wecomQRQueryResponse struct {
-	ErrCode int    `json:"errcode,omitempty"`
-	ErrMsg  string `json:"errmsg,omitempty"`
-	Data    struct {
-		Status  string `json:"status"`
-		BotInfo struct {
-			BotID  string `json:"botid"`
-			Secret string `json:"secret"`
-		} `json:"bot_info"`
-	} `json:"data"`
-}
-
-func newWeComCommand() *cobra.Command {
-	var timeout time.Duration
-
-	cmd := &cobra.Command{
-		Use:   "wecom",
-		Short: "Scan a WeCom QR code and configure channels.wecom",
-		Args:  cobra.NoArgs,
-		RunE: func(_ *cobra.Command, _ []string) error {
-			return authWeComCmd(timeout)
-		},
-	}
-
-	cmd.Flags().DurationVar(&timeout, "timeout", wecomQRPollTimeout, "How long to wait for QR confirmation")
-
-	return cmd
-}
-
-func authWeComCmd(timeout time.Duration) error {
-	return authWeComCmdWithScanner(context.Background(), os.Stdout, timeout, scanWeComQRCodeInteractive)
-}
-
-func authWeComCmdWithScanner(
-	ctx context.Context,
-	writer io.Writer,
-	timeout time.Duration,
-	scanner wecomQRScanner,
-) error {
-	if scanner == nil {
-		return fmt.Errorf("wecom QR scanner is nil")
-	}
-	if writer == nil {
-		writer = os.Stdout
-	}
-
-	cfg, err := internal.LoadConfig()
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	opts := defaultWeComQRFlowOptions(timeout)
-	opts.Writer = writer
-
-	botInfo, err := scanner(ctx, opts)
-	if err != nil {
-		return err
-	}
-
-	applyWeComAuthResult(cfg, botInfo)
-
-	if saveErr := config.SaveConfig(internal.GetConfigPath(), cfg); saveErr != nil {
-		return fmt.Errorf("failed to save config: %w", saveErr)
-	}
-
-	fmt.Fprintln(writer)
-	fmt.Fprintln(writer, "WeCom connected.")
-	fmt.Fprintf(writer, "Bot ID: %s\n", botInfo.BotID)
-	fmt.Fprintf(writer, "Config: %s\n", internal.GetConfigPath())
-
-	return nil
-}
-
-func defaultWeComQRFlowOptions(timeout time.Duration) wecomQRFlowOptions {
-	if timeout <= 0 {
-		timeout = wecomQRPollTimeout
-	}
-
-	return wecomQRFlowOptions{
-		HTTPClient:    &http.Client{Timeout: wecomQRHTTPTimeout},
-		GenerateURL:   wecomQRGenerateEndpoint,
-		QueryURL:      wecomQRQueryEndpoint,
-		QRCodePageURL: wecomQRPageEndpoint,
-		SourceID:      wecomQRSourceID,
-		PollInterval:  wecomQRPollInterval,
-		PollTimeout:   timeout,
-		Writer:        os.Stdout,
-	}
-}
-
-func applyWeComAuthResult(cfg *config.Config, botInfo wecomQRBotInfo) {
-	bc := cfg.Channels.GetByType(config.ChannelWeCom)
-	if bc == nil {
-		bc = &config.Channel{Type: config.ChannelWeCom}
-		cfg.Channels["wecom"] = bc
-	}
-	bc.Enabled = true
-
-	decoded, err := bc.GetDecoded()
-	if err != nil {
-		logger.ErrorCF("wecom", "failed to decode WeCom settings", map[string]any{
-			"error": err.Error(),
-		})
-		return
-	}
-	wecomCfg, ok := decoded.(*config.WeComSettings)
-	if !ok {
-		logger.ErrorCF("wecom", "unexpected WeCom settings type", map[string]any{
-			"got": fmt.Sprintf("%T", decoded),
-		})
-		return
-	}
-	wecomCfg.BotID = botInfo.BotID
-	wecomCfg.Secret = *config.NewSecureString(botInfo.Secret)
-	if strings.TrimSpace(wecomCfg.WebSocketURL) == "" {
-		wecomCfg.WebSocketURL = wecomDefaultWebSocketURL
-	}
-}
-
-func scanWeComQRCodeInteractive(ctx context.Context, opts wecomQRFlowOptions) (wecomQRBotInfo, error) {
-	opts = normalizeWeComQRFlowOptions(opts)
-
-	fmt.Fprintln(opts.Writer, "Requesting WeCom QR code...")
-
-	session, err := fetchWeComQRCode(ctx, opts)
-	if err != nil {
-		return wecomQRBotInfo{}, err
-	}
-
-	fmt.Fprintln(opts.Writer)
-	fmt.Fprintln(opts.Writer, "=======================================================")
-	fmt.Fprintln(opts.Writer, "Please scan the following QR code with WeCom:")
-	fmt.Fprintln(opts.Writer, "=======================================================")
-	fmt.Fprintln(opts.Writer)
-
-	qrterminal.GenerateWithConfig(session.AuthURL, qrterminal.Config{
-		Level:      qrterminal.L,
-		Writer:     opts.Writer,
-		HalfBlocks: true,
-	})
-
-	pageURL, err := buildWeComQRCodePageURL(opts.QRCodePageURL, opts.SourceID, session.SCode)
-	if err != nil {
-		return wecomQRBotInfo{}, err
-	}
-
-	fmt.Fprintln(opts.Writer)
-	fmt.Fprintf(opts.Writer, "QR Code Link: %s\n", pageURL)
-	fmt.Fprintln(opts.Writer)
-	fmt.Fprintln(opts.Writer, "Waiting for scan...")
-
-	return pollWeComQRCodeResult(ctx, opts, session.SCode)
-}
-
-func normalizeWeComQRFlowOptions(opts wecomQRFlowOptions) wecomQRFlowOptions {
-	if opts.HTTPClient == nil {
-		opts.HTTPClient = &http.Client{Timeout: wecomQRHTTPTimeout}
-	}
-	if strings.TrimSpace(opts.GenerateURL) == "" {
-		opts.GenerateURL = wecomQRGenerateEndpoint
-	}
-	if strings.TrimSpace(opts.QueryURL) == "" {
-		opts.QueryURL = wecomQRQueryEndpoint
-	}
-	if strings.TrimSpace(opts.QRCodePageURL) == "" {
-		opts.QRCodePageURL = wecomQRPageEndpoint
-	}
-	if strings.TrimSpace(opts.SourceID) == "" {
-		opts.SourceID = wecomQRSourceID
-	}
-	if opts.PollInterval <= 0 {
-		opts.PollInterval = wecomQRPollInterval
-	}
-	if opts.PollTimeout <= 0 {
-		opts.PollTimeout = wecomQRPollTimeout
-	}
-	if opts.Writer == nil {
-		opts.Writer = os.Stdout
-	}
-
-	return opts
-}
-
-func fetchWeComQRCode(ctx context.Context, opts wecomQRFlowOptions) (wecomQRSession, error) {
-	generateURL, err := buildWeComQRGenerateURL(opts.GenerateURL, opts.SourceID, wecomPlatformCode())
-	if err != nil {
-		return wecomQRSession{}, err
-	}
-
-	var resp wecomQRGenerateResponse
-	if err := doWeComJSONGet(ctx, opts.HTTPClient, generateURL, &resp); err != nil {
-		return wecomQRSession{}, fmt.Errorf("failed to get WeCom QR code: %w", err)
-	}
-	if resp.ErrCode != 0 {
-		return wecomQRSession{}, fmt.Errorf(
-			"failed to get WeCom QR code: errcode=%d errmsg=%s",
-			resp.ErrCode,
-			resp.ErrMsg,
-		)
-	}
-	if resp.Data.SCode == "" || resp.Data.AuthURL == "" {
-		return wecomQRSession{}, fmt.Errorf("failed to get WeCom QR code: response missing scode or auth_url")
-	}
-
-	return wecomQRSession{
-		SCode:   resp.Data.SCode,
-		AuthURL: resp.Data.AuthURL,
-	}, nil
-}
-
-func pollWeComQRCodeResult(ctx context.Context, opts wecomQRFlowOptions, scode string) (wecomQRBotInfo, error) {
-	if strings.TrimSpace(scode) == "" {
-		return wecomQRBotInfo{}, fmt.Errorf("missing WeCom QR scode")
-	}
-
-	timeoutCtx, cancel := context.WithTimeout(ctx, opts.PollTimeout)
-	defer cancel()
-
-	var scannedPrinted bool
-
-	for {
-		status, err := queryWeComQRCodeStatus(timeoutCtx, opts, scode)
-		if err != nil {
-			if errors.Is(err, context.DeadlineExceeded) || errors.Is(timeoutCtx.Err(), context.DeadlineExceeded) {
-				return wecomQRBotInfo{}, fmt.Errorf("WeCom QR scan timed out after %s", opts.PollTimeout)
-			}
-			return wecomQRBotInfo{}, err
-		}
-
-		switch strings.ToLower(status.Data.Status) {
-		case "success":
-			if status.Data.BotInfo.BotID == "" || status.Data.BotInfo.Secret == "" {
-				return wecomQRBotInfo{}, fmt.Errorf("WeCom QR scan succeeded but bot credentials are missing")
-			}
-			return wecomQRBotInfo{
-				BotID:  status.Data.BotInfo.BotID,
-				Secret: status.Data.BotInfo.Secret,
-			}, nil
-		case "expired":
-			return wecomQRBotInfo{}, fmt.Errorf("WeCom QR code expired, please retry")
-		case "scaned", "scanned":
-			if !scannedPrinted {
-				fmt.Fprintln(opts.Writer, "QR code scanned. Confirm the login in WeCom.")
-				scannedPrinted = true
-			}
-		}
-
-		select {
-		case <-timeoutCtx.Done():
-			if errors.Is(timeoutCtx.Err(), context.DeadlineExceeded) {
-				return wecomQRBotInfo{}, fmt.Errorf("WeCom QR scan timed out after %s", opts.PollTimeout)
-			}
-			return wecomQRBotInfo{}, timeoutCtx.Err()
-		case <-time.After(opts.PollInterval):
-		}
-	}
-}
-
-func queryWeComQRCodeStatus(ctx context.Context, opts wecomQRFlowOptions, scode string) (wecomQRQueryResponse, error) {
-	queryURL, err := buildWeComQRQueryURL(opts.QueryURL, scode)
-	if err != nil {
-		return wecomQRQueryResponse{}, err
-	}
-
-	var resp wecomQRQueryResponse
-	if err := doWeComJSONGet(ctx, opts.HTTPClient, queryURL, &resp); err != nil {
-		return wecomQRQueryResponse{}, fmt.Errorf("failed to query WeCom QR result: %w", err)
-	}
-	if resp.ErrCode != 0 {
-		return wecomQRQueryResponse{}, fmt.Errorf(
-			"failed to query WeCom QR result: errcode=%d errmsg=%s",
-			resp.ErrCode,
-			resp.ErrMsg,
-		)
-	}
-
-	return resp, nil
-}
-
-func buildWeComQRGenerateURL(baseURL, sourceID string, platformCode int) (string, error) {
-	u, err := url.Parse(baseURL)
-	if err != nil {
-		return "", fmt.Errorf("invalid WeCom QR generate URL: %w", err)
-	}
-
-	query := u.Query()
-	query.Set("source", sourceID)
-	query.Set("sourceID", sourceID)
-	query.Set("plat", strconv.Itoa(platformCode))
-	u.RawQuery = query.Encode()
-
-	return u.String(), nil
-}
-
-func buildWeComQRQueryURL(baseURL, scode string) (string, error) {
-	u, err := url.Parse(baseURL)
-	if err != nil {
-		return "", fmt.Errorf("invalid WeCom QR query URL: %w", err)
-	}
-
-	query := u.Query()
-	query.Set("scode", scode)
-	u.RawQuery = query.Encode()
-
-	return u.String(), nil
-}
-
-func buildWeComQRCodePageURL(baseURL, sourceID, scode string) (string, error) {
-	u, err := url.Parse(baseURL)
-	if err != nil {
-		return "", fmt.Errorf("invalid WeCom QR page URL: %w", err)
-	}
-
-	query := u.Query()
-	query.Set("source", sourceID)
-	query.Set("sourceID", sourceID)
-	query.Set("scode", scode)
-	u.RawQuery = query.Encode()
-
-	return u.String(), nil
-}
-
-func doWeComJSONGet(ctx context.Context, client *http.Client, targetURL string, out any) error {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, targetURL, nil)
-	if err != nil {
-		return err
-	}
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, readErr := io.ReadAll(io.LimitReader(resp.Body, 8192))
-		if readErr != nil {
-			return fmt.Errorf("unexpected status %s", resp.Status)
-		}
-		return fmt.Errorf("unexpected status %s: %s", resp.Status, strings.TrimSpace(string(body)))
-	}
-
-	if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
-		return fmt.Errorf("decode JSON response: %w", err)
-	}
-
-	return nil
-}
-
-func wecomPlatformCode() int {
-	switch runtime.GOOS {
-	case "darwin":
-		return 1
-	case "windows":
-		return 2
-	case "linux":
-		return 3
-	default:
-		return 0
-	}
-}

cmd/picoclaw/internal/auth/wecom_test.go

@@ -1,179 +0,0 @@
-package auth
-
-import (
-	"bytes"
-	"context"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"path/filepath"
-	"strconv"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-func newIPv4TestServer(t *testing.T, handler http.Handler) *httptest.Server {
-	t.Helper()
-
-	server := httptest.NewUnstartedServer(handler)
-	listener, err := net.Listen("tcp4", "127.0.0.1:0")
-	require.NoError(t, err)
-
-	server.Listener = listener
-	server.Start()
-	t.Cleanup(server.Close)
-	return server
-}
-
-func TestNewWeComCommand(t *testing.T) {
-	cmd := newWeComCommand()
-
-	require.NotNil(t, cmd)
-	assert.Equal(t, "wecom", cmd.Use)
-	assert.Equal(t, "Scan a WeCom QR code and configure channels.wecom", cmd.Short)
-	assert.NotNil(t, cmd.Flags().Lookup("timeout"))
-}
-
-func TestBuildWeComQRGenerateURL(t *testing.T) {
-	rawURL, err := buildWeComQRGenerateURL("https://example.com/ai/qc/generate", wecomQRSourceID, 3)
-	require.NoError(t, err)
-
-	parsed, err := url.Parse(rawURL)
-	require.NoError(t, err)
-
-	assert.Equal(t, wecomQRSourceID, parsed.Query().Get("source"))
-	assert.Equal(t, wecomQRSourceID, parsed.Query().Get("sourceID"))
-	assert.Equal(t, "3", parsed.Query().Get("plat"))
-}
-
-func TestBuildWeComQRCodePageURL(t *testing.T) {
-	rawURL, err := buildWeComQRCodePageURL("https://example.com/ai/qc/gen", wecomQRSourceID, "scode-1")
-	require.NoError(t, err)
-
-	parsed, err := url.Parse(rawURL)
-	require.NoError(t, err)
-
-	assert.Equal(t, wecomQRSourceID, parsed.Query().Get("source"))
-	assert.Equal(t, wecomQRSourceID, parsed.Query().Get("sourceID"))
-	assert.Equal(t, "scode-1", parsed.Query().Get("scode"))
-}
-
-func TestFetchWeComQRCode(t *testing.T) {
-	server := newIPv4TestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, "/generate", r.URL.Path)
-		assert.Equal(t, wecomQRSourceID, r.URL.Query().Get("source"))
-		assert.Equal(t, wecomQRSourceID, r.URL.Query().Get("sourceID"))
-		assert.Equal(t, strconv.Itoa(wecomPlatformCode()), r.URL.Query().Get("plat"))
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"data":{"scode":"scode-1","auth_url":"https://example.com/qr"}}`))
-	}))
-
-	opts := normalizeWeComQRFlowOptions(wecomQRFlowOptions{
-		HTTPClient:  server.Client(),
-		GenerateURL: server.URL + "/generate",
-		Writer:      bytes.NewBuffer(nil),
-	})
-
-	session, err := fetchWeComQRCode(context.Background(), opts)
-	require.NoError(t, err)
-	assert.Equal(t, "scode-1", session.SCode)
-	assert.Equal(t, "https://example.com/qr", session.AuthURL)
-}
-
-func TestPollWeComQRCodeResult(t *testing.T) {
-	var calls atomic.Int32
-
-	server := newIPv4TestServer(t, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		call := calls.Add(1)
-		assert.Equal(t, "/query", r.URL.Path)
-		assert.Equal(t, "scode-1", r.URL.Query().Get("scode"))
-		w.Header().Set("Content-Type", "application/json")
-		switch call {
-		case 1:
-			_, _ = w.Write([]byte(`{"data":{"status":"wait"}}`))
-		case 2:
-			_, _ = w.Write([]byte(`{"data":{"status":"scaned"}}`))
-		default:
-			_, _ = w.Write([]byte(`{"data":{"status":"success","bot_info":{"botid":"bot-1","secret":"secret-1"}}}`))
-		}
-	}))
-
-	var output bytes.Buffer
-	opts := normalizeWeComQRFlowOptions(wecomQRFlowOptions{
-		HTTPClient:   server.Client(),
-		QueryURL:     server.URL + "/query",
-		PollInterval: time.Millisecond,
-		PollTimeout:  time.Second,
-		Writer:       &output,
-	})
-
-	botInfo, err := pollWeComQRCodeResult(context.Background(), opts, "scode-1")
-	require.NoError(t, err)
-	assert.Equal(t, "bot-1", botInfo.BotID)
-	assert.Equal(t, "secret-1", botInfo.Secret)
-	assert.Contains(t, output.String(), "QR code scanned. Confirm the login in WeCom.")
-}
-
-func TestApplyWeComAuthResult(t *testing.T) {
-	cfg := config.DefaultConfig()
-	require.NoError(t, config.InitChannelList(cfg.Channels))
-	wecom := cfg.Channels["wecom"]
-	t.Logf("wecom: %+v", wecom)
-	decoded, err := wecom.GetDecoded()
-	require.NoError(t, err)
-	weCfg := decoded.(*config.WeComSettings)
-	weCfg.WebSocketURL = ""
-
-	applyWeComAuthResult(cfg, wecomQRBotInfo{
-		BotID:  "bot-1",
-		Secret: "secret-1",
-	})
-
-	assert.True(t, wecom.Enabled)
-	assert.Equal(t, "bot-1", weCfg.BotID)
-	assert.Equal(t, "secret-1", weCfg.Secret.String())
-	assert.Equal(t, wecomDefaultWebSocketURL, weCfg.WebSocketURL)
-}
-
-func TestAuthWeComCmdWithScanner(t *testing.T) {
-	tmpDir := t.TempDir()
-	configPath := filepath.Join(tmpDir, "config.json")
-
-	t.Setenv(config.EnvHome, tmpDir)
-	t.Setenv(config.EnvConfig, configPath)
-
-	var output bytes.Buffer
-	err := authWeComCmdWithScanner(
-		context.Background(),
-		&output,
-		time.Second,
-		func(_ context.Context, opts wecomQRFlowOptions) (wecomQRBotInfo, error) {
-			assert.Equal(t, wecomQRSourceID, opts.SourceID)
-			return wecomQRBotInfo{
-				BotID:  "bot-1",
-				Secret: "secret-1",
-			}, nil
-		},
-	)
-	require.NoError(t, err)
-
-	cfg, err := config.LoadConfig(internal.GetConfigPath())
-	require.NoError(t, err)
-	wecom := cfg.Channels["wecom"]
-	decoded, err := wecom.GetDecoded()
-	require.NoError(t, err)
-	weCfg := decoded.(*config.WeComSettings)
-	assert.True(t, wecom.Enabled)
-	assert.Equal(t, "bot-1", weCfg.BotID)
-	assert.Equal(t, "secret-1", weCfg.Secret.String())
-	assert.Equal(t, wecomDefaultWebSocketURL, weCfg.WebSocketURL)
-	assert.Contains(t, output.String(), "WeCom connected.")
-}

cmd/picoclaw/internal/auth/weixin.go

@@ -1,134 +0,0 @@
-package auth
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/channels/weixin"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-func newWeixinCommand() *cobra.Command {
-	var baseURL string
-	var proxy string
-	var timeout int
-
-	cmd := &cobra.Command{
-		Use:   "weixin",
-		Short: "Connect a WeChat personal account via QR code",
-		Long: `Start the interactive Weixin (WeChat personal) QR code login flow.
-
-A QR code is displayed in the terminal. Scan it with the WeChat mobile app
-to authorize your account. On success, the bot token is saved to the picoclaw
-config so you can start the gateway immediately.
-
-Example:
-  picoclaw auth weixin`,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			return runWeixinOnboard(baseURL, proxy, time.Duration(timeout)*time.Second)
-		},
-	}
-
-	cmd.Flags().StringVar(&baseURL, "base-url", "https://ilinkai.weixin.qq.com/", "iLink API base URL")
-	cmd.Flags().StringVar(&proxy, "proxy", "", "HTTP proxy URL (e.g. http://localhost:7890)")
-	cmd.Flags().IntVar(&timeout, "timeout", 300, "Login timeout in seconds")
-
-	return cmd
-}
-
-func runWeixinOnboard(baseURL, proxy string, timeout time.Duration) error {
-	fmt.Println("Starting Weixin (WeChat personal) login...")
-	fmt.Println()
-
-	botToken, userID, accountID, returnedBaseURL, err := weixin.PerformLoginInteractive(
-		context.Background(),
-		weixin.AuthFlowOpts{
-			BaseURL: baseURL,
-			Timeout: timeout,
-			Proxy:   proxy,
-		},
-	)
-	if err != nil {
-		return fmt.Errorf("login failed: %w", err)
-	}
-
-	fmt.Println()
-	fmt.Println("✅ Login successful!")
-	fmt.Printf("   Account ID : %s\n", accountID)
-	if userID != "" {
-		fmt.Printf("   User ID    : %s\n", userID)
-	}
-	fmt.Println()
-
-	// Prefer the server-returned base URL (may be region-specific)
-	effectiveBaseURL := returnedBaseURL
-	if effectiveBaseURL == "" {
-		effectiveBaseURL = baseURL
-	}
-
-	if err := saveWeixinConfig(botToken, effectiveBaseURL, proxy); err != nil {
-		fmt.Printf("⚠️  Could not auto-save to config: %v\n", err)
-		printManualWeixinConfig(botToken, effectiveBaseURL)
-		return nil
-	}
-
-	fmt.Println("✓ Config updated. Start the gateway with:")
-	fmt.Println()
-	fmt.Println("  picoclaw gateway")
-	fmt.Println()
-	fmt.Println("To restrict which WeChat users can send messages, add their user IDs")
-	fmt.Println("to channels.weixin.allow_from in your config.")
-
-	return nil
-}
-
-// saveWeixinConfig patches channels.weixin in the config and saves it.
-func saveWeixinConfig(token, baseURL, proxy string) error {
-	cfgPath := internal.GetConfigPath()
-
-	cfg, err := config.LoadConfig(cfgPath)
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	bc := cfg.Channels.GetByType(config.ChannelWeixin)
-	if bc == nil {
-		bc = &config.Channel{Type: config.ChannelWeixin}
-		cfg.Channels[config.ChannelWeixin] = bc
-	}
-	bc.Enabled = true
-
-	if decoded, err := bc.GetDecoded(); err == nil && decoded != nil {
-		if weixinCfg, ok := decoded.(*config.WeixinSettings); ok {
-			weixinCfg.Token = *config.NewSecureString(token)
-			const defaultBase = "https://ilinkai.weixin.qq.com/"
-			if baseURL != "" && baseURL != defaultBase {
-				weixinCfg.BaseURL = baseURL
-			}
-			if proxy != "" {
-				weixinCfg.Proxy = proxy
-			}
-		}
-	}
-
-	return config.SaveConfig(cfgPath, cfg)
-}
-
-func printManualWeixinConfig(token, baseURL string) {
-	fmt.Println()
-	fmt.Println("Add the following to the channels section of your picoclaw config:")
-	fmt.Println()
-	fmt.Println(`  "weixin": {`)
-	fmt.Println(`    "enabled": true,`)
-	fmt.Printf("    \"token\": %q,\n", token)
-	const defaultBase = "https://ilinkai.weixin.qq.com/"
-	if baseURL != "" && baseURL != defaultBase {
-		fmt.Printf("    \"base_url\": %q,\n", baseURL)
-	}
-	fmt.Println(`    "allow_from": []`)
-	fmt.Println(`  }`)
-}

cmd/picoclaw/internal/cliui/cliui.go

@@ -1,147 +0,0 @@
-// Package cliui renders human-oriented CLI output: bordered panels and columns
-// on wide interactive terminals. Layout (boxes/columns) is independent of ANSI
-// color: use --no-color or NO_COLOR to disable colors only; narrow or non-TTY
-// stdout falls back to plain line-oriented output.
-package cliui
-
-import (
-	"os"
-	"sync"
-
-	"github.com/charmbracelet/lipgloss"
-	"github.com/muesli/termenv"
-	"golang.org/x/term"
-)
-
-// Minimum terminal width (columns) for bordered / structured layout.
-// Below this, plain line-oriented output is used so boxes do not wrap badly.
-const minWidthFancy = 88
-
-// Minimum width to lay out some views in two columns (e.g. status providers).
-const minWidthColumns = 104
-
-var initMu sync.Mutex
-
-// Init configures lipgloss for this process. When disableAnsiColors is true
-// (e.g. --no-color, NO_COLOR, or TERM=dumb), only color is turned off; Unicode
-// borders still render when UseFancyLayout() is true.
-func Init(disableAnsiColors bool) {
-	initMu.Lock()
-	defer initMu.Unlock()
-	if disableAnsiColors {
-		lipgloss.SetColorProfile(termenv.Ascii)
-		return
-	}
-	lipgloss.SetColorProfile(termenv.EnvColorProfile())
-}
-
-// StdoutWidth returns the terminal width or a sane default if unknown.
-func StdoutWidth() int {
-	w, _, err := term.GetSize(int(os.Stdout.Fd()))
-	if err != nil || w < 20 {
-		return 80
-	}
-	return w
-}
-
-// UseFancyLayout is true when styled boxes/columns should be used.
-func UseFancyLayout() bool {
-	if !term.IsTerminal(int(os.Stdout.Fd())) {
-		return false
-	}
-	return StdoutWidth() >= minWidthFancy
-}
-
-// UseColumnLayout is true when a second content column is viable.
-func UseColumnLayout() bool {
-	return UseFancyLayout() && StdoutWidth() >= minWidthColumns
-}
-
-// InnerWidth is the target content width inside borders/margins.
-func InnerWidth() int {
-	w := StdoutWidth()
-	// Rounded border + horizontal padding (lipgloss borders ~= 2 cols each side + padding).
-	const borderBudget = 8
-	if w > borderBudget+48 {
-		return w - borderBudget
-	}
-	return 48
-}
-
-// StderrWidth returns stderr terminal width or a sane default.
-func StderrWidth() int {
-	w, _, err := term.GetSize(int(os.Stderr.Fd()))
-	if err != nil || w < 20 {
-		return 80
-	}
-	return w
-}
-
-// UseFancyStderr is true when stderr can show boxed errors without ugly wraps.
-func UseFancyStderr() bool {
-	if !term.IsTerminal(int(os.Stderr.Fd())) {
-		return false
-	}
-	return StderrWidth() >= minWidthFancy
-}
-
-// InnerStderrWidth mirrors InnerWidth but for stderr.
-func InnerStderrWidth() int {
-	w := StderrWidth()
-	const borderBudget = 8
-	if w > borderBudget+48 {
-		return w - borderBudget
-	}
-	return 48
-}
-
-var (
-	accentBlue = lipgloss.Color("#3E5DB9")
-	accentRed  = lipgloss.Color("#D54646")
-	colorMuted = lipgloss.Color("#6B6B6B")
-	colorOK    = lipgloss.Color("#2E7D32")
-)
-
-func borderStyle() lipgloss.Style {
-	return lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(accentBlue).
-		Padding(0, 1)
-}
-
-func titleBarStyle() lipgloss.Style {
-	return lipgloss.NewStyle().
-		Foreground(accentRed).
-		Bold(true)
-}
-
-func mutedStyle() lipgloss.Style {
-	return lipgloss.NewStyle().Foreground(colorMuted)
-}
-
-func bodyStyle() lipgloss.Style {
-	return lipgloss.NewStyle()
-}
-
-func kvKeyStyle() lipgloss.Style {
-	return lipgloss.NewStyle().Foreground(accentBlue).Bold(true)
-}
-
-func kvValStyle() lipgloss.Style {
-	return lipgloss.NewStyle()
-}
-
-// helpIntroStyle is the top tagline (PicoClaw blue, matches ASCII banner left side).
-func helpIntroStyle() lipgloss.Style {
-	return lipgloss.NewStyle().Foreground(accentBlue).Bold(true)
-}
-
-// helpIdentStyle is the left column for commands and flags (blue identifiers).
-func helpIdentStyle() lipgloss.Style {
-	return lipgloss.NewStyle().Foreground(accentBlue).Bold(true)
-}
-
-// helpPlaceholderStyle highlights <placeholders> in usage lines (red accent).
-func helpPlaceholderStyle() lipgloss.Style {
-	return lipgloss.NewStyle().Foreground(accentRed).Bold(true)
-}

cmd/picoclaw/internal/cliui/cliui_test.go

@@ -1,180 +0,0 @@
-package cliui
-
-import (
-	"testing"
-
-	flag "github.com/spf13/pflag"
-)
-
-func init() {
-	// Disable ANSI colors in tests so output is predictable plain text.
-	Init(true)
-}
-
-// ---------------------------------------------------------------------------
-// showErrHint
-// ---------------------------------------------------------------------------
-
-func TestShowErrHint(t *testing.T) {
-	cases := []struct {
-		msg  string
-		want bool
-	}{
-		// Cobra flag errors — should show hint
-		{"unknown flag: --foo", true},
-		{"unknown shorthand flag: 'f' in -f", true},
-		{"flag needs an argument: --output", true},
-		{"required flag(s) \"model\" not set", true},
-		// Generic invalid-argument errors — should show hint
-		{"invalid argument \"abc\" for --count", true},
-		// required flag errors — should show hint
-		{"required flag(s) \"model\" not set", true},
-		// usage: in message — should show hint
-		{"bad input\nusage: picoclaw ...", true},
-		// Should NOT false-positive on broad words
-		{"connection flagged by remote", false},
-		{"feature flag not set", false},
-		{"invalid API key provided", false},
-		{"authentication required", false},
-		// Unrelated messages — no hint
-		{"something went wrong", false},
-		{"network timeout", false},
-	}
-
-	for _, tc := range cases {
-		got := showErrHint(tc.msg)
-		if got != tc.want {
-			t.Errorf("showErrHint(%q) = %v, want %v", tc.msg, got, tc.want)
-		}
-	}
-}
-
-// ---------------------------------------------------------------------------
-// styleUsageTokens
-// ---------------------------------------------------------------------------
-
-func TestStyleUsageTokensContainsTokens(t *testing.T) {
-	cases := []struct {
-		input    string
-		contains []string // substrings that must appear in plain output
-	}{
-		{
-			"picoclaw agent <message>",
-			[]string{"picoclaw agent", "<message>"},
-		},
-		{
-			"picoclaw [command] [flags]",
-			[]string{"picoclaw", "[command]", "[flags]"},
-		},
-		{
-			"picoclaw",
-			[]string{"picoclaw"},
-		},
-		{
-			"cmd <arg1> [--flag]",
-			[]string{"cmd", "<arg1>", "[--flag]"},
-		},
-	}
-
-	for _, tc := range cases {
-		out := styleUsageTokens(tc.input)
-		for _, sub := range tc.contains {
-			if !containsStripped(out, sub) {
-				t.Errorf("styleUsageTokens(%q): output %q does not contain %q", tc.input, out, sub)
-			}
-		}
-	}
-}
-
-// containsStripped checks whether plain contains sub after stripping ANSI escapes.
-// Since Init(true) sets Ascii profile, lipgloss emits no escape codes in tests,
-// so this is just a plain substring check.
-func containsStripped(plain, sub string) bool {
-	return len(plain) >= len(sub) && findSubstring(plain, sub)
-}
-
-func findSubstring(s, sub string) bool {
-	for i := 0; i <= len(s)-len(sub); i++ {
-		if s[i:i+len(sub)] == sub {
-			return true
-		}
-	}
-	return false
-}
-
-// ---------------------------------------------------------------------------
-// collectFlagRows
-// ---------------------------------------------------------------------------
-
-func TestCollectFlagRows_Empty(t *testing.T) {
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	rows := collectFlagRows(fs)
-	if len(rows) != 0 {
-		t.Fatalf("expected 0 rows for empty FlagSet, got %d", len(rows))
-	}
-}
-
-func TestCollectFlagRows_BasicFlags(t *testing.T) {
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	fs.String("output", "", "output file path")
-	fs.Bool("verbose", false, "enable verbose mode")
-	fs.Int("count", 1, "number of items")
-
-	rows := collectFlagRows(fs)
-
-	if len(rows) != 3 {
-		t.Fatalf("expected 3 rows, got %d", len(rows))
-	}
-
-	// Rows must be sorted alphabetically by flag name.
-	names := make([]string, 0, len(rows))
-	for _, r := range rows {
-		names = append(names, r[0])
-	}
-	if names[0] > names[1] || names[1] > names[2] {
-		t.Errorf("rows not sorted: %v", names)
-	}
-}
-
-func TestCollectFlagRows_Shorthand(t *testing.T) {
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	fs.StringP("model", "m", "", "model name")
-
-	rows := collectFlagRows(fs)
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(rows))
-	}
-	left := rows[0][0]
-	if !findSubstring(left, "-m") || !findSubstring(left, "--model") {
-		t.Errorf("expected shorthand and long form in %q", left)
-	}
-}
-
-func TestCollectFlagRows_HiddenFlagsExcluded(t *testing.T) {
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	fs.String("visible", "", "this shows up")
-	hidden := fs.String("hidden", "", "this should not show up")
-	_ = hidden
-	_ = fs.MarkHidden("hidden")
-
-	rows := collectFlagRows(fs)
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row (hidden excluded), got %d", len(rows))
-	}
-	if !findSubstring(rows[0][0], "visible") {
-		t.Errorf("expected visible flag in rows, got %q", rows[0][0])
-	}
-}
-
-func TestCollectFlagRows_UsageInRightColumn(t *testing.T) {
-	fs := flag.NewFlagSet("test", flag.ContinueOnError)
-	fs.String("format", "json", "output format: json or text")
-
-	rows := collectFlagRows(fs)
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(rows))
-	}
-	if rows[0][1] != "output format: json or text" {
-		t.Errorf("expected usage in right column, got %q", rows[0][1])
-	}
-}

cmd/picoclaw/internal/cliui/help_cmd.go

@@ -1,298 +0,0 @@
-package cliui
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-	"github.com/spf13/cobra"
-	flag "github.com/spf13/pflag"
-)
-
-// RenderCommandHelp builds Ruff-style sectioned, two-column help when
-// UseFancyLayout(); otherwise plain Cobra-style text.
-func RenderCommandHelp(c *cobra.Command) string {
-	if !UseFancyLayout() {
-		return plainCommandHelp(c)
-	}
-	syncFlags(c)
-
-	var b strings.Builder
-	head, sub := helpIntro(c)
-	if head != "" {
-		b.WriteString(helpIntroStyle().Render(head))
-		b.WriteString("\n")
-	}
-	if sub != "" {
-		b.WriteString(mutedStyle().Render(sub))
-		b.WriteString("\n")
-	}
-	if head != "" || sub != "" {
-		b.WriteString("\n")
-	}
-
-	inner := InnerWidth()
-	contentW := inner - 6
-	if contentW < 36 {
-		contentW = 36
-	}
-
-	// Usage
-	usageBody := bodyStyle().MaxWidth(contentW).Render(styleUsageTokens(c.UseLine()))
-	b.WriteString(sectionPanel("Usage", usageBody, inner))
-	b.WriteString("\n")
-
-	// Examples
-	if ex := strings.TrimSpace(c.Example); ex != "" {
-		exBody := bodyStyle().Width(contentW).Render(ex)
-		b.WriteString(sectionPanel("Examples", exBody, inner))
-		b.WriteString("\n")
-	}
-
-	// Subcommands
-	subs := visibleSubcommands(c)
-	if len(subs) > 0 {
-		rows := make([][2]string, 0, len(subs))
-		for _, sub := range subs {
-			left := sub.Name()
-			if a := sub.Aliases; len(a) > 0 {
-				left += " (" + strings.Join(a, ", ") + ")"
-			}
-			rows = append(rows, [2]string{left, sub.Short})
-		}
-		b.WriteString(sectionPanel("Commands", renderTwoColPairs(rows, contentW), inner))
-		b.WriteString("\n")
-	}
-
-	// Local options
-	local := c.LocalFlags()
-	opts := collectFlagRows(local)
-	if len(opts) > 0 {
-		title := "Options"
-		if !c.HasParent() {
-			title = "Flags"
-		}
-		b.WriteString(sectionPanel(title, renderTwoColPairs(opts, contentW), inner))
-		b.WriteString("\n")
-	}
-
-	// Global (inherited) options
-	if c.HasAvailableInheritedFlags() {
-		inh := collectFlagRows(c.InheritedFlags())
-		if len(inh) > 0 {
-			b.WriteString(sectionPanel("Global options", renderTwoColPairs(inh, contentW), inner))
-			b.WriteString("\n")
-		}
-	}
-
-	return b.String()
-}
-
-// RenderCommandQuickRef prints the same Usage / Flags / Global sections as help,
-// for embedding after errors (stderr). outerW is typically InnerStderrWidth().
-func RenderCommandQuickRef(c *cobra.Command, outerW int) string {
-	if c == nil || outerW < 40 {
-		return ""
-	}
-	syncFlags(c)
-	contentW := outerW - 6
-	if contentW < 36 {
-		contentW = 36
-	}
-	var b strings.Builder
-	usageBody := bodyStyle().MaxWidth(contentW).Render(styleUsageTokens(c.UseLine()))
-	b.WriteString(sectionPanel("Usage", usageBody, outerW))
-	b.WriteString("\n")
-	if len(c.Aliases) > 0 {
-		al := "Aliases: " + strings.Join(c.Aliases, ", ")
-		alBody := mutedStyle().MaxWidth(contentW).Render(al)
-		b.WriteString(sectionPanel("Aliases", alBody, outerW))
-		b.WriteString("\n")
-	}
-	opts := collectFlagRows(c.LocalFlags())
-	if len(opts) > 0 {
-		title := "Options"
-		if !c.HasParent() {
-			title = "Flags"
-		}
-		b.WriteString(sectionPanel(title, renderTwoColPairs(opts, contentW), outerW))
-		b.WriteString("\n")
-	}
-	if c.HasAvailableInheritedFlags() {
-		inh := collectFlagRows(c.InheritedFlags())
-		if len(inh) > 0 {
-			b.WriteString(sectionPanel("Global options", renderTwoColPairs(inh, contentW), outerW))
-			b.WriteString("\n")
-		}
-	}
-	return b.String()
-}
-
-func syncFlags(c *cobra.Command) {
-	_ = c.LocalFlags()
-	if c.HasAvailableInheritedFlags() {
-		_ = c.InheritedFlags()
-	}
-}
-
-func plainCommandHelp(c *cobra.Command) string {
-	desc := c.Long
-	if desc == "" {
-		desc = c.Short
-	}
-	desc = strings.TrimRight(desc, " \t\n\r")
-	var b strings.Builder
-	if desc != "" {
-		fmt.Fprintln(&b, desc)
-		fmt.Fprintln(&b)
-	}
-	if c.Runnable() || c.HasSubCommands() {
-		b.WriteString(c.UsageString())
-	}
-	return b.String()
-}
-
-func helpIntro(c *cobra.Command) (head, sub string) {
-	head = strings.TrimSpace(c.Short)
-	long := strings.TrimSpace(c.Long)
-	if long == "" || long == head {
-		return head, ""
-	}
-	lines := strings.Split(long, "\n")
-	var rest []string
-	for i, ln := range lines {
-		ln = strings.TrimSpace(ln)
-		if ln == "" {
-			continue
-		}
-		if i == 0 && ln == head {
-			continue
-		}
-		rest = append(rest, ln)
-	}
-	sub = strings.Join(rest, "\n")
-	return head, sub
-}
-
-func visibleSubcommands(c *cobra.Command) []*cobra.Command {
-	var out []*cobra.Command
-	for _, sub := range c.Commands() {
-		if sub.Hidden {
-			continue
-		}
-		out = append(out, sub)
-	}
-	sort.Slice(out, func(i, j int) bool { return out[i].Name() < out[j].Name() })
-	return out
-}
-
-func sectionPanel(title, body string, width int) string {
-	head := titleBarStyle().Render(title) + "\n\n"
-	return borderStyle().Width(width).Render(head + body)
-}
-
-// styleUsageTokens highlights PicoClaw-blue command tokens and red <placeholders>/[groups].
-func styleUsageTokens(s string) string {
-	var b strings.Builder
-	for len(s) > 0 {
-		ia := strings.Index(s, "<")
-		ib := strings.Index(s, "[")
-		next, kind := -1, 0 // 1 = angle, 2 = bracket
-		switch {
-		case ia >= 0 && (ib < 0 || ia < ib):
-			next, kind = ia, 1
-		case ib >= 0:
-			next, kind = ib, 2
-		}
-		if next < 0 {
-			b.WriteString(helpIdentStyle().Render(s))
-			break
-		}
-		if next > 0 {
-			b.WriteString(helpIdentStyle().Render(s[:next]))
-		}
-		s = s[next:]
-		if kind == 1 {
-			j := strings.Index(s, ">")
-			if j < 0 {
-				b.WriteString(helpIdentStyle().Render(s))
-				break
-			}
-			b.WriteString(helpPlaceholderStyle().Render(s[:j+1]))
-			s = s[j+1:]
-			continue
-		}
-		j := strings.Index(s, "]")
-		if j < 0 {
-			b.WriteString(helpIdentStyle().Render(s))
-			break
-		}
-		b.WriteString(helpPlaceholderStyle().Render(s[:j+1]))
-		s = s[j+1:]
-	}
-	return b.String()
-}
-
-func collectFlagRows(fs *flag.FlagSet) [][2]string {
-	var names []string
-	seen := map[string][2]string{}
-	fs.VisitAll(func(f *flag.Flag) {
-		if f.Hidden {
-			return
-		}
-		left := formatFlagLeft(f)
-		right := f.Usage
-		if f.Deprecated != "" {
-			right += " (deprecated: " + f.Deprecated + ")"
-		}
-		names = append(names, f.Name)
-		seen[f.Name] = [2]string{left, right}
-	})
-	sort.Strings(names)
-	rows := make([][2]string, 0, len(names))
-	for _, n := range names {
-		rows = append(rows, seen[n])
-	}
-	return rows
-}
-
-func formatFlagLeft(f *flag.Flag) string {
-	if len(f.Shorthand) > 0 {
-		return "-" + f.Shorthand + ", --" + f.Name
-	}
-	return "--" + f.Name
-}
-
-func renderTwoColPairs(rows [][2]string, contentW int) string {
-	if len(rows) == 0 {
-		return ""
-	}
-	leftW := 0
-	for _, r := range rows {
-		if w := lipgloss.Width(r[0]); w > leftW {
-			leftW = w
-		}
-	}
-	const minLeft, maxLeft = 16, 34
-	if leftW < minLeft {
-		leftW = minLeft
-	}
-	if leftW > maxLeft {
-		leftW = maxLeft
-	}
-	gap := "  "
-	rightW := contentW - leftW - lipgloss.Width(gap)
-	if rightW < 24 {
-		rightW = 24
-	}
-
-	var b strings.Builder
-	for _, r := range rows {
-		left := helpIdentStyle().Width(leftW).Align(lipgloss.Left).Render(r[0])
-		right := bodyStyle().Width(rightW).Render(strings.TrimSpace(r[1]))
-		b.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, left, gap, right))
-		b.WriteString("\n")
-	}
-	return strings.TrimRight(b.String(), "\n")
-}

cmd/picoclaw/internal/cliui/help_error.go

@@ -1,75 +0,0 @@
-package cliui
-
-import (
-	"strings"
-
-	"github.com/spf13/cobra"
-)
-
-// FormatCLIError formats errors with the same boxed sections as help. When ctx
-// is the command that was running when the error occurred, Usage / Flags panels
-// are appended so styling matches picoclaw -h.
-func FormatCLIError(msg string, ctx *cobra.Command) string {
-	msg = strings.TrimRight(msg, "\n")
-	if !UseFancyStderr() {
-		s := "Error: " + msg + "\n"
-		if ctx != nil && showErrHint(msg) {
-			s += "\n" + plainCommandHelp(ctx)
-		}
-		return s
-	}
-	w := InnerStderrWidth()
-	contentW := w - 6
-	if contentW < 36 {
-		contentW = 36
-	}
-
-	title := titleBarStyle().Render("Error") + "\n\n"
-
-	paras := strings.Split(msg, "\n")
-	var body strings.Builder
-	for i, p := range paras {
-		p = strings.TrimRight(p, " ")
-		if p == "" {
-			continue
-		}
-		st := bodyStyle().Width(contentW)
-		if i > 0 {
-			body.WriteString("\n")
-		}
-		if i == 0 {
-			body.WriteString(st.Render(p))
-		} else {
-			body.WriteString(mutedStyle().Width(contentW).Render(p))
-		}
-	}
-
-	foot := ""
-	if showErrHint(msg) {
-		if ctx != nil {
-			foot = "\n\n" + mutedStyle().Width(contentW).
-				Render("Full command help: "+ctx.CommandPath()+" --help")
-		} else {
-			foot = "\n\n" + mutedStyle().Width(contentW).
-				Render("Tip: picoclaw --help   ·   picoclaw <command> --help")
-		}
-	}
-
-	out := borderStyle().Width(w).Render(title+body.String()+foot) + "\n"
-	if ctx != nil && showErrHint(msg) {
-		if ref := RenderCommandQuickRef(ctx, w); ref != "" {
-			out += "\n" + ref
-		}
-	}
-	return out
-}
-
-func showErrHint(msg string) bool {
-	m := strings.ToLower(msg)
-	return strings.Contains(m, "unknown flag") ||
-		strings.Contains(m, "unknown shorthand flag") ||
-		strings.Contains(m, "flag needs an argument") ||
-		strings.Contains(m, "invalid argument") ||
-		strings.Contains(m, "required flag") ||
-		strings.Contains(m, "usage:")
-}

cmd/picoclaw/internal/cliui/mcp_show.go

@@ -1,384 +0,0 @@
-package cliui
-
-import (
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-// MCPShowServer holds the server metadata for PrintMCPShow.
-type MCPShowServer struct {
-	Name              string
-	Type              string
-	Target            string
-	Enabled           bool
-	EffectiveDeferred bool     // resolved value (per-server override or global default)
-	DeferredExplicit  bool     // true = per-server override set, false = inherited from global
-	EnvKeys           []string // sorted env var names (values intentionally omitted)
-	EnvFile           string
-	Headers           []string // sorted header names
-}
-
-// MCPShowTool holds one tool's info for PrintMCPShow.
-type MCPShowTool struct {
-	Name        string
-	Description string
-	Parameters  []MCPShowParam
-}
-
-// MCPShowParam is one parameter entry.
-type MCPShowParam struct {
-	Name        string
-	Type        string
-	Description string
-	Required    bool
-}
-
-// PrintMCPShow renders the mcp show output (plain or fancy).
-// w is where the output is written; pass cmd.OutOrStdout() from cobra commands.
-func PrintMCPShow(w io.Writer, server MCPShowServer, tools []MCPShowTool, disabled bool) {
-	if !UseFancyLayout() {
-		printMCPShowPlain(w, server, tools, disabled)
-		return
-	}
-	printMCPShowFancy(w, server, tools, disabled)
-}
-
-// ── plain (narrow / non-TTY) ────────────────────────────────────────────────
-
-func printMCPShowPlain(w io.Writer, server MCPShowServer, tools []MCPShowTool, disabled bool) {
-	fmt.Fprintf(w, "Server: %s\n", server.Name)
-	fmt.Fprintf(w, "Type:   %s\n", server.Type)
-	fmt.Fprintf(w, "Target: %s\n", server.Target)
-	fmt.Fprintf(w, "Enabled: %s\n", boolWord(server.Enabled))
-	deferredLabel := boolWord(server.EffectiveDeferred)
-	if !server.DeferredExplicit {
-		deferredLabel += " (default)"
-	}
-	fmt.Fprintf(w, "Deferred: %s\n", deferredLabel)
-	if len(server.EnvKeys) > 0 {
-		fmt.Fprintf(w, "Env vars: %s\n", strings.Join(server.EnvKeys, ", "))
-	}
-	if server.EnvFile != "" {
-		fmt.Fprintf(w, "Env file: %s\n", server.EnvFile)
-	}
-	if len(server.Headers) > 0 {
-		fmt.Fprintf(w, "Headers: %s\n", strings.Join(server.Headers, ", "))
-	}
-	fmt.Fprintln(w)
-
-	if disabled {
-		fmt.Fprintln(w, "Server is disabled; skipping tool discovery.")
-		return
-	}
-	if len(tools) == 0 {
-		fmt.Fprintln(w, "No tools exposed by this server.")
-		return
-	}
-
-	fmt.Fprintf(w, "Tools (%d):\n", len(tools))
-	for _, tool := range tools {
-		fmt.Fprintf(w, "  %s\n", tool.Name)
-		if tool.Description != "" {
-			fmt.Fprintf(w, "    %s\n", truncateDescription(tool.Description, 120))
-		}
-		if len(tool.Parameters) == 0 {
-			fmt.Fprintln(w, "    Parameters: none")
-			continue
-		}
-		for _, p := range tool.Parameters {
-			line := fmt.Sprintf("    - %s", p.Name)
-			if p.Type != "" {
-				line += fmt.Sprintf(" (%s", p.Type)
-				if p.Required {
-					line += ", required"
-				}
-				line += ")"
-			} else if p.Required {
-				line += " (required)"
-			}
-			if p.Description != "" {
-				line += ": " + truncateDescription(p.Description, 80)
-			}
-			fmt.Fprintln(w, line)
-		}
-	}
-}
-
-// ── fancy (wide TTY) ────────────────────────────────────────────────────────
-
-var (
-	mcpToolNameStyle = func() lipgloss.Style {
-		return lipgloss.NewStyle().Foreground(accentBlue).Bold(true)
-	}
-	mcpParamNameStyle = func() lipgloss.Style {
-		return lipgloss.NewStyle().Foreground(accentRed).Bold(true)
-	}
-	mcpTagStyle = func() lipgloss.Style {
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#888888"))
-	}
-	mcpRequiredStyle = func() lipgloss.Style {
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#D54646")).Bold(true)
-	}
-	mcpOptionalStyle = func() lipgloss.Style {
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#6B6B6B"))
-	}
-	mcpDescStyle = func() lipgloss.Style {
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#CCCCCC"))
-	}
-)
-
-func printMCPShowFancy(w io.Writer, server MCPShowServer, tools []MCPShowTool, disabled bool) {
-	inner := InnerWidth()
-	box := borderStyle().Width(inner)
-
-	var b strings.Builder
-
-	// ── server header ──
-	b.WriteString(titleBarStyle().Render("⬡  " + server.Name))
-	b.WriteString("\n\n")
-
-	keyW := 10
-	writeKV := func(key, val string) {
-		k := kvKeyStyle().Width(keyW).Render(key)
-		b.WriteString(k + "  " + val + "\n")
-	}
-
-	writeKV("Type", server.Type)
-	writeKV("Target", server.Target)
-	writeKV("Enabled", coloredBool(server.Enabled))
-	deferredVal := coloredBool(server.EffectiveDeferred)
-	if !server.DeferredExplicit {
-		deferredVal += "  " + mcpTagStyle().Render("(default)")
-	}
-	writeKV("Deferred", deferredVal)
-	if len(server.EnvKeys) > 0 {
-		writeKV("Env vars", mutedStyle().Render(strings.Join(server.EnvKeys, ", ")))
-	}
-	if server.EnvFile != "" {
-		writeKV("Env file", mutedStyle().Render(server.EnvFile))
-	}
-	if len(server.Headers) > 0 {
-		writeKV("Headers", mutedStyle().Render(strings.Join(server.Headers, ", ")))
-	}
-
-	if disabled {
-		b.WriteString("\n")
-		b.WriteString(mutedStyle().Render("Server is disabled; skipping tool discovery."))
-		fmt.Fprintln(w, box.Render(b.String()))
-		return
-	}
-
-	if len(tools) == 0 {
-		b.WriteString("\n")
-		b.WriteString(mutedStyle().Render("No tools exposed by this server."))
-		fmt.Fprintln(w, box.Render(b.String()))
-		return
-	}
-
-	// ── tools section ──
-	b.WriteString("\n")
-	b.WriteString(kvKeyStyle().Render(fmt.Sprintf("Tools (%d)", len(tools))))
-	b.WriteString("\n")
-
-	contentW := inner - 4 // account for box padding
-	for i, tool := range tools {
-		if i > 0 {
-			b.WriteString(strings.Repeat("─", contentW) + "\n")
-		}
-		b.WriteString("\n")
-
-		// Tool name + index badge
-		badge := mcpTagStyle().Render(fmt.Sprintf("[%d/%d]", i+1, len(tools)))
-		b.WriteString("  " + mcpToolNameStyle().Render(tool.Name) + "  " + badge + "\n")
-
-		// Description (wrapped to content width)
-		if tool.Description != "" {
-			desc := truncateDescription(tool.Description, 160)
-			b.WriteString("  " + mcpDescStyle().Render(desc) + "\n")
-		}
-
-		// Parameters
-		if len(tool.Parameters) == 0 {
-			b.WriteString("  " + mcpTagStyle().Render("no parameters") + "\n")
-			continue
-		}
-
-		b.WriteString("\n")
-		for _, p := range tool.Parameters {
-			// name
-			pName := mcpParamNameStyle().Render(p.Name)
-
-			// type tag
-			typeTag := ""
-			if p.Type != "" {
-				typeTag = "  " + mcpTagStyle().Render("<"+p.Type+">")
-			}
-
-			// required / optional badge
-			var reqBadge string
-			if p.Required {
-				reqBadge = "  " + mcpRequiredStyle().Render("required")
-			} else {
-				reqBadge = "  " + mcpOptionalStyle().Render("optional")
-			}
-
-			b.WriteString("    " + pName + typeTag + reqBadge + "\n")
-
-			if p.Description != "" {
-				desc := truncateDescription(p.Description, 120)
-				b.WriteString("      " + mutedStyle().Render(desc) + "\n")
-			}
-		}
-	}
-
-	fmt.Fprintln(w, box.Render(b.String()))
-}
-
-// ── mcp list ────────────────────────────────────────────────────────────────
-
-// MCPListRow is one row in the mcp list output.
-type MCPListRow struct {
-	Name              string
-	Type              string
-	Target            string
-	Status            string // "enabled", "disabled", "ok (N tools)", "error"
-	EffectiveDeferred bool   // resolved value (per-server override or global default)
-	DeferredExplicit  bool   // true = per-server override set, false = inherited from global
-}
-
-// PrintMCPList renders the mcp list output (plain or fancy).
-func PrintMCPList(w io.Writer, rows []MCPListRow) {
-	if !UseFancyLayout() {
-		printMCPListPlain(w, rows)
-		return
-	}
-	printMCPListFancy(w, rows)
-}
-
-func printMCPListPlain(w io.Writer, rows []MCPListRow) {
-	headers := []string{"Name", "Type", "Command", "Status", "Deferred"}
-	tableRows := make([][]string, len(rows))
-	for i, r := range rows {
-		deferred := boolWord(r.EffectiveDeferred)
-		if !r.DeferredExplicit {
-			deferred += " (default)"
-		}
-		tableRows[i] = []string{r.Name, r.Type, r.Target, r.Status, deferred}
-	}
-	// reuse the ASCII table renderer already in helpers.go via the caller
-	// (list.go still uses renderTable for the plain path)
-	widths := make([]int, len(headers))
-	for i, h := range headers {
-		widths[i] = len(h)
-	}
-	for _, row := range tableRows {
-		for i, cell := range row {
-			if len(cell) > widths[i] {
-				widths[i] = len(cell)
-			}
-		}
-	}
-	border := func() {
-		fmt.Fprint(w, "+")
-		for _, width := range widths {
-			fmt.Fprint(w, strings.Repeat("-", width+2)+"+")
-		}
-		fmt.Fprintln(w)
-	}
-	writeRow := func(row []string) {
-		fmt.Fprint(w, "|")
-		for i, cell := range row {
-			fmt.Fprintf(w, " %s%s |", cell, strings.Repeat(" ", widths[i]-len(cell)))
-		}
-		fmt.Fprintln(w)
-	}
-	border()
-	writeRow(headers)
-	border()
-	for _, row := range tableRows {
-		writeRow(row)
-	}
-	border()
-}
-
-func printMCPListFancy(w io.Writer, rows []MCPListRow) {
-	inner := InnerWidth()
-	box := borderStyle().Width(inner)
-
-	var b strings.Builder
-
-	title := fmt.Sprintf("MCP Servers (%d)", len(rows))
-	b.WriteString(titleBarStyle().Render(title))
-	b.WriteString("\n")
-
-	contentW := inner - 4
-	for i, row := range rows {
-		if i > 0 {
-			b.WriteString(strings.Repeat("─", contentW) + "\n")
-		}
-		b.WriteString("\n")
-
-		statusBadge := mcpListStatusStyle(row.Status).Render(row.Status)
-		var deferredBadge string
-		if row.EffectiveDeferred {
-			if row.DeferredExplicit {
-				deferredBadge = "  " + mcpTagStyle().Render("deferred")
-			} else {
-				deferredBadge = "  " + mcpOptionalStyle().Render("deferred (default)")
-			}
-		}
-		b.WriteString("  " + mcpToolNameStyle().Render(row.Name) + "  " + statusBadge + deferredBadge + "\n")
-		b.WriteString("  " + mcpTagStyle().Render(row.Type+"  "+row.Target) + "\n")
-	}
-
-	fmt.Fprintln(w, box.Render(b.String()))
-}
-
-func mcpListStatusStyle(status string) lipgloss.Style {
-	switch {
-	case status == "enabled":
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#2E7D32")).Bold(true)
-	case status == "disabled":
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#6B6B6B"))
-	case strings.HasPrefix(status, "ok"):
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#2E7D32")).Bold(true)
-	case status == "error":
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#D54646")).Bold(true)
-	default:
-		return lipgloss.NewStyle()
-	}
-}
-
-// ── helpers ─────────────────────────────────────────────────────────────────
-
-func boolWord(v bool) string {
-	if v {
-		return "yes"
-	}
-	return "no"
-}
-
-func coloredBool(v bool) string {
-	if v {
-		return lipgloss.NewStyle().Foreground(lipgloss.Color("#2E7D32")).Bold(true).Render("yes")
-	}
-	return lipgloss.NewStyle().Foreground(lipgloss.Color("#D54646")).Render("no")
-}
-
-// truncateDescription strips newlines, collapses whitespace, and caps length.
-func truncateDescription(s string, maxLen int) string {
-	// collapse newlines and repeated spaces into a single space
-	s = strings.Join(strings.Fields(s), " ")
-	if len(s) <= maxLen {
-		return s
-	}
-	// cut at last space before maxLen
-	cut := s[:maxLen]
-	if idx := strings.LastIndex(cut, " "); idx > maxLen/2 {
-		cut = cut[:idx]
-	}
-	return cut + "…"
-}

cmd/picoclaw/internal/cliui/onboard.go

@@ -1,110 +0,0 @@
-package cliui
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-// PrintOnboardComplete prints the post-onboard “ready” message and next steps.
-func PrintOnboardComplete(logo string, encrypt bool, configPath string) {
-	if !UseFancyLayout() {
-		printOnboardPlain(logo, encrypt, configPath)
-		return
-	}
-	printOnboardFancy(logo, encrypt, configPath)
-}
-
-func printOnboardPlain(logo string, encrypt bool, configPath string) {
-	fmt.Printf("\n%s picoclaw is ready!\n", logo)
-	fmt.Println("\nNext steps:")
-	if encrypt {
-		fmt.Println("  1. Set your encryption passphrase before starting picoclaw:")
-		fmt.Println("       export PICOCLAW_KEY_PASSPHRASE=<your-passphrase>   # Linux/macOS")
-		fmt.Println("       set PICOCLAW_KEY_PASSPHRASE=<your-passphrase>      # Windows cmd")
-		fmt.Println("")
-		fmt.Println("  2. Add your API key to", configPath)
-	} else {
-		fmt.Println("  1. Add your API key to", configPath)
-	}
-	fmt.Println("")
-	fmt.Println("     Recommended:")
-	fmt.Println("     - OpenRouter: https://openrouter.ai/keys (access 100+ models)")
-	fmt.Println("     - Ollama:     https://ollama.com (local, free)")
-	fmt.Println("")
-	fmt.Println("     See README.md for 17+ supported providers.")
-	fmt.Println("")
-	if encrypt {
-		fmt.Println("  3. Chat: picoclaw agent -m \"Hello!\"")
-	} else {
-		fmt.Println("  2. Chat: picoclaw agent -m \"Hello!\"")
-	}
-}
-
-func printOnboardFancy(logo string, encrypt bool, configPath string) {
-	inner := InnerWidth()
-	box := borderStyle().MaxWidth(inner + 8)
-
-	ready := titleBarStyle().Render(logo+" picoclaw is ready!") + "\n"
-	fmt.Println()
-	fmt.Println(box.Width(inner).Render(strings.TrimSpace(ready)))
-	fmt.Println()
-
-	steps := buildOnboardingSteps(encrypt, configPath)
-	rec := recommendedBlock()
-	chat := chatStep(encrypt)
-
-	if UseColumnLayout() {
-		leftW := min(inner/2-2, 52)
-		rightW := inner - leftW - 4
-		if rightW < 36 {
-			rightW = 36
-		}
-		leftBlock := borderStyle().MaxWidth(leftW + 8).Width(leftW).
-			Render(titleBarStyle().Render("Next steps") + "\n\n" + bodyStyle().Width(leftW).Render(steps))
-		rightBlock := borderStyle().MaxWidth(rightW + 8).Width(rightW).
-			Render(mutedStyle().Bold(true).Render("Recommended") + "\n\n" + bodyStyle().Width(rightW).Render(rec))
-		gap := strings.Repeat(" ", 2)
-		fmt.Println(lipgloss.JoinHorizontal(lipgloss.Top, leftBlock, gap, rightBlock))
-		fmt.Println()
-		full := borderStyle().Width(inner).Render(bodyStyle().Width(inner - 4).Render(chat))
-		fmt.Println(full)
-		return
-	}
-
-	// Same order as plain output: numbered steps → recommended → chat line.
-	next := titleBarStyle().Render("Next steps") + "\n\n" +
-		bodyStyle().Width(inner-4).Render(steps+"\n\n"+rec+"\n\n"+chat)
-	fmt.Println(borderStyle().Width(inner).Render(next))
-}
-
-func buildOnboardingSteps(encrypt bool, configPath string) string {
-	var b strings.Builder
-	if encrypt {
-		b.WriteString("1. Set your encryption passphrase before starting picoclaw:\n")
-		b.WriteString("   export PICOCLAW_KEY_PASSPHRASE=<your-passphrase>   # Linux/macOS\n")
-		b.WriteString("   set PICOCLAW_KEY_PASSPHRASE=<your-passphrase>      # Windows cmd\n\n")
-		b.WriteString("2. Add your API key to\n   ")
-		b.WriteString(configPath)
-		b.WriteString("\n")
-	} else {
-		b.WriteString("1. Add your API key to\n   ")
-		b.WriteString(configPath)
-		b.WriteString("\n")
-	}
-	return b.String()
-}
-
-func recommendedBlock() string {
-	return "• OpenRouter: https://openrouter.ai/keys\n  (access 100+ models)\n\n" +
-		"• Ollama: https://ollama.com\n  (local, free)\n\n" +
-		"See README.md for 17+ supported providers."
-}
-
-func chatStep(encrypt bool) string {
-	if encrypt {
-		return "3. Chat:\n   picoclaw agent -m \"Hello!\""
-	}
-	return "2. Chat:\n   picoclaw agent -m \"Hello!\""
-}

cmd/picoclaw/internal/cliui/status.go

@@ -1,168 +0,0 @@
-package cliui
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-// ProviderRow holds one provider's display name and status value.
-type ProviderRow struct {
-	Name string
-	Val  string
-}
-
-// StatusReport is a structured status view for PrintStatus.
-type StatusReport struct {
-	Logo          string
-	Version       string
-	Build         string
-	ConfigPath    string
-	ConfigOK      bool
-	WorkspacePath string
-	WorkspaceOK   bool
-	Model         string
-	Providers     []ProviderRow
-	OAuthLines    []string // each full line "provider (method): state"
-}
-
-// PrintStatus renders picoclaw status (plain or fancy).
-func PrintStatus(r StatusReport) {
-	if !UseFancyLayout() {
-		printStatusPlain(r)
-		return
-	}
-	printStatusFancy(r)
-}
-
-func printStatusPlain(r StatusReport) {
-	fmt.Printf("%s picoclaw Status\n", r.Logo)
-	fmt.Printf("Version: %s\n", r.Version)
-	if r.Build != "" {
-		fmt.Printf("Build: %s\n", r.Build)
-	}
-	fmt.Println()
-
-	printPathLine("Config", r.ConfigPath, r.ConfigOK)
-	printPathLine("Workspace", r.WorkspacePath, r.WorkspaceOK)
-
-	if r.ConfigOK {
-		fmt.Printf("Model: %s\n", r.Model)
-		for _, p := range r.Providers {
-			fmt.Printf("%s: %s\n", p.Name, p.Val)
-		}
-		if len(r.OAuthLines) > 0 {
-			fmt.Println("\nOAuth/Token Auth:")
-			for _, line := range r.OAuthLines {
-				fmt.Printf("  %s\n", line)
-			}
-		}
-	}
-}
-
-func printPathLine(label, path string, ok bool) {
-	mark := "✗"
-	if ok {
-		mark = "✓"
-	}
-	fmt.Println(label+":", path, mark)
-}
-
-func printStatusFancy(r StatusReport) {
-	inner := InnerWidth()
-	topBox := borderStyle().Width(inner)
-
-	var head strings.Builder
-	head.WriteString(titleBarStyle().Render(r.Logo + " picoclaw Status"))
-	head.WriteString("\n\n")
-	head.WriteString(kvKeyStyle().Render("Version") + "  " + kvValStyle().Render(r.Version))
-	if r.Build != "" {
-		head.WriteString("\n")
-		head.WriteString(kvKeyStyle().Render("Build") + "     " + kvValStyle().Render(r.Build))
-	}
-	fmt.Println(topBox.Render(head.String()))
-	fmt.Println()
-
-	if UseColumnLayout() && len(r.Providers) > 0 && r.ConfigOK {
-		leftW := (inner - 2) / 2
-		rightW := inner - leftW - 2
-		pathsNarrow := pathStatusPanel(r, leftW)
-		prov := providerTablePanel(r, rightW)
-		gap := strings.Repeat(" ", 2)
-		fmt.Println(lipgloss.JoinHorizontal(lipgloss.Top, pathsNarrow, gap, prov))
-	} else {
-		fmt.Println(pathStatusPanel(r, inner))
-		if len(r.Providers) > 0 && r.ConfigOK {
-			fmt.Println(providerTablePanel(r, inner))
-		}
-	}
-
-	if len(r.OAuthLines) > 0 && r.ConfigOK {
-		var ob strings.Builder
-		ob.WriteString(titleBarStyle().Render("OAuth / token auth") + "\n\n")
-		for _, line := range r.OAuthLines {
-			ob.WriteString("  • " + line + "\n")
-		}
-		fmt.Println()
-		fmt.Println(borderStyle().Width(inner).Render(ob.String()))
-	}
-}
-
-func pathStatusPanel(r StatusReport, inner int) string {
-	cfgMark := statusMark(r.ConfigOK)
-	wsMark := statusMark(r.WorkspaceOK)
-	var b strings.Builder
-	b.WriteString(kvKeyStyle().Render("Config") + "\n")
-	b.WriteString(mutedStyle().Render(r.ConfigPath))
-	b.WriteString(" " + cfgMark + "\n\n")
-	b.WriteString(kvKeyStyle().Render("Workspace") + "\n")
-	b.WriteString(mutedStyle().Render(r.WorkspacePath))
-	b.WriteString(" " + wsMark + "\n")
-	if r.ConfigOK {
-		b.WriteString("\n")
-		b.WriteString(kvKeyStyle().Render("Model") + "  " + kvValStyle().Render(r.Model))
-	}
-	return borderStyle().Width(inner).Render(b.String())
-}
-
-func statusMark(ok bool) string {
-	if ok {
-		return lipgloss.NewStyle().Foreground(colorOK).Render("✓")
-	}
-	return lipgloss.NewStyle().Foreground(accentRed).Render("✗")
-}
-
-func providerTablePanel(r StatusReport, colW int) string {
-	if len(r.Providers) == 0 {
-		return ""
-	}
-	keyW := min(22, colW/3)
-	if keyW < 14 {
-		keyW = 14
-	}
-	valW := colW - keyW - 3
-	if valW < 12 {
-		valW = 12
-	}
-
-	var b strings.Builder
-	b.WriteString(titleBarStyle().Render("Providers & local") + "\n\n")
-	for _, p := range r.Providers {
-		k := lipgloss.NewStyle().Foreground(accentBlue).Bold(true).Width(keyW).Render(p.Name)
-		v := styleProviderVal(p.Val).Width(valW).Render(p.Val)
-		b.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, k, "  ", v))
-		b.WriteString("\n")
-	}
-	return borderStyle().Width(colW).Render(strings.TrimRight(b.String(), "\n"))
-}
-
-func styleProviderVal(s string) lipgloss.Style {
-	if s == "✓" || strings.HasPrefix(s, "✓ ") {
-		return lipgloss.NewStyle().Foreground(colorOK)
-	}
-	if s == "not set" {
-		return mutedStyle()
-	}
-	return lipgloss.NewStyle()
-}

cmd/picoclaw/internal/cliui/version.go

@@ -1,61 +0,0 @@
-package cliui
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/charmbracelet/lipgloss"
-)
-
-// PrintVersion prints version, optional build info, and Go toolchain line.
-func PrintVersion(logo, versionLine string, build, goVer string) {
-	if !UseFancyLayout() {
-		fmt.Printf("%s %s\n", logo, versionLine)
-		if build != "" {
-			fmt.Printf("  Build: %s\n", build)
-		}
-		if goVer != "" {
-			fmt.Printf("  Go: %s\n", goVer)
-		}
-		return
-	}
-
-	inner := InnerWidth()
-	box := borderStyle().Width(inner)
-
-	if UseColumnLayout() {
-		leftCol := kvKeyStyle().Width(12).Align(lipgloss.Right)
-		rightW := inner - 16
-		rightStyle := kvValStyle().Width(rightW)
-
-		rows := [][]string{
-			{leftCol.Render("Version"), rightStyle.Render(versionLine)},
-		}
-		if build != "" {
-			rows = append(rows, []string{leftCol.Render("Build"), rightStyle.Render(build)})
-		}
-		if goVer != "" {
-			rows = append(rows, []string{leftCol.Render("Go"), rightStyle.Render(goVer)})
-		}
-		var body strings.Builder
-		for _, r := range rows {
-			body.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, r[0], "  ", r[1]))
-			body.WriteString("\n")
-		}
-		header := titleBarStyle().Render(logo+" picoclaw") + "\n\n"
-		fmt.Println(box.Render(header + body.String()))
-		return
-	}
-
-	var lines []string
-	lines = append(lines, titleBarStyle().Render(logo+" picoclaw"))
-	lines = append(lines, "")
-	lines = append(lines, kvKeyStyle().Render("Version")+"  "+kvValStyle().Render(versionLine))
-	if build != "" {
-		lines = append(lines, kvKeyStyle().Render("Build")+"     "+kvValStyle().Render(build))
-	}
-	if goVer != "" {
-		lines = append(lines, kvKeyStyle().Render("Go")+"        "+kvValStyle().Render(goVer))
-	}
-	fmt.Println(box.Render(strings.Join(lines, "\n")))
-}

cmd/picoclaw/internal/cron/add.go

@@ -14,6 +14,7 @@ func newAddCommand(storePath func() string) *cobra.Command {
 		message string
 		every   int64
 		cronExp string
+		deliver bool
 		channel string
 		to      string
 	)
@@ -36,7 +37,7 @@ func newAddCommand(storePath func() string) *cobra.Command {
 			}
 
 			cs := cron.NewCronService(storePath(), nil)
-			job, err := cs.AddJob(name, schedule, message, channel, to)
+			job, err := cs.AddJob(name, schedule, message, deliver, channel, to)
 			if err != nil {
 				return fmt.Errorf("error adding job: %w", err)
 			}
@@ -51,6 +52,7 @@ func newAddCommand(storePath func() string) *cobra.Command {
 	cmd.Flags().StringVarP(&message, "message", "m", "", "Message for agent")
 	cmd.Flags().Int64VarP(&every, "every", "e", 0, "Run every N seconds")
 	cmd.Flags().StringVarP(&cronExp, "cron", "c", "", "Cron expression (e.g. '0 9 * * *')")
+	cmd.Flags().BoolVarP(&deliver, "deliver", "d", false, "Deliver response to channel")
 	cmd.Flags().StringVar(&to, "to", "", "Recipient for delivery")
 	cmd.Flags().StringVar(&channel, "channel", "", "Channel for delivery")
 

cmd/picoclaw/internal/cron/add_test.go

@@ -21,6 +21,7 @@ func TestNewAddSubcommand(t *testing.T) {
 
 	assert.NotNil(t, cmd.Flags().Lookup("every"))
 	assert.NotNil(t, cmd.Flags().Lookup("cron"))
+	assert.NotNil(t, cmd.Flags().Lookup("deliver"))
 	assert.NotNil(t, cmd.Flags().Lookup("to"))
 	assert.NotNil(t, cmd.Flags().Lookup("channel"))
 

cmd/picoclaw/internal/gateway/command.go

@@ -1,91 +1,23 @@
 package gateway
 
 import (
-	"fmt"
-	"os"
-
 	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/gateway"
-	"github.com/sipeed/picoclaw/pkg/logger"
-	"github.com/sipeed/picoclaw/pkg/netbind"
-	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
-func resolveGatewayHostOverride(explicit bool, host string) (string, error) {
-	if !explicit {
-		return "", nil
-	}
-	normalized, err := netbind.NormalizeHostInput(host)
-	if err != nil {
-		return "", fmt.Errorf("invalid --host value: %w", err)
-	}
-	return normalized, nil
-}
-
 func NewGatewayCommand() *cobra.Command {
 	var debug bool
-	var noTruncate bool
-	var allowEmpty bool
-	var host string
 
 	cmd := &cobra.Command{
 		Use:     "gateway",
 		Aliases: []string{"g"},
 		Short:   "Start picoclaw gateway",
 		Args:    cobra.NoArgs,
-		PreRunE: func(_ *cobra.Command, _ []string) error {
+		RunE: func(_ *cobra.Command, _ []string) error {
-			if noTruncate && !debug {
+			return gatewayCmd(debug)
-				return fmt.Errorf("the --no-truncate option can only be used in conjunction with --debug (-d)")
-			}
-
-			if noTruncate {
-				utils.SetDisableTruncation(true)
-				logger.Info("String truncation is globally disabled via 'no-truncate' flag")
-			}
-
-			return nil
-		},
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			resolvedHost, err := resolveGatewayHostOverride(cmd.Flags().Changed("host"), host)
-			if err != nil {
-				return err
-			}
-			if resolvedHost != "" {
-				prevHost, hadPrev := os.LookupEnv(config.EnvGatewayHost)
-				if err := os.Setenv(config.EnvGatewayHost, resolvedHost); err != nil {
-					return fmt.Errorf("failed to set %s: %w", config.EnvGatewayHost, err)
-				}
-				defer func() {
-					if hadPrev {
-						_ = os.Setenv(config.EnvGatewayHost, prevHost)
-						return
-					}
-					_ = os.Unsetenv(config.EnvGatewayHost)
-				}()
-			}
-
-			return gateway.Run(debug, internal.GetPicoclawHome(), internal.GetConfigPath(), allowEmpty)
 		},
 	}
 
 	cmd.Flags().BoolVarP(&debug, "debug", "d", false, "Enable debug logging")
-	cmd.Flags().BoolVarP(&noTruncate, "no-truncate", "T", false, "Disable string truncation in debug logs")
-	cmd.Flags().BoolVarP(
-		&allowEmpty,
-		"allow-empty",
-		"E",
-		false,
-		"Continue starting even when no default model is configured",
-	)
-	cmd.Flags().StringVar(
-		&host,
-		"host",
-		"",
-		"Host address for gateway binding (overrides gateway.host for this run)",
-	)
 
 	return cmd
 }

cmd/picoclaw/internal/gateway/command_test.go

@@ -28,39 +28,4 @@ func TestNewGatewayCommand(t *testing.T) {
 
 	assert.True(t, cmd.HasFlags())
 	assert.NotNil(t, cmd.Flags().Lookup("debug"))
-	assert.NotNil(t, cmd.Flags().Lookup("allow-empty"))
-	assert.NotNil(t, cmd.Flags().Lookup("host"))
-}
-
-func TestResolveGatewayHostOverride(t *testing.T) {
-	tests := []struct {
-		name     string
-		explicit bool
-		host     string
-		wantHost string
-		wantErr  bool
-	}{
-		{name: "implicit empty host is allowed", explicit: false, host: "", wantHost: "", wantErr: false},
-		{name: "explicit empty host rejected", explicit: true, host: "   ", wantHost: "", wantErr: true},
-		{name: "explicit localhost kept", explicit: true, host: " localhost ", wantHost: "localhost", wantErr: false},
-		{
-			name:     "explicit multi host normalized",
-			explicit: true,
-			host:     " [::1] , 127.0.0.1 ",
-			wantHost: "::1,127.0.0.1",
-			wantErr:  false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := resolveGatewayHostOverride(tt.explicit, tt.host)
-			if (err != nil) != tt.wantErr {
-				t.Fatalf("resolveGatewayHostOverride() err = %v, wantErr %t", err, tt.wantErr)
-			}
-			if got != tt.wantHost {
-				t.Fatalf("resolveGatewayHostOverride() host = %q, want %q", got, tt.wantHost)
-			}
-		})
-	}
 }

cmd/picoclaw/internal/gateway/helpers.go

@@ -0,0 +1,235 @@
+package gateway
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"time"
+
+	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
+	"github.com/sipeed/picoclaw/pkg/agent"
+	"github.com/sipeed/picoclaw/pkg/bus"
+	"github.com/sipeed/picoclaw/pkg/channels"
+	_ "github.com/sipeed/picoclaw/pkg/channels/dingtalk"
+	_ "github.com/sipeed/picoclaw/pkg/channels/discord"
+	_ "github.com/sipeed/picoclaw/pkg/channels/feishu"
+	_ "github.com/sipeed/picoclaw/pkg/channels/line"
+	_ "github.com/sipeed/picoclaw/pkg/channels/maixcam"
+	_ "github.com/sipeed/picoclaw/pkg/channels/onebot"
+	_ "github.com/sipeed/picoclaw/pkg/channels/pico"
+	_ "github.com/sipeed/picoclaw/pkg/channels/qq"
+	_ "github.com/sipeed/picoclaw/pkg/channels/slack"
+	_ "github.com/sipeed/picoclaw/pkg/channels/telegram"
+	_ "github.com/sipeed/picoclaw/pkg/channels/wecom"
+	_ "github.com/sipeed/picoclaw/pkg/channels/whatsapp"
+	_ "github.com/sipeed/picoclaw/pkg/channels/whatsapp_native"
+	"github.com/sipeed/picoclaw/pkg/config"
+	"github.com/sipeed/picoclaw/pkg/cron"
+	"github.com/sipeed/picoclaw/pkg/devices"
+	"github.com/sipeed/picoclaw/pkg/health"
+	"github.com/sipeed/picoclaw/pkg/heartbeat"
+	"github.com/sipeed/picoclaw/pkg/logger"
+	"github.com/sipeed/picoclaw/pkg/media"
+	"github.com/sipeed/picoclaw/pkg/providers"
+	"github.com/sipeed/picoclaw/pkg/state"
+	"github.com/sipeed/picoclaw/pkg/tools"
+)
+
+func gatewayCmd(debug bool) error {
+	if debug {
+		logger.SetLevel(logger.DEBUG)
+		fmt.Println("🔍 Debug mode enabled")
+	}
+
+	cfg, err := internal.LoadConfig()
+	if err != nil {
+		return fmt.Errorf("error loading config: %w", err)
+	}
+
+	provider, modelID, err := providers.CreateProvider(cfg)
+	if err != nil {
+		return fmt.Errorf("error creating provider: %w", err)
+	}
+
+	// Use the resolved model ID from provider creation
+	if modelID != "" {
+		cfg.Agents.Defaults.ModelName = modelID
+	}
+
+	msgBus := bus.NewMessageBus()
+	agentLoop := agent.NewAgentLoop(cfg, msgBus, provider)
+
+	// Print agent startup info
+	fmt.Println("\n📦 Agent Status:")
+	startupInfo := agentLoop.GetStartupInfo()
+	toolsInfo := startupInfo["tools"].(map[string]any)
+	skillsInfo := startupInfo["skills"].(map[string]any)
+	fmt.Printf("  • Tools: %d loaded\n", toolsInfo["count"])
+	fmt.Printf("  • Skills: %d/%d available\n",
+		skillsInfo["available"],
+		skillsInfo["total"])
+
+	// Log to file as well
+	logger.InfoCF("agent", "Agent initialized",
+		map[string]any{
+			"tools_count":      toolsInfo["count"],
+			"skills_total":     skillsInfo["total"],
+			"skills_available": skillsInfo["available"],
+		})
+
+	// Setup cron tool and service
+	execTimeout := time.Duration(cfg.Tools.Cron.ExecTimeoutMinutes) * time.Minute
+	cronService := setupCronTool(
+		agentLoop,
+		msgBus,
+		cfg.WorkspacePath(),
+		cfg.Agents.Defaults.RestrictToWorkspace,
+		execTimeout,
+		cfg,
+	)
+
+	heartbeatService := heartbeat.NewHeartbeatService(
+		cfg.WorkspacePath(),
+		cfg.Heartbeat.Interval,
+		cfg.Heartbeat.Enabled,
+	)
+	heartbeatService.SetBus(msgBus)
+	heartbeatService.SetHandler(func(prompt, channel, chatID string) *tools.ToolResult {
+		// Use cli:direct as fallback if no valid channel
+		if channel == "" || chatID == "" {
+			channel, chatID = "cli", "direct"
+		}
+		// Use ProcessHeartbeat - no session history, each heartbeat is independent
+		var response string
+		response, err = agentLoop.ProcessHeartbeat(context.Background(), prompt, channel, chatID)
+		if err != nil {
+			return tools.ErrorResult(fmt.Sprintf("Heartbeat error: %v", err))
+		}
+		if response == "HEARTBEAT_OK" {
+			return tools.SilentResult("Heartbeat OK")
+		}
+		// For heartbeat, always return silent - the subagent result will be
+		// sent to user via processSystemMessage when the async task completes
+		return tools.SilentResult(response)
+	})
+
+	// Create media store for file lifecycle management with TTL cleanup
+	mediaStore := media.NewFileMediaStoreWithCleanup(media.MediaCleanerConfig{
+		Enabled:  cfg.Tools.MediaCleanup.Enabled,
+		MaxAge:   time.Duration(cfg.Tools.MediaCleanup.MaxAge) * time.Minute,
+		Interval: time.Duration(cfg.Tools.MediaCleanup.Interval) * time.Minute,
+	})
+	mediaStore.Start()
+
+	channelManager, err := channels.NewManager(cfg, msgBus, mediaStore)
+	if err != nil {
+		mediaStore.Stop()
+		return fmt.Errorf("error creating channel manager: %w", err)
+	}
+
+	// Inject channel manager and media store into agent loop
+	agentLoop.SetChannelManager(channelManager)
+	agentLoop.SetMediaStore(mediaStore)
+
+	enabledChannels := channelManager.GetEnabledChannels()
+	if len(enabledChannels) > 0 {
+		fmt.Printf("✓ Channels enabled: %s\n", enabledChannels)
+	} else {
+		fmt.Println("⚠ Warning: No channels enabled")
+	}
+
+	fmt.Printf("✓ Gateway started on %s:%d\n", cfg.Gateway.Host, cfg.Gateway.Port)
+	fmt.Println("Press Ctrl+C to stop")
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	if err := cronService.Start(); err != nil {
+		fmt.Printf("Error starting cron service: %v\n", err)
+	}
+	fmt.Println("✓ Cron service started")
+
+	if err := heartbeatService.Start(); err != nil {
+		fmt.Printf("Error starting heartbeat service: %v\n", err)
+	}
+	fmt.Println("✓ Heartbeat service started")
+
+	stateManager := state.NewManager(cfg.WorkspacePath())
+	deviceService := devices.NewService(devices.Config{
+		Enabled:    cfg.Devices.Enabled,
+		MonitorUSB: cfg.Devices.MonitorUSB,
+	}, stateManager)
+	deviceService.SetBus(msgBus)
+	if err := deviceService.Start(ctx); err != nil {
+		fmt.Printf("Error starting device service: %v\n", err)
+	} else if cfg.Devices.Enabled {
+		fmt.Println("✓ Device event service started")
+	}
+
+	// Setup shared HTTP server with health endpoints and webhook handlers
+	healthServer := health.NewServer(cfg.Gateway.Host, cfg.Gateway.Port)
+	addr := fmt.Sprintf("%s:%d", cfg.Gateway.Host, cfg.Gateway.Port)
+	channelManager.SetupHTTPServer(addr, healthServer)
+
+	if err := channelManager.StartAll(ctx); err != nil {
+		fmt.Printf("Error starting channels: %v\n", err)
+	}
+
+	fmt.Printf("✓ Health endpoints available at http://%s:%d/health and /ready\n", cfg.Gateway.Host, cfg.Gateway.Port)
+
+	go agentLoop.Run(ctx)
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, os.Interrupt)
+	<-sigChan
+
+	fmt.Println("\nShutting down...")
+	if cp, ok := provider.(providers.StatefulProvider); ok {
+		cp.Close()
+	}
+	cancel()
+	msgBus.Close()
+
+	// Use a fresh context with timeout for graceful shutdown,
+	// since the original ctx is already canceled.
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer shutdownCancel()
+
+	channelManager.StopAll(shutdownCtx)
+	deviceService.Stop()
+	heartbeatService.Stop()
+	cronService.Stop()
+	mediaStore.Stop()
+	agentLoop.Stop()
+	fmt.Println("✓ Gateway stopped")
+
+	return nil
+}
+
+func setupCronTool(
+	agentLoop *agent.AgentLoop,
+	msgBus *bus.MessageBus,
+	workspace string,
+	restrict bool,
+	execTimeout time.Duration,
+	cfg *config.Config,
+) *cron.CronService {
+	cronStorePath := filepath.Join(workspace, "cron", "jobs.json")
+
+	// Create cron service
+	cronService := cron.NewCronService(cronStorePath, nil)
+
+	// Create and register CronTool
+	cronTool := tools.NewCronTool(cronService, agentLoop, msgBus, workspace, restrict, execTimeout, cfg)
+	agentLoop.RegisterTool(cronTool)
+
+	// Set the onJob handler
+	cronService.SetOnJob(func(job *cron.CronJob) (string, error) {
+		result := cronTool.ExecuteJob(context.Background(), job)
+		return result, nil
+	})
+
+	return cronService
+}

cmd/picoclaw/internal/helpers.go

@@ -1,52 +1,52 @@
 package internal
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 
-	"github.com/sipeed/picoclaw/pkg"
 	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/logger"
 )
 
-const Logo = pkg.Logo
+const Logo = "🦞"
 
-// GetPicoclawHome returns the picoclaw home directory.
+var (
-// Priority: $PICOCLAW_HOME > ~/.picoclaw
+	version   = "dev"
-func GetPicoclawHome() string {
+	gitCommit string
-	return config.GetHome()
+	buildTime string
-}
+	goVersion string
+)
 
 func GetConfigPath() string {
-	if configPath := os.Getenv(config.EnvConfig); configPath != "" {
+	home, _ := os.UserHomeDir()
-		return configPath
+	return filepath.Join(home, ".picoclaw", "config.json")
-	}
-	return filepath.Join(GetPicoclawHome(), "config.json")
 }
 
 func LoadConfig() (*config.Config, error) {
-	cfg, err := config.LoadConfig(GetConfigPath())
+	return config.LoadConfig(GetConfigPath())
-	if err != nil {
-		return nil, err
-	}
-	logger.SetLevelFromString(cfg.Gateway.LogLevel)
-	return cfg, nil
 }
 
 // FormatVersion returns the version string with optional git commit
-// Deprecated: Use pkg/config.FormatVersion instead
 func FormatVersion() string {
-	return config.FormatVersion()
+	v := version
+	if gitCommit != "" {
+		v += fmt.Sprintf(" (git: %s)", gitCommit)
+	}
+	return v
 }
 
 // FormatBuildInfo returns build time and go version info
-// Deprecated: Use pkg/config.FormatBuildInfo instead
 func FormatBuildInfo() (string, string) {
-	return config.FormatBuildInfo()
+	build := buildTime
+	goVer := goVersion
+	if goVer == "" {
+		goVer = runtime.Version()
+	}
+	return build, goVer
 }
 
 // GetVersion returns the version string
-// Deprecated: Use pkg/config.GetVersion instead
 func GetVersion() string {
-	return config.GetVersion()
+	return version
 }

cmd/picoclaw/internal/helpers_test.go

@@ -8,8 +8,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/sipeed/picoclaw/pkg/config"
 )
 
 func TestGetConfigPath(t *testing.T) {
@@ -21,25 +19,63 @@ func TestGetConfigPath(t *testing.T) {
 	assert.Equal(t, want, got)
 }
 
-func TestGetConfigPath_WithPICOCLAW_HOME(t *testing.T) {
+func TestFormatVersion_NoGitCommit(t *testing.T) {
-	t.Setenv(config.EnvHome, "/custom/picoclaw")
+	oldVersion, oldGit := version, gitCommit
-	t.Setenv("HOME", "/tmp/home")
+	t.Cleanup(func() { version, gitCommit = oldVersion, oldGit })
 
-	got := GetConfigPath()
+	version = "1.2.3"
-	want := filepath.Join("/custom/picoclaw", "config.json")
+	gitCommit = ""
 
-	assert.Equal(t, want, got)
+	assert.Equal(t, "1.2.3", FormatVersion())
 }
 
-func TestGetConfigPath_WithPICOCLAW_CONFIG(t *testing.T) {
+func TestFormatVersion_WithGitCommit(t *testing.T) {
-	t.Setenv("PICOCLAW_CONFIG", "/custom/config.json")
+	oldVersion, oldGit := version, gitCommit
-	t.Setenv(config.EnvHome, "/custom/picoclaw")
+	t.Cleanup(func() { version, gitCommit = oldVersion, oldGit })
-	t.Setenv("HOME", "/tmp/home")
 
-	got := GetConfigPath()
+	version = "1.2.3"
-	want := "/custom/config.json"
+	gitCommit = "abc123"
 
-	assert.Equal(t, want, got)
+	assert.Equal(t, "1.2.3 (git: abc123)", FormatVersion())
+}
+
+func TestFormatBuildInfo_UsesBuildTimeAndGoVersion_WhenSet(t *testing.T) {
+	oldBuildTime, oldGoVersion := buildTime, goVersion
+	t.Cleanup(func() { buildTime, goVersion = oldBuildTime, oldGoVersion })
+
+	buildTime = "2026-02-20T00:00:00Z"
+	goVersion = "go1.23.0"
+
+	build, goVer := FormatBuildInfo()
+
+	assert.Equal(t, buildTime, build)
+	assert.Equal(t, goVersion, goVer)
+}
+
+func TestFormatBuildInfo_EmptyBuildTime_ReturnsEmptyBuild(t *testing.T) {
+	oldBuildTime, oldGoVersion := buildTime, goVersion
+	t.Cleanup(func() { buildTime, goVersion = oldBuildTime, oldGoVersion })
+
+	buildTime = ""
+	goVersion = "go1.23.0"
+
+	build, goVer := FormatBuildInfo()
+
+	assert.Empty(t, build)
+	assert.Equal(t, goVersion, goVer)
+}
+
+func TestFormatBuildInfo_EmptyGoVersion_FallsBackToRuntimeVersion(t *testing.T) {
+	oldBuildTime, oldGoVersion := buildTime, goVersion
+	t.Cleanup(func() { buildTime, goVersion = oldBuildTime, oldGoVersion })
+
+	buildTime = "x"
+	goVersion = ""
+
+	build, goVer := FormatBuildInfo()
+
+	assert.Equal(t, "x", build)
+	assert.Equal(t, runtime.Version(), goVer)
 }
 
 func TestGetConfigPath_Windows(t *testing.T) {
@@ -55,3 +91,7 @@ func TestGetConfigPath_Windows(t *testing.T) {
 
 	require.True(t, strings.EqualFold(got, want), "GetConfigPath() = %q, want %q", got, want)
 }
+
+func TestGetVersion(t *testing.T) {
+	assert.Equal(t, "dev", GetVersion())
+}

cmd/picoclaw/internal/mcp/add.go

@@ -1,249 +0,0 @@
-package mcp
-
-import (
-	"fmt"
-	"net/url"
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-type addOptions struct {
-	Env       []string
-	EnvFile   string
-	Headers   []string
-	Transport string
-	Force     bool
-	Deferred  *bool // nil = not set, true = deferred, false = not deferred
-}
-
-func newAddCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:                "add [flags] <name> <command-or-url> [args...]",
-		Short:              "Add or update an MCP server",
-		DisableFlagParsing: true,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			opts, name, target, targetArgs, showHelp, err := parseAddArgs(args)
-			if showHelp {
-				return cmd.Help()
-			}
-			if err != nil {
-				return err
-			}
-
-			cfg, err := loadConfig()
-			if err != nil {
-				return err
-			}
-			if cfg.Tools.MCP.Servers == nil {
-				cfg.Tools.MCP.Servers = make(map[string]config.MCPServerConfig)
-			}
-
-			if _, exists := cfg.Tools.MCP.Servers[name]; exists && !opts.Force {
-				var overwrite bool
-
-				overwrite, err = confirmOverwrite(cmd.InOrStdin(), cmd.OutOrStdout(), name)
-				if err != nil {
-					return fmt.Errorf("failed to confirm overwrite: %w", err)
-				}
-				if !overwrite {
-					return fmt.Errorf("aborted: MCP server %q already exists", name)
-				}
-			}
-
-			server, err := buildServerConfig(target, targetArgs, opts)
-			if err != nil {
-				return err
-			}
-
-			cfg.Tools.MCP.Enabled = true
-			cfg.Tools.MCP.Servers[name] = server
-
-			if err := saveValidatedConfig(cfg); err != nil {
-				return err
-			}
-
-			fmt.Fprintf(cmd.OutOrStdout(), "✓ MCP server %q saved.\n", name)
-			return nil
-		},
-	}
-
-	flags := cmd.Flags()
-	flags.StringArrayP("env", "e", nil, "Environment variable in KEY=value format (repeatable, saved to config)")
-	flags.String("env-file", "", "Path to an env file for stdio servers (recommended for secrets)")
-	flags.StringArrayP("header", "H", nil, "HTTP header in 'Name: Value' or 'Name=Value' format (repeatable)")
-	flags.StringP("transport", "t", "stdio", "Transport type: stdio, http / streamable-http, or sse")
-	flags.BoolP("force", "f", false, "Overwrite an existing server without prompting")
-	flags.Bool("deferred", false, "Mark server as deferred (tools hidden until explicitly activated)")
-	flags.Bool("no-deferred", false, "Mark server as non-deferred (tools always active)")
-
-	return cmd
-}
-
-func parseAddArgs(args []string) (addOptions, string, string, []string, bool, error) {
-	opts := addOptions{Transport: "stdio"}
-	var positional []string
-	serverArgs := make([]string, 0)
-	explicitCommand := make([]string, 0)
-
-	for i := 0; i < len(args); i++ {
-		arg := args[i]
-
-		switch {
-		case arg == "--help" || arg == "-h":
-			return addOptions{}, "", "", nil, true, nil
-		case arg == "--":
-			if i+1 < len(args) {
-				explicitCommand = append(explicitCommand, args[i+1:]...)
-			}
-			i = len(args)
-		case arg == "--force" || arg == "-f":
-			opts.Force = true
-		case arg == "--deferred":
-			t := true
-			opts.Deferred = &t
-		case arg == "--no-deferred":
-			f := false
-			opts.Deferred = &f
-		case arg == "--transport" || arg == "-t":
-			if i+1 >= len(args) {
-				return addOptions{}, "", "", nil, false, fmt.Errorf("missing value for %s", arg)
-			}
-			i++
-			opts.Transport = args[i]
-		case strings.HasPrefix(arg, "--transport="):
-			opts.Transport = strings.TrimPrefix(arg, "--transport=")
-		case arg == "--env" || arg == "-e":
-			if i+1 >= len(args) {
-				return addOptions{}, "", "", nil, false, fmt.Errorf("missing value for %s", arg)
-			}
-			i++
-			opts.Env = append(opts.Env, args[i])
-		case arg == "--env-file":
-			if i+1 >= len(args) {
-				return addOptions{}, "", "", nil, false, fmt.Errorf("missing value for %s", arg)
-			}
-			i++
-			opts.EnvFile = args[i]
-		case strings.HasPrefix(arg, "--env="):
-			opts.Env = append(opts.Env, strings.TrimPrefix(arg, "--env="))
-		case strings.HasPrefix(arg, "--env-file="):
-			opts.EnvFile = strings.TrimPrefix(arg, "--env-file=")
-		case arg == "--header" || arg == "-H":
-			if i+1 >= len(args) {
-				return addOptions{}, "", "", nil, false, fmt.Errorf("missing value for %s", arg)
-			}
-			i++
-			opts.Headers = append(opts.Headers, args[i])
-		case strings.HasPrefix(arg, "--header="):
-			opts.Headers = append(opts.Headers, strings.TrimPrefix(arg, "--header="))
-		case strings.HasPrefix(arg, "-") && len(positional) >= 2:
-			serverArgs = append(serverArgs, args[i:]...)
-			i = len(args)
-		default:
-			positional = append(positional, arg)
-		}
-	}
-
-	if len(explicitCommand) > 0 {
-		if len(positional) != 1 {
-			return addOptions{}, "", "", nil, false, fmt.Errorf(
-				"usage: picoclaw mcp add [flags] <name> <command-or-url> [args...] or picoclaw mcp add [flags] <name> -- <command> [args...]",
-			)
-		}
-		if len(explicitCommand) == 0 {
-			return addOptions{}, "", "", nil, false, fmt.Errorf("missing stdio command after --")
-		}
-		return opts, positional[0], explicitCommand[0], explicitCommand[1:], false, nil
-	}
-
-	if len(positional) < 2 {
-		return addOptions{}, "", "", nil, false, fmt.Errorf(
-			"usage: picoclaw mcp add [flags] <name> <command-or-url> [args...] or picoclaw mcp add [flags] <name> -- <command> [args...]",
-		)
-	}
-
-	targetArgs := make([]string, 0, len(positional)-2+len(serverArgs))
-	targetArgs = append(targetArgs, positional[2:]...)
-	targetArgs = append(targetArgs, serverArgs...)
-
-	return opts, positional[0], positional[1], targetArgs, false, nil
-}
-
-func buildServerConfig(target string, args []string, opts addOptions) (config.MCPServerConfig, error) {
-	transport := config.NormalizeMCPTransportType(opts.Transport)
-	if transport == "" {
-		transport = "stdio"
-	}
-	switch transport {
-	case "stdio", "http", "sse":
-	default:
-		return config.MCPServerConfig{}, fmt.Errorf("unsupported transport %q", opts.Transport)
-	}
-
-	env, err := parseEnvAssignments(opts.Env)
-	if err != nil {
-		return config.MCPServerConfig{}, err
-	}
-	headers, err := parseHeaderAssignments(opts.Headers)
-	if err != nil {
-		return config.MCPServerConfig{}, err
-	}
-
-	server := config.MCPServerConfig{
-		Enabled:  true,
-		Type:     transport,
-		Deferred: opts.Deferred,
-	}
-
-	switch transport {
-	case "http", "sse":
-		if len(env) > 0 {
-			return config.MCPServerConfig{}, fmt.Errorf("--env can only be used with stdio transport")
-		}
-		if strings.TrimSpace(opts.EnvFile) != "" {
-			return config.MCPServerConfig{}, fmt.Errorf("--env-file can only be used with stdio transport")
-		}
-		if len(args) > 0 {
-			return config.MCPServerConfig{}, fmt.Errorf("%s transport does not accept command arguments", transport)
-		}
-		parsedURL, err := url.ParseRequestURI(target)
-		if err != nil || parsedURL.Scheme == "" || parsedURL.Host == "" {
-			return config.MCPServerConfig{}, fmt.Errorf("invalid MCP URL %q", target)
-		}
-		server.URL = target
-		server.Headers = headers
-		return server, nil
-	}
-
-	if len(headers) > 0 {
-		return config.MCPServerConfig{}, fmt.Errorf("--header can only be used with http or sse transport")
-	}
-
-	if looksLikeRemoteURL(target) {
-		return config.MCPServerConfig{}, fmt.Errorf(
-			"target %q looks like a remote MCP URL, but transport is %q. Use --transport http or --transport sse",
-			target,
-			transport,
-		)
-	}
-
-	command := target
-	commandArgs := append([]string(nil), args...)
-
-	if err := validateLocalCommandPath(target); err != nil {
-		return config.MCPServerConfig{}, err
-	}
-	if isLocalCommandPath(command) {
-		command = expandHomePath(command)
-	}
-
-	server.Command = command
-	server.Args = commandArgs
-	server.Env = env
-	server.EnvFile = strings.TrimSpace(opts.EnvFile)
-
-	return server, nil
-}

cmd/picoclaw/internal/mcp/command.go

@@ -1,25 +0,0 @@
-package mcp
-
-import "github.com/spf13/cobra"
-
-func NewMCPCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "mcp",
-		Short: "Manage MCP server configuration",
-		Args:  cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			return cmd.Help()
-		},
-	}
-
-	cmd.AddCommand(
-		newAddCommand(),
-		newRemoveCommand(),
-		newListCommand(),
-		newEditCommand(),
-		newTestCommand(),
-		newShowCommand(),
-	)
-
-	return cmd
-}

cmd/picoclaw/internal/mcp/command_test.go

@@ -1,660 +0,0 @@
-package mcp
-
-import (
-	"bytes"
-	"context"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"slices"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-func TestNewMCPCommand(t *testing.T) {
-	cmd := NewMCPCommand()
-
-	require.NotNil(t, cmd)
-
-	assert.Equal(t, "mcp", cmd.Use)
-	assert.Equal(t, "Manage MCP server configuration", cmd.Short)
-	assert.True(t, cmd.HasSubCommands())
-
-	allowedCommands := []string{
-		"add",
-		"remove",
-		"list",
-		"edit",
-		"test",
-		"show",
-	}
-
-	subcommands := cmd.Commands()
-	assert.Len(t, subcommands, len(allowedCommands))
-
-	for _, subcmd := range subcommands {
-		found := slices.Contains(allowedCommands, subcmd.Name())
-		assert.True(t, found, "unexpected subcommand %q", subcmd.Name())
-		assert.False(t, subcmd.Hidden)
-	}
-}
-
-func TestMCPAddAddsGenericStdioServer(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{
-		"add",
-		"sqlite",
-		"npx",
-		"-y",
-		"@modelcontextprotocol/server-sqlite",
-		"--db",
-		"./mydb.db",
-	}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, `MCP server "sqlite" saved`)
-
-	cfg := readMCPConfig(t, configPath)
-	require.True(t, cfg.Tools.MCP.Enabled)
-
-	server, ok := cfg.Tools.MCP.Servers["sqlite"]
-	require.True(t, ok)
-	assert.True(t, server.Enabled)
-	assert.Equal(t, "stdio", server.Type)
-	assert.Equal(t, "npx", server.Command)
-	assert.Equal(t, []string{"-y", "@modelcontextprotocol/server-sqlite", "--db", "./mydb.db"}, server.Args)
-}
-
-func TestMCPAddSupportsHeadersAfterURL(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"apify",
-		"https://mcp.apify.com/",
-		"-t",
-		"http",
-		"--header",
-		"Authorization: Bearer OMITTED",
-	}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["apify"]
-	assert.Equal(t, "http", server.Type)
-	assert.Equal(t, "https://mcp.apify.com/", server.URL)
-	assert.Equal(t, map[string]string{"Authorization": "Bearer OMITTED"}, server.Headers)
-}
-
-func TestMCPAddSupportsTransportBeforeName(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"--transport",
-		"sse",
-		"fiscal-ai",
-		"https://api.fiscal.ai/mcp/sse",
-	}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["fiscal-ai"]
-	assert.Equal(t, "sse", server.Type)
-	assert.Equal(t, "https://api.fiscal.ai/mcp/sse", server.URL)
-}
-
-func TestMCPAddSupportsExplicitStdioCommandAfterSeparator(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"--transport",
-		"stdio",
-		"--env",
-		"AIRTABLE_API_KEY=YOUR_KEY",
-		"airtable",
-		"--",
-		"npx",
-		"-y",
-		"airtable-mcp-server",
-	}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["airtable"]
-	assert.Equal(t, "stdio", server.Type)
-	assert.Equal(t, "npx", server.Command)
-	assert.Equal(t, []string{"-y", "airtable-mcp-server"}, server.Args)
-	assert.Equal(t, map[string]string{"AIRTABLE_API_KEY": "YOUR_KEY"}, server.Env)
-}
-
-func TestMCPAddSupportsEnvFileForStdio(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"--env-file",
-		".env.mcp",
-		"filesystem",
-		"npx",
-		"-y",
-		"@modelcontextprotocol/server-filesystem",
-	}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["filesystem"]
-	assert.Equal(t, "stdio", server.Type)
-	assert.Equal(t, "npx", server.Command)
-	assert.Equal(t, []string{"-y", "@modelcontextprotocol/server-filesystem"}, server.Args)
-	assert.Equal(t, ".env.mcp", server.EnvFile)
-}
-
-func TestMCPAddRejectsEnvFileForHTTP(t *testing.T) {
-	setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"--transport",
-		"http",
-		"--env-file",
-		".env.mcp",
-		"context7",
-		"https://mcp.context7.com/mcp",
-	}, "")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "--env-file can only be used with stdio transport")
-}
-
-func TestMCPAddRejectsNonExecutableLocalCommand(t *testing.T) {
-	setupMCPConfigEnv(t)
-
-	tmpDir := t.TempDir()
-	localCmd := filepath.Join(tmpDir, "server.sh")
-	require.NoError(t, os.WriteFile(localCmd, []byte("#!/bin/sh\nexit 0\n"), 0o644))
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "local", localCmd}, "")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "not executable")
-}
-
-func TestMCPAddExpandsHomeInSavedLocalCommand(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	homeDir := t.TempDir()
-	t.Setenv("HOME", homeDir)
-	t.Setenv("USERPROFILE", homeDir)
-
-	localCmd := filepath.Join(homeDir, "bin", "my-mcp")
-	require.NoError(t, os.MkdirAll(filepath.Dir(localCmd), 0o755))
-	require.NoError(t, os.WriteFile(localCmd, []byte("#!/bin/sh\nexit 0\n"), 0o755))
-
-	tildeCmd := "~" + string(os.PathSeparator) + filepath.Join("bin", "my-mcp")
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "local-home", tildeCmd}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["local-home"]
-	assert.Equal(t, localCmd, server.Command)
-}
-
-func TestMCPAddShowsClearErrorForRemoteURLWithoutTransport(t *testing.T) {
-	setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "apify", "https://mcp.apify.com/"}, "")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), `looks like a remote MCP URL`)
-	assert.Contains(t, err.Error(), `Use --transport http or --transport sse`)
-}
-
-func TestMCPAddOverwritePromptDecline(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"filesystem": {
-						Enabled: true,
-						Type:    "stdio",
-						Command: "old",
-					},
-				},
-			},
-		},
-	})
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"add", "filesystem", "new-command"}, "n\n")
-	require.Error(t, err)
-	assert.Contains(t, output, `Overwrite? [y/N]:`)
-	assert.Contains(t, err.Error(), "aborted")
-
-	cfg := readMCPConfig(t, configPath)
-	assert.Equal(t, "old", cfg.Tools.MCP.Servers["filesystem"].Command)
-}
-
-func TestMCPAddOverwriteWithConfirmation(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"filesystem": {
-						Enabled: true,
-						Type:    "stdio",
-						Command: "old",
-					},
-				},
-			},
-		},
-	})
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "filesystem", "new-command"}, "y\n")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	assert.Equal(t, "new-command", cfg.Tools.MCP.Servers["filesystem"].Command)
-}
-
-func TestMCPAddHTTPServer(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"context7",
-		"--transport",
-		"http",
-		"https://mcp.context7.com/mcp",
-	}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["context7"]
-	assert.Equal(t, "http", server.Type)
-	assert.Equal(t, "https://mcp.context7.com/mcp", server.URL)
-	assert.Empty(t, server.Command)
-}
-
-func TestMCPAddSupportsStreamableHTTPAlias(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{
-		"add",
-		"context7",
-		"--transport",
-		"streamable-http",
-		"https://mcp.context7.com/mcp",
-	}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["context7"]
-	assert.Equal(t, "http", server.Type)
-	assert.Equal(t, "https://mcp.context7.com/mcp", server.URL)
-}
-
-func TestSaveValidatedConfigNormalizesStreamableHTTPAlias(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cfg := config.DefaultConfig()
-	cfg.Tools.MCP.Enabled = true
-	cfg.Tools.MCP.Servers = map[string]config.MCPServerConfig{
-		"context7": {
-			Enabled: true,
-			Type:    "streamable-http",
-			URL:     "https://mcp.context7.com/mcp",
-		},
-	}
-
-	require.NoError(t, saveValidatedConfig(cfg))
-
-	saved := readMCPConfig(t, configPath)
-	server := saved.Tools.MCP.Servers["context7"]
-	assert.Equal(t, "http", server.Type)
-	assert.Equal(t, "https://mcp.context7.com/mcp", server.URL)
-	assert.Equal(t, "streamable-http", cfg.Tools.MCP.Servers["context7"].Type)
-}
-
-func TestMCPRemoveRemovesLastServerAndDisablesMCP(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"filesystem": {
-						Enabled: true,
-						Type:    "stdio",
-						Command: "npx",
-					},
-				},
-			},
-		},
-	})
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"remove", "filesystem"}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, `MCP server "filesystem" removed`)
-
-	cfg := readMCPConfig(t, configPath)
-	assert.False(t, cfg.Tools.MCP.Enabled)
-	assert.Empty(t, cfg.Tools.MCP.Servers)
-}
-
-func TestMCPListPrintsTable(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"context7": {
-						Enabled: true,
-						Type:    "http",
-						URL:     "https://mcp.context7.com/mcp",
-					},
-					"filesystem": {
-						Enabled: false,
-						Type:    "stdio",
-						Command: "npx",
-						Args:    []string{"-y", "@modelcontextprotocol/server-filesystem", "/tmp"},
-					},
-				},
-			},
-		},
-	})
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"list"}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, "| Name")
-	assert.Contains(t, output, "context7")
-	assert.Contains(t, output, "filesystem")
-	assert.Contains(t, output, "https://mcp.context7.com/mcp")
-	assert.Contains(t, output, "disabled")
-}
-
-func TestMCPListWithStatusUsesProbe(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"filesystem": {
-						Enabled: true,
-						Type:    "stdio",
-						Command: "npx",
-					},
-				},
-			},
-		},
-	})
-
-	originalProbe := serverProbe
-	defer func() { serverProbe = originalProbe }()
-	serverProbe = func(_ context.Context, name string, server config.MCPServerConfig, workspacePath string) (probeResult, error) {
-		assert.Equal(t, "filesystem", name)
-		assert.Equal(t, readMCPConfig(t, configPath).WorkspacePath(), workspacePath)
-		assert.Equal(t, "npx", server.Command)
-		return probeResult{ToolCount: 3}, nil
-	}
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"list", "--status"}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, "ok (3 tools)")
-}
-
-func TestMCPEditUsesEditor(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	originalEditor := editorCommand
-	defer func() { editorCommand = originalEditor }()
-
-	var gotName string
-	var gotArgs []string
-	editorCommand = func(name string, args ...string) *exec.Cmd {
-		gotName = name
-		gotArgs = append([]string(nil), args...)
-		return exec.Command("sh", "-c", "exit 0")
-	}
-
-	t.Setenv("EDITOR", `dummy-editor --wait`)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"edit"}, "")
-	require.NoError(t, err)
-
-	assert.Equal(t, "dummy-editor", gotName)
-	assert.Equal(t, []string{"--wait", configPath}, gotArgs)
-	_, statErr := os.Stat(configPath)
-	assert.NoError(t, statErr)
-}
-
-func TestMCPEditRequiresEditor(t *testing.T) {
-	setupMCPConfigEnv(t)
-	t.Setenv("EDITOR", "")
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"edit"}, "")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "$EDITOR is not set")
-}
-
-func TestMCPTestUsesProbe(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"filesystem": {
-						Enabled: false,
-						Type:    "stdio",
-						Command: "npx",
-					},
-				},
-			},
-		},
-	})
-
-	originalProbe := serverProbe
-	defer func() { serverProbe = originalProbe }()
-	serverProbe = func(_ context.Context, name string, _ config.MCPServerConfig, workspacePath string) (probeResult, error) {
-		assert.Equal(t, "filesystem", name)
-		assert.Equal(t, readMCPConfig(t, configPath).WorkspacePath(), workspacePath)
-		return probeResult{ToolCount: 2}, nil
-	}
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"test", "filesystem"}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, `MCP server "filesystem" reachable (2 tools)`)
-}
-
-func TestMCPAddDeferredFlag(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "--deferred", "myserver", "npx", "my-mcp"}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["myserver"]
-	require.NotNil(t, server.Deferred)
-	assert.True(t, *server.Deferred)
-}
-
-func TestMCPAddNoDeferredFlag(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "--no-deferred", "myserver", "npx", "my-mcp"}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["myserver"]
-	require.NotNil(t, server.Deferred)
-	assert.False(t, *server.Deferred)
-}
-
-func TestMCPAddNoDeferredByDefault(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"add", "myserver", "npx", "my-mcp"}, "")
-	require.NoError(t, err)
-
-	cfg := readMCPConfig(t, configPath)
-	server := cfg.Tools.MCP.Servers["myserver"]
-	assert.Nil(t, server.Deferred)
-}
-
-func TestMCPShowNotFound(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, nil)
-
-	cmd := NewMCPCommand()
-	_, err := executeCommand(cmd, []string{"show", "missing"}, "")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), `"missing" not found`)
-}
-
-func TestMCPShowDisabledServer(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"myserver": {
-						Enabled: false,
-						Type:    "stdio",
-						Command: "npx",
-					},
-				},
-			},
-		},
-	})
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"show", "myserver"}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, "myserver")
-	assert.Contains(t, output, "disabled")
-}
-
-func TestMCPShowUsesProbe(t *testing.T) {
-	configPath := setupMCPConfigEnv(t)
-	writeMCPConfig(t, configPath, &config.Config{
-		Tools: config.ToolsConfig{
-			MCP: config.MCPConfig{
-				ToolConfig: config.ToolConfig{Enabled: true},
-				Servers: map[string]config.MCPServerConfig{
-					"myserver": {
-						Enabled: true,
-						Type:    "stdio",
-						Command: "npx",
-					},
-				},
-			},
-		},
-	})
-
-	original := serverShowProbe
-	defer func() { serverShowProbe = original }()
-	serverShowProbe = func(_ context.Context, name string, _ config.MCPServerConfig, _ string) ([]toolDetail, error) {
-		assert.Equal(t, "myserver", name)
-		return []toolDetail{
-			{
-				Name:        "read_file",
-				Description: "Read a file from the filesystem",
-				Parameters: []paramDetail{
-					{Name: "path", Type: "string", Description: "File path", Required: true},
-					{Name: "encoding", Type: "string", Description: "Character encoding", Required: false},
-				},
-			},
-			{
-				Name:        "list_dir",
-				Description: "List directory contents",
-				Parameters:  nil,
-			},
-		}, nil
-	}
-
-	cmd := NewMCPCommand()
-	output, err := executeCommand(cmd, []string{"show", "myserver"}, "")
-	require.NoError(t, err)
-	assert.Contains(t, output, "myserver")
-	assert.Contains(t, output, "read_file")
-	assert.Contains(t, output, "Read a file from the filesystem")
-	assert.Contains(t, output, "path")
-	assert.Contains(t, output, "string")
-	assert.Contains(t, output, "required")
-	assert.Contains(t, output, "list_dir")
-	assert.Contains(t, output, "none")
-}
-
-func setupMCPConfigEnv(t *testing.T) string {
-	t.Helper()
-
-	configPath := filepath.Join(t.TempDir(), "config.json")
-	t.Setenv(config.EnvConfig, configPath)
-	t.Setenv(config.EnvHome, filepath.Dir(configPath))
-	return configPath
-}
-
-func writeMCPConfig(t *testing.T, path string, cfg *config.Config) {
-	t.Helper()
-
-	if cfg == nil {
-		cfg = config.DefaultConfig()
-	}
-
-	require.NoError(t, config.SaveConfig(path, cfg))
-}
-
-func readMCPConfig(t *testing.T, path string) *config.Config {
-	t.Helper()
-
-	cfg, err := config.LoadConfig(path)
-	require.NoError(t, err)
-	return cfg
-}
-
-func executeCommand(cmd *cobra.Command, args []string, stdin string) (string, error) {
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-
-	cmd.SetArgs(args)
-	cmd.SetOut(&stdout)
-	cmd.SetErr(&stderr)
-	cmd.SetIn(strings.NewReader(stdin))
-
-	err := cmd.Execute()
-	return stdout.String() + stderr.String(), err
-}

cmd/picoclaw/internal/mcp/edit.go

@@ -1,54 +0,0 @@
-package mcp
-
-import (
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"go.mau.fi/util/shlex"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-)
-
-func newEditCommand() *cobra.Command {
-	return &cobra.Command{
-		Use:   "edit",
-		Short: "Open the PicoClaw config in $EDITOR",
-		Args:  cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			editor := strings.TrimSpace(os.Getenv("EDITOR"))
-			if editor == "" {
-				return fmt.Errorf("$EDITOR is not set")
-			}
-
-			cfg, err := loadConfig()
-			if err != nil {
-				return err
-			}
-			if err = saveValidatedConfig(cfg); err != nil {
-				return err
-			}
-
-			editorArgs, err := shlex.Split(editor)
-			if err != nil {
-				return fmt.Errorf("failed to parse $EDITOR: %w", err)
-			}
-			if len(editorArgs) == 0 {
-				return fmt.Errorf("$EDITOR is empty")
-			}
-
-			editorArgs = append(editorArgs, internal.GetConfigPath())
-			process := editorCommand(editorArgs[0], editorArgs[1:]...)
-			process.Stdin = cmd.InOrStdin()
-			process.Stdout = cmd.OutOrStdout()
-			process.Stderr = cmd.ErrOrStderr()
-
-			if err := process.Run(); err != nil {
-				return fmt.Errorf("failed to start editor: %w", err)
-			}
-
-			return nil
-		},
-	}
-}

cmd/picoclaw/internal/mcp/helpers.go

@@ -1,374 +0,0 @@
-package mcp
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/url"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"sort"
-	"strings"
-	"sync"
-
-	"github.com/google/jsonschema-go/jsonschema"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/config"
-	picomcp "github.com/sipeed/picoclaw/pkg/mcp"
-)
-
-type probeResult struct {
-	ToolCount int
-}
-
-var (
-	editorCommand = exec.Command
-	serverProbe   = defaultServerProbe
-
-	mcpConfigSchemaOnce sync.Once
-	mcpConfigSchema     *jsonschema.Resolved
-	errMcpConfigSchema  error
-)
-
-const mcpConfigSchemaJSON = `{
-  "type": "object",
-  "properties": {
-    "tools": {
-      "type": "object",
-      "properties": {
-        "mcp": {
-          "type": "object",
-          "properties": {
-            "enabled": { "type": "boolean" },
-            "discovery": { "type": "object", "additionalProperties": true },
-            "max_inline_text_chars": { "type": "integer" },
-            "servers": {
-              "type": "object",
-              "additionalProperties": {
-                "type": "object",
-                "properties": {
-                  "enabled": { "type": "boolean" },
-                  "deferred": { "type": "boolean" },
-                  "command": { "type": "string" },
-                  "args": {
-                    "type": "array",
-                    "items": { "type": "string" }
-                  },
-                  "env": {
-                    "type": "object",
-                    "additionalProperties": { "type": "string" }
-                  },
-                  "env_file": { "type": "string" },
-                  "type": {
-                    "type": "string",
-                    "enum": ["stdio", "http", "sse"]
-                  },
-                  "url": { "type": "string" },
-                  "headers": {
-                    "type": "object",
-                    "additionalProperties": { "type": "string" }
-                  }
-                },
-                "required": ["enabled"],
-                "anyOf": [
-                  { "required": ["command"] },
-                  { "required": ["url"] }
-                ],
-                "additionalProperties": false
-              }
-            }
-          },
-          "required": ["enabled"],
-          "additionalProperties": true
-        }
-      },
-      "required": ["mcp"],
-      "additionalProperties": true
-    }
-  },
-  "required": ["tools"],
-  "additionalProperties": true
-}`
-
-func loadConfig() (*config.Config, error) {
-	cfg, err := config.LoadConfig(internal.GetConfigPath())
-	if err != nil {
-		return nil, fmt.Errorf("failed to load config: %w", err)
-	}
-	return cfg, nil
-}
-
-func saveValidatedConfig(cfg *config.Config) error {
-	if cfg == nil {
-		return fmt.Errorf("config is nil")
-	}
-
-	normalizedCfg := normalizedConfigForSave(cfg)
-
-	data, err := json.Marshal(normalizedCfg)
-	if err != nil {
-		return fmt.Errorf("failed to serialize config: %w", err)
-	}
-
-	if err := validateConfigDocument(data); err != nil {
-		return err
-	}
-
-	if err := config.SaveConfig(internal.GetConfigPath(), normalizedCfg); err != nil {
-		return fmt.Errorf("failed to save config: %w", err)
-	}
-
-	return nil
-}
-
-func normalizedConfigForSave(cfg *config.Config) *config.Config {
-	clone := *cfg
-	if cfg.Tools.MCP.Servers == nil {
-		return &clone
-	}
-
-	clone.Tools = cfg.Tools
-	clone.Tools.MCP = cfg.Tools.MCP
-	clone.Tools.MCP.Servers = make(map[string]config.MCPServerConfig, len(cfg.Tools.MCP.Servers))
-	for name, server := range cfg.Tools.MCP.Servers {
-		if server.Type != "" {
-			server.Type = config.NormalizeMCPTransportType(server.Type)
-		}
-		clone.Tools.MCP.Servers[name] = server
-	}
-
-	return &clone
-}
-
-func validateConfigDocument(data []byte) error {
-	var instance map[string]any
-	if err := json.Unmarshal(data, &instance); err != nil {
-		return fmt.Errorf("failed to decode serialized config: %w", err)
-	}
-
-	schema, err := loadMCPConfigSchema()
-	if err != nil {
-		return fmt.Errorf("failed to load MCP config schema: %w", err)
-	}
-
-	if err := schema.Validate(instance); err != nil {
-		return fmt.Errorf("config validation failed: %w", err)
-	}
-
-	return nil
-}
-
-func loadMCPConfigSchema() (*jsonschema.Resolved, error) {
-	mcpConfigSchemaOnce.Do(func() {
-		var schema jsonschema.Schema
-		if err := json.Unmarshal([]byte(mcpConfigSchemaJSON), &schema); err != nil {
-			errMcpConfigSchema = err
-			return
-		}
-		mcpConfigSchema, errMcpConfigSchema = schema.Resolve(nil)
-	})
-
-	return mcpConfigSchema, errMcpConfigSchema
-}
-
-func inferTransportType(server config.MCPServerConfig) string {
-	transport := config.EffectiveMCPTransportType(server)
-	if transport == "" {
-		return "unknown"
-	}
-	return transport
-}
-
-func renderServerTarget(server config.MCPServerConfig) string {
-	transport := inferTransportType(server)
-	if transport == "http" || transport == "sse" {
-		if server.URL == "" {
-			return "<missing url>"
-		}
-		return server.URL
-	}
-
-	parts := append([]string{server.Command}, server.Args...)
-	rendered := strings.TrimSpace(strings.Join(parts, " "))
-	if rendered == "" {
-		return "<missing command>"
-	}
-	return rendered
-}
-
-func sortedServerNames(servers map[string]config.MCPServerConfig) []string {
-	names := make([]string, 0, len(servers))
-	for name := range servers {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return names
-}
-
-func parseEnvAssignments(values []string) (map[string]string, error) {
-	if len(values) == 0 {
-		return nil, nil
-	}
-
-	env := make(map[string]string, len(values))
-	for _, entry := range values {
-		key, value, found := strings.Cut(entry, "=")
-		if !found {
-			return nil, fmt.Errorf("invalid env assignment %q: expected KEY=value", entry)
-		}
-		key = strings.TrimSpace(key)
-		if key == "" {
-			return nil, fmt.Errorf("invalid env assignment %q: key cannot be empty", entry)
-		}
-		env[key] = value
-	}
-
-	return env, nil
-}
-
-func parseHeaderAssignments(values []string) (map[string]string, error) {
-	if len(values) == 0 {
-		return nil, nil
-	}
-
-	headers := make(map[string]string, len(values))
-	for _, entry := range values {
-		key, value, found := strings.Cut(entry, ":")
-		if !found {
-			key, value, found = strings.Cut(entry, "=")
-		}
-		if !found {
-			return nil, fmt.Errorf("invalid header %q: expected 'Name: Value' or 'Name=Value'", entry)
-		}
-		key = strings.TrimSpace(key)
-		value = strings.TrimSpace(value)
-		if key == "" {
-			return nil, fmt.Errorf("invalid header %q: name cannot be empty", entry)
-		}
-		headers[key] = value
-	}
-
-	return headers, nil
-}
-
-func looksLikeRemoteURL(target string) bool {
-	parsedURL, err := url.ParseRequestURI(target)
-	if err != nil {
-		return false
-	}
-	if parsedURL.Host == "" {
-		return false
-	}
-	switch strings.ToLower(parsedURL.Scheme) {
-	case "http", "https":
-		return true
-	default:
-		return false
-	}
-}
-
-func isLocalCommandPath(command string) bool {
-	if command == "" {
-		return false
-	}
-	if looksLikeRemoteURL(command) {
-		return false
-	}
-	return filepath.IsAbs(command) ||
-		filepath.VolumeName(command) != "" ||
-		strings.HasPrefix(command, "."+string(os.PathSeparator)) ||
-		strings.HasPrefix(command, ".."+string(os.PathSeparator)) ||
-		command == "." ||
-		command == ".." ||
-		strings.ContainsRune(command, os.PathSeparator)
-}
-
-func expandHomePath(path string) string {
-	if path == "" || path[0] != '~' {
-		return path
-	}
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return path
-	}
-	if path == "~" {
-		return home
-	}
-	if strings.HasPrefix(path, "~/") || strings.HasPrefix(path, "~\\") {
-		return filepath.Join(home, path[2:])
-	}
-	return path
-}
-
-func validateLocalCommandPath(command string) error {
-	if !isLocalCommandPath(command) {
-		return nil
-	}
-
-	path := expandHomePath(command)
-	info, err := os.Stat(path)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return fmt.Errorf("local command %q does not exist", command)
-		}
-		return fmt.Errorf("failed to stat local command %q: %w", command, err)
-	}
-	if info.IsDir() {
-		return fmt.Errorf("local command %q is a directory", command)
-	}
-	if runtime.GOOS != "windows" && info.Mode()&0o111 == 0 {
-		return fmt.Errorf("local command %q is not executable", command)
-	}
-	return nil
-}
-
-func defaultServerProbe(
-	ctx context.Context,
-	name string,
-	server config.MCPServerConfig,
-	workspacePath string,
-) (probeResult, error) {
-	mgr := picomcp.NewManager()
-	defer func() { _ = mgr.Close() }()
-
-	server.Enabled = true
-	mcpCfg := config.MCPConfig{
-		ToolConfig: config.ToolConfig{Enabled: true},
-		Servers: map[string]config.MCPServerConfig{
-			name: server,
-		},
-	}
-
-	if err := mgr.LoadFromMCPConfig(ctx, mcpCfg, workspacePath); err != nil {
-		return probeResult{}, err
-	}
-
-	conn, ok := mgr.GetServer(name)
-	if !ok {
-		return probeResult{}, fmt.Errorf("server %q did not register a connection", name)
-	}
-
-	return probeResult{ToolCount: len(conn.Tools)}, nil
-}
-
-func confirmOverwrite(r io.Reader, w io.Writer, name string) (bool, error) {
-	if _, err := fmt.Fprintf(w, "MCP server %q already exists. Overwrite? [y/N]: ", name); err != nil {
-		return false, err
-	}
-
-	var answer string
-	if _, err := fmt.Fscanln(r, &answer); err != nil {
-		if errors.Is(err, io.EOF) {
-			return false, nil
-		}
-		return false, err
-	}
-
-	answer = strings.TrimSpace(strings.ToLower(answer))
-	return answer == "y" || answer == "yes", nil
-}

cmd/picoclaw/internal/mcp/list.go

@@ -1,78 +0,0 @@
-package mcp
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal/cliui"
-)
-
-func newListCommand() *cobra.Command {
-	var (
-		includeStatus bool
-		timeout       time.Duration
-	)
-
-	cmd := &cobra.Command{
-		Use:   "list",
-		Short: "List configured MCP servers",
-		Args:  cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			cfg, err := loadConfig()
-			if err != nil {
-				return err
-			}
-
-			if len(cfg.Tools.MCP.Servers) == 0 {
-				fmt.Fprintln(cmd.OutOrStdout(), "No MCP servers configured.")
-				return nil
-			}
-
-			rows := make([]cliui.MCPListRow, 0, len(cfg.Tools.MCP.Servers))
-			for _, name := range sortedServerNames(cfg.Tools.MCP.Servers) {
-				server := cfg.Tools.MCP.Servers[name]
-				status := "disabled"
-				if server.Enabled {
-					status = "enabled"
-				}
-
-				if includeStatus && server.Enabled {
-					ctx, cancel := context.WithTimeout(context.Background(), timeout)
-					result, probeErr := serverProbe(ctx, name, server, cfg.WorkspacePath())
-					cancel()
-					if probeErr != nil {
-						status = "error"
-					} else {
-						status = fmt.Sprintf("ok (%d tools)", result.ToolCount)
-					}
-				}
-
-				effectiveDeferred := cfg.Tools.MCP.Discovery.Enabled
-				deferredExplicit := server.Deferred != nil
-				if deferredExplicit {
-					effectiveDeferred = *server.Deferred
-				}
-
-				rows = append(rows, cliui.MCPListRow{
-					Name:              name,
-					Type:              inferTransportType(server),
-					Target:            renderServerTarget(server),
-					Status:            status,
-					EffectiveDeferred: effectiveDeferred,
-					DeferredExplicit:  deferredExplicit,
-				})
-			}
-
-			cliui.PrintMCPList(cmd.OutOrStdout(), rows)
-			return nil
-		},
-	}
-
-	cmd.Flags().BoolVar(&includeStatus, "status", false, "Ping enabled servers and show live status")
-	cmd.Flags().DurationVar(&timeout, "timeout", 5*time.Second, "Timeout for each live status check")
-
-	return cmd
-}

cmd/picoclaw/internal/mcp/remove.go

@@ -1,39 +0,0 @@
-package mcp
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-func newRemoveCommand() *cobra.Command {
-	return &cobra.Command{
-		Use:   "remove <name>",
-		Short: "Remove an MCP server from config",
-		Args:  cobra.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := loadConfig()
-			if err != nil {
-				return err
-			}
-
-			name := args[0]
-			if _, exists := cfg.Tools.MCP.Servers[name]; !exists {
-				return fmt.Errorf("MCP server %q not found", name)
-			}
-
-			delete(cfg.Tools.MCP.Servers, name)
-			if len(cfg.Tools.MCP.Servers) == 0 {
-				cfg.Tools.MCP.Servers = nil
-				cfg.Tools.MCP.Enabled = false
-			}
-
-			if err := saveValidatedConfig(cfg); err != nil {
-				return err
-			}
-
-			fmt.Fprintf(cmd.OutOrStdout(), "✓ MCP server %q removed.\n", name)
-			return nil
-		},
-	}
-}

cmd/picoclaw/internal/mcp/show.go

@@ -1,237 +0,0 @@
-package mcp
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal/cliui"
-	"github.com/sipeed/picoclaw/pkg/config"
-	picomcp "github.com/sipeed/picoclaw/pkg/mcp"
-)
-
-type toolDetail struct {
-	Name        string
-	Description string
-	Parameters  []paramDetail
-}
-
-type paramDetail struct {
-	Name        string
-	Type        string
-	Description string
-	Required    bool
-}
-
-var serverShowProbe = defaultServerShowProbe
-
-func defaultServerShowProbe(
-	ctx context.Context,
-	name string,
-	server config.MCPServerConfig,
-	workspacePath string,
-) ([]toolDetail, error) {
-	mgr := picomcp.NewManager()
-	defer func() { _ = mgr.Close() }()
-
-	server.Enabled = true
-	mcpCfg := config.MCPConfig{
-		ToolConfig: config.ToolConfig{Enabled: true},
-		Servers: map[string]config.MCPServerConfig{
-			name: server,
-		},
-	}
-
-	if err := mgr.LoadFromMCPConfig(ctx, mcpCfg, workspacePath); err != nil {
-		return nil, err
-	}
-
-	conn, ok := mgr.GetServer(name)
-	if !ok {
-		return nil, fmt.Errorf("server %q did not register a connection", name)
-	}
-
-	details := make([]toolDetail, 0, len(conn.Tools))
-	for _, tool := range conn.Tools {
-		details = append(details, toolDetail{
-			Name:        tool.Name,
-			Description: tool.Description,
-			Parameters:  extractParameters(tool.InputSchema),
-		})
-	}
-	return details, nil
-}
-
-func extractParameters(schema any) []paramDetail {
-	schemaMap := normalizeSchema(schema)
-	properties, ok := schemaMap["properties"].(map[string]any)
-	if !ok || len(properties) == 0 {
-		return nil
-	}
-
-	required := make(map[string]struct{})
-	switch raw := schemaMap["required"].(type) {
-	case []string:
-		for _, name := range raw {
-			required[name] = struct{}{}
-		}
-	case []any:
-		for _, value := range raw {
-			if name, ok := value.(string); ok {
-				required[name] = struct{}{}
-			}
-		}
-	}
-
-	names := make([]string, 0, len(properties))
-	for name := range properties {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-
-	params := make([]paramDetail, 0, len(names))
-	for _, name := range names {
-		param := paramDetail{Name: name}
-		if propMap, ok := properties[name].(map[string]any); ok {
-			if typeName, ok := propMap["type"].(string); ok {
-				param.Type = strings.TrimSpace(typeName)
-			}
-			if desc, ok := propMap["description"].(string); ok {
-				param.Description = strings.TrimSpace(desc)
-			}
-		}
-		_, param.Required = required[name]
-		params = append(params, param)
-	}
-	return params
-}
-
-func normalizeSchema(schema any) map[string]any {
-	if schema == nil {
-		return map[string]any{}
-	}
-	if schemaMap, ok := schema.(map[string]any); ok {
-		return schemaMap
-	}
-
-	var jsonData []byte
-	switch raw := schema.(type) {
-	case json.RawMessage:
-		jsonData = raw
-	case []byte:
-		jsonData = raw
-	default:
-		var err error
-		jsonData, err = json.Marshal(schema)
-		if err != nil {
-			return map[string]any{}
-		}
-	}
-
-	var result map[string]any
-	if err := json.Unmarshal(jsonData, &result); err != nil {
-		return map[string]any{}
-	}
-	return result
-}
-
-func newShowCommand() *cobra.Command {
-	var timeout time.Duration
-
-	cmd := &cobra.Command{
-		Use:   "show <name>",
-		Short: "Show details and tools for a configured MCP server",
-		Args:  cobra.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := loadConfig()
-			if err != nil {
-				return err
-			}
-
-			name := args[0]
-			server, exists := cfg.Tools.MCP.Servers[name]
-			if !exists {
-				return fmt.Errorf("MCP server %q not found", name)
-			}
-
-			serverInfo := buildServerInfo(name, server, cfg.Tools.MCP.Discovery.Enabled)
-
-			if !server.Enabled {
-				cliui.PrintMCPShow(cmd.OutOrStdout(), serverInfo, nil, true)
-				return nil
-			}
-
-			ctx, cancel := context.WithTimeout(context.Background(), timeout)
-			defer cancel()
-
-			details, err := serverShowProbe(ctx, name, server, cfg.WorkspacePath())
-			if err != nil {
-				return fmt.Errorf("failed to connect to MCP server %q: %w", name, err)
-			}
-
-			tools := make([]cliui.MCPShowTool, 0, len(details))
-			for _, d := range details {
-				params := make([]cliui.MCPShowParam, 0, len(d.Parameters))
-				for _, p := range d.Parameters {
-					params = append(params, cliui.MCPShowParam{
-						Name:        p.Name,
-						Type:        p.Type,
-						Description: p.Description,
-						Required:    p.Required,
-					})
-				}
-				tools = append(tools, cliui.MCPShowTool{
-					Name:        d.Name,
-					Description: d.Description,
-					Parameters:  params,
-				})
-			}
-
-			cliui.PrintMCPShow(cmd.OutOrStdout(), serverInfo, tools, false)
-			return nil
-		},
-	}
-
-	cmd.Flags().DurationVar(&timeout, "timeout", 10*time.Second, "Connection timeout")
-
-	return cmd
-}
-
-func buildServerInfo(name string, server config.MCPServerConfig, discoveryEnabled bool) cliui.MCPShowServer {
-	effectiveDeferred := discoveryEnabled
-	deferredExplicit := server.Deferred != nil
-	if deferredExplicit {
-		effectiveDeferred = *server.Deferred
-	}
-	info := cliui.MCPShowServer{
-		Name:              name,
-		Type:              inferTransportType(server),
-		Target:            renderServerTarget(server),
-		Enabled:           server.Enabled,
-		EffectiveDeferred: effectiveDeferred,
-		DeferredExplicit:  deferredExplicit,
-		EnvFile:           server.EnvFile,
-	}
-	if len(server.Env) > 0 {
-		keys := make([]string, 0, len(server.Env))
-		for k := range server.Env {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		info.EnvKeys = keys
-	}
-	if len(server.Headers) > 0 {
-		keys := make([]string, 0, len(server.Headers))
-		for k := range server.Headers {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		info.Headers = keys
-	}
-	return info
-}

cmd/picoclaw/internal/mcp/test.go

@@ -1,46 +0,0 @@
-package mcp
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/spf13/cobra"
-)
-
-func newTestCommand() *cobra.Command {
-	var timeout time.Duration
-
-	cmd := &cobra.Command{
-		Use:   "test <name>",
-		Short: "Test connectivity for a configured MCP server",
-		Args:  cobra.ExactArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			cfg, err := loadConfig()
-			if err != nil {
-				return err
-			}
-
-			name := args[0]
-			server, exists := cfg.Tools.MCP.Servers[name]
-			if !exists {
-				return fmt.Errorf("MCP server %q not found", name)
-			}
-
-			ctx, cancel := context.WithTimeout(context.Background(), timeout)
-			defer cancel()
-
-			result, err := serverProbe(ctx, name, server, cfg.WorkspacePath())
-			if err != nil {
-				return fmt.Errorf("failed to reach MCP server %q: %w", name, err)
-			}
-
-			fmt.Fprintf(cmd.OutOrStdout(), "✓ MCP server %q reachable (%d tools).\n", name, result.ToolCount)
-			return nil
-		},
-	}
-
-	cmd.Flags().DurationVar(&timeout, "timeout", 5*time.Second, "Connection timeout")
-
-	return cmd
-}

cmd/picoclaw/internal/migrate/command.go

@@ -11,21 +11,19 @@ func NewMigrateCommand() *cobra.Command {
 
 	cmd := &cobra.Command{
 		Use:   "migrate",
-		Short: "Migrate from xxxclaw(openclaw, etc.) to picoclaw",
+		Short: "Migrate from OpenClaw to PicoClaw",
 		Args:  cobra.NoArgs,
 		Example: `  picoclaw migrate
-  picoclaw migrate --from openclaw
   picoclaw migrate --dry-run
   picoclaw migrate --refresh
   picoclaw migrate --force`,
 		RunE: func(cmd *cobra.Command, _ []string) error {
-			m := migrate.NewMigrateInstance(opts)
+			result, err := migrate.Run(opts)
-			result, err := m.Run(opts)
 			if err != nil {
 				return err
 			}
 			if !opts.DryRun {
-				m.PrintSummary(result)
+				migrate.PrintSummary(result)
 			}
 			return nil
 		},
@@ -33,8 +31,6 @@ func NewMigrateCommand() *cobra.Command {
 
 	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false,
 		"Show what would be migrated without making changes")
-	cmd.Flags().StringVar(&opts.Source, "from", "openclaw",
-		"Source to migrate from (e.g., openclaw)")
 	cmd.Flags().BoolVar(&opts.Refresh, "refresh", false,
 		"Re-sync workspace files from OpenClaw (repeatable)")
 	cmd.Flags().BoolVar(&opts.ConfigOnly, "config-only", false,
@@ -43,10 +39,10 @@ func NewMigrateCommand() *cobra.Command {
 		"Only migrate workspace files, skip config")
 	cmd.Flags().BoolVar(&opts.Force, "force", false,
 		"Skip confirmation prompts")
-	cmd.Flags().StringVar(&opts.SourceHome, "source-home", "",
+	cmd.Flags().StringVar(&opts.OpenClawHome, "openclaw-home", "",
-		"Override source home directory (default: ~/.openclaw)")
+		"Override OpenClaw home directory (default: ~/.openclaw)")
-	cmd.Flags().StringVar(&opts.TargetHome, "target-home", "",
+	cmd.Flags().StringVar(&opts.PicoClawHome, "picoclaw-home", "",
-		"Override target home directory (default: ~/.picoclaw)")
+		"Override PicoClaw home directory (default: ~/.picoclaw)")
 
 	return cmd
 }

cmd/picoclaw/internal/migrate/command_test.go

@@ -13,7 +13,7 @@ func TestNewMigrateCommand(t *testing.T) {
 	require.NotNil(t, cmd)
 
 	assert.Equal(t, "migrate", cmd.Use)
-	assert.Equal(t, "Migrate from xxxclaw(openclaw, etc.) to picoclaw", cmd.Short)
+	assert.Equal(t, "Migrate from OpenClaw to PicoClaw", cmd.Short)
 
 	assert.Len(t, cmd.Aliases, 0)
 
@@ -33,6 +33,6 @@ func TestNewMigrateCommand(t *testing.T) {
 	assert.NotNil(t, cmd.Flags().Lookup("config-only"))
 	assert.NotNil(t, cmd.Flags().Lookup("workspace-only"))
 	assert.NotNil(t, cmd.Flags().Lookup("force"))
-	assert.NotNil(t, cmd.Flags().Lookup("source-home"))
+	assert.NotNil(t, cmd.Flags().Lookup("openclaw-home"))
-	assert.NotNil(t, cmd.Flags().Lookup("target-home"))
+	assert.NotNil(t, cmd.Flags().Lookup("picoclaw-home"))
 }

cmd/picoclaw/internal/model/add.go

@@ -1,200 +0,0 @@
-package model
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-const defaultAliasName = "custom-prefer"
-
-func newAddCommand() *cobra.Command {
-	var (
-		apiBase   string
-		apiKey    string
-		modelID   string
-		alias     string
-		modelType string
-	)
-
-	cmd := &cobra.Command{
-		Use:   "add",
-		Short: "Add a model from an OpenAI-compatible endpoint",
-		Long: `Add a model entry by querying an OpenAI-compatible endpoint exposing
-GET <api-base>/models, then setting it as the default model.
-
-If --model is omitted, the available models are listed and you can pick one
-interactively. If --model is provided, the entry is written without contacting
-the server.
-
-Sample interactive session (key shown masked):
-
-    $ picoclaw model add \
-        -b https://ark.cn-beijing.volces.com/api/v3 \
-        -k 7dff****-****-****-****-********e829
-
-    115 model(s) available:
-        1) doubao-lite-128k-240428    (doubao-lite-128k)
-        2) doubao-pro-128k-240515     (doubao-pro-128k)
-        ...
-       48) deepseek-r1-250120          (deepseek-r1)
-       78) kimi-k2-250711              (kimi-k2)
-        ...
-      115) doubao-seed3d-2-0-260328    (doubao-seed3d-2-0)
-    Pick a model (number or id): 48
-    ✓ Saved model 'custom-prefer' (deepseek-r1-250120) and set as default.`,
-		Example: `  picoclaw model add --api-base https://api.openai.com/v1 --api-key sk-...
-  picoclaw model add -b http://localhost:8000/v1 -k dummy -m my-model -n local`,
-		Args: cobra.NoArgs,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			return runAdd(addOptions{
-				apiBase:   strings.TrimSpace(apiBase),
-				apiKey:    strings.TrimSpace(apiKey),
-				modelID:   strings.TrimSpace(modelID),
-				alias:     strings.TrimSpace(alias),
-				modelType: strings.TrimSpace(modelType),
-				stdin:     cmd.InOrStdin(),
-				stdout:    cmd.OutOrStdout(),
-			})
-		},
-	}
-
-	cmd.Flags().StringVarP(&apiBase, "api-base", "b", "",
-		"API base URL (required), e.g. https://api.openai.com/v1")
-	cmd.Flags().StringVarP(&apiKey, "api-key", "k", "", "API key (required)")
-	cmd.Flags().StringVarP(&modelID, "model", "m", "",
-		"Model id; when set, skips the interactive picker and the network call")
-	cmd.Flags().StringVarP(&alias, "name", "n", defaultAliasName,
-		"Local alias written to model_list and used as the default model name")
-	cmd.Flags().StringVar(&modelType, "type", "openai-compatible",
-		"Endpoint type (only 'openai-compatible' is supported today)")
-	_ = cmd.MarkFlagRequired("api-base")
-	_ = cmd.MarkFlagRequired("api-key")
-
-	return cmd
-}
-
-type addOptions struct {
-	apiBase   string
-	apiKey    string
-	modelID   string
-	alias     string
-	modelType string
-	stdin     io.Reader
-	stdout    io.Writer
-}
-
-func runAdd(opt addOptions) error {
-	if opt.modelType != "" && opt.modelType != "openai-compatible" {
-		return fmt.Errorf("unsupported --type %q (only 'openai-compatible' is supported)", opt.modelType)
-	}
-	if opt.alias == "" {
-		opt.alias = defaultAliasName
-	}
-
-	selected := opt.modelID
-	if selected == "" {
-		entries, err := fetchOpenAIModels(opt.apiBase, opt.apiKey)
-		if err != nil {
-			return fmt.Errorf("fetch models: %w", err)
-		}
-		if len(entries) == 0 {
-			return fmt.Errorf("no models returned by %s", opt.apiBase)
-		}
-		selected, err = pickModel(opt.stdin, opt.stdout, entries)
-		if err != nil {
-			return err
-		}
-	}
-
-	return upsertModelDefault(opt.apiBase, opt.apiKey, opt.alias, selected, opt.stdout)
-}
-
-func pickModel(stdin io.Reader, stdout io.Writer, entries []modelEntry) (string, error) {
-	fmt.Fprintf(stdout, "\n%d model(s) available:\n", len(entries))
-	for i, m := range entries {
-		line := m.ID
-		if m.Name != "" && m.Name != m.ID {
-			line = fmt.Sprintf("%s (%s)", m.ID, m.Name)
-		}
-		fmt.Fprintf(stdout, "  %3d) %s\n", i+1, line)
-	}
-
-	scanner := bufio.NewScanner(stdin)
-	for {
-		fmt.Fprint(stdout, "Pick a model (number or id): ")
-		if !scanner.Scan() {
-			if err := scanner.Err(); err != nil {
-				return "", fmt.Errorf("read input: %w", err)
-			}
-			return "", fmt.Errorf("no selection provided")
-		}
-		text := strings.TrimSpace(scanner.Text())
-		if text == "" {
-			continue
-		}
-		if idx, err := strconv.Atoi(text); err == nil {
-			if idx < 1 || idx > len(entries) {
-				fmt.Fprintf(stdout, "Out of range. Enter 1-%d.\n", len(entries))
-				continue
-			}
-			return entries[idx-1].ID, nil
-		}
-		for _, m := range entries {
-			if m.ID == text {
-				return m.ID, nil
-			}
-		}
-		fmt.Fprintln(stdout, "Not a valid number or model id; try again.")
-	}
-}
-
-func upsertModelDefault(apiBase, apiKey, alias, modelID string, stdout io.Writer) error {
-	configPath := internal.GetConfigPath()
-	cfg, err := config.LoadConfig(configPath)
-	if err != nil {
-		return fmt.Errorf("failed to load config: %w", err)
-	}
-
-	secureKeys := config.SimpleSecureStrings(apiKey)
-
-	found := false
-	for _, m := range cfg.ModelList {
-		if m == nil {
-			continue
-		}
-		if m.ModelName == alias {
-			m.Model = modelID
-			m.APIBase = apiBase
-			m.APIKeys = secureKeys
-			m.Enabled = true
-			found = true
-			break
-		}
-	}
-	if !found {
-		cfg.ModelList = append(cfg.ModelList, &config.ModelConfig{
-			ModelName: alias,
-			Model:     modelID,
-			APIBase:   apiBase,
-			APIKeys:   secureKeys,
-			Enabled:   true,
-		})
-	}
-
-	cfg.Agents.Defaults.ModelName = alias
-
-	if err := config.SaveConfig(configPath, cfg); err != nil {
-		return fmt.Errorf("failed to save config: %w", err)
-	}
-
-	fmt.Fprintf(stdout, "✓ Saved model '%s' (%s) and set as default.\n", alias, modelID)
-	return nil
-}

cmd/picoclaw/internal/model/add_test.go

@@ -1,257 +0,0 @@
-package model
-
-import (
-	"bytes"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-func TestFetchOpenAIModels_DataEnvelope(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, "/models", r.URL.Path)
-		assert.Equal(t, "Bearer secret", r.Header.Get("Authorization"))
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"data":[{"id":"gpt-foo","name":"Foo"},{"id":"gpt-bar"}]}`))
-	}))
-	defer srv.Close()
-
-	entries, err := fetchOpenAIModels(srv.URL, "secret")
-	require.NoError(t, err)
-	require.Len(t, entries, 2)
-	assert.Equal(t, "gpt-foo", entries[0].ID)
-	assert.Equal(t, "Foo", entries[0].Name)
-	assert.Equal(t, "gpt-bar", entries[1].ID)
-}
-
-func TestFetchOpenAIModels_BareArray(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`[{"id":"a"},{"id":"b"}]`))
-	}))
-	defer srv.Close()
-
-	entries, err := fetchOpenAIModels(srv.URL, "secret")
-	require.NoError(t, err)
-	require.Len(t, entries, 2)
-	assert.Equal(t, "a", entries[0].ID)
-	assert.Equal(t, "b", entries[1].ID)
-}
-
-func TestFetchOpenAIModels_TrimsTrailingSlash(t *testing.T) {
-	var gotPath string
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotPath = r.URL.Path
-		_, _ = w.Write([]byte(`{"data":[{"id":"x"}]}`))
-	}))
-	defer srv.Close()
-
-	_, err := fetchOpenAIModels(srv.URL+"/", "k")
-	require.NoError(t, err)
-	assert.Equal(t, "/models", gotPath)
-}
-
-func TestFetchOpenAIModels_HTTPError(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		http.Error(w, "nope", http.StatusUnauthorized)
-	}))
-	defer srv.Close()
-
-	_, err := fetchOpenAIModels(srv.URL, "bad")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "HTTP 401")
-}
-
-func TestFetchOpenAIModels_EmptyDataEnvelope(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte(`{"data":[]}`))
-	}))
-	defer srv.Close()
-
-	entries, err := fetchOpenAIModels(srv.URL, "k")
-	require.NoError(t, err)
-	assert.Empty(t, entries)
-}
-
-func TestFetchOpenAIModels_EmptyBareArray(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte(`[]`))
-	}))
-	defer srv.Close()
-
-	entries, err := fetchOpenAIModels(srv.URL, "k")
-	require.NoError(t, err)
-	assert.Empty(t, entries)
-}
-
-func TestFetchOpenAIModels_UnrecognizedShape(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		_, _ = w.Write([]byte(`{"models":"not-supported"}`))
-	}))
-	defer srv.Close()
-
-	_, err := fetchOpenAIModels(srv.URL, "k")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "unrecognized shape")
-}
-
-func TestFetchOpenAIModels_RequiresInputs(t *testing.T) {
-	_, err := fetchOpenAIModels("", "k")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "api base")
-
-	_, err = fetchOpenAIModels("https://example.com", "")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "api key")
-}
-
-func TestPickModel_ByIndex(t *testing.T) {
-	entries := []modelEntry{{ID: "a"}, {ID: "b"}, {ID: "c"}}
-	out := &bytes.Buffer{}
-	got, err := pickModel(strings.NewReader("2\n"), out, entries)
-	require.NoError(t, err)
-	assert.Equal(t, "b", got)
-	assert.Contains(t, out.String(), "3 model(s) available")
-}
-
-func TestPickModel_ByID(t *testing.T) {
-	entries := []modelEntry{{ID: "alpha"}, {ID: "beta"}}
-	out := &bytes.Buffer{}
-	got, err := pickModel(strings.NewReader("beta\n"), out, entries)
-	require.NoError(t, err)
-	assert.Equal(t, "beta", got)
-}
-
-func TestPickModel_RetriesOnInvalid(t *testing.T) {
-	entries := []modelEntry{{ID: "x"}}
-	out := &bytes.Buffer{}
-	got, err := pickModel(strings.NewReader("\n9\nnot-a-model\nx\n"), out, entries)
-	require.NoError(t, err)
-	assert.Equal(t, "x", got)
-	rendered := out.String()
-	assert.Contains(t, rendered, "Out of range")
-	assert.Contains(t, rendered, "Not a valid number")
-}
-
-func TestRunAdd_WithExplicitModel_NoNetwork(t *testing.T) {
-	initTest(t)
-
-	out := &bytes.Buffer{}
-	err := runAdd(addOptions{
-		apiBase:   "https://invalid.invalid/v1",
-		apiKey:    "k",
-		modelID:   "explicit-model",
-		alias:     "myalias",
-		modelType: "openai-compatible",
-		stdout:    out,
-	})
-	require.NoError(t, err)
-	assert.Contains(t, out.String(), "Saved model 'myalias' (explicit-model)")
-
-	cfg, err := config.LoadConfig(configPath)
-	require.NoError(t, err)
-	assert.Equal(t, "myalias", cfg.Agents.Defaults.GetModelName())
-	added := findModelByName(cfg, "myalias")
-	require.NotNil(t, added, "expected model 'myalias' in model_list")
-	assert.Equal(t, "explicit-model", added.Model)
-	assert.Equal(t, "https://invalid.invalid/v1", added.APIBase)
-	assert.True(t, added.Enabled)
-	require.Len(t, added.APIKeys, 1)
-	assert.Equal(t, "k", added.APIKeys[0].String())
-}
-
-func findModelByName(cfg *config.Config, name string) *config.ModelConfig {
-	for _, m := range cfg.ModelList {
-		if m != nil && m.ModelName == name {
-			return m
-		}
-	}
-	return nil
-}
-
-func TestRunAdd_FetchAndPick(t *testing.T) {
-	initTest(t)
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		assert.Equal(t, "Bearer my-key", r.Header.Get("Authorization"))
-		_, _ = w.Write([]byte(`{"data":[{"id":"m1"},{"id":"m2"}]}`))
-	}))
-	defer srv.Close()
-
-	out := &bytes.Buffer{}
-	err := runAdd(addOptions{
-		apiBase:   srv.URL,
-		apiKey:    "my-key",
-		alias:     defaultAliasName,
-		modelType: "openai-compatible",
-		stdin:     strings.NewReader("2\n"),
-		stdout:    out,
-	})
-	require.NoError(t, err)
-
-	cfg, err := config.LoadConfig(configPath)
-	require.NoError(t, err)
-	assert.Equal(t, defaultAliasName, cfg.Agents.Defaults.GetModelName())
-	added := findModelByName(cfg, defaultAliasName)
-	require.NotNil(t, added)
-	assert.Equal(t, "m2", added.Model)
-}
-
-func TestRunAdd_UpsertsExistingAlias(t *testing.T) {
-	initTest(t)
-
-	first := &bytes.Buffer{}
-	require.NoError(t, runAdd(addOptions{
-		apiBase: "https://a.example/v1",
-		apiKey:  "k1",
-		modelID: "m1",
-		alias:   "shared",
-		stdout:  first,
-	}))
-
-	second := &bytes.Buffer{}
-	require.NoError(t, runAdd(addOptions{
-		apiBase: "https://b.example/v1",
-		apiKey:  "k2",
-		modelID: "m2",
-		alias:   "shared",
-		stdout:  second,
-	}))
-
-	cfg, err := config.LoadConfig(configPath)
-	require.NoError(t, err)
-	matches := 0
-	for _, m := range cfg.ModelList {
-		if m != nil && m.ModelName == "shared" {
-			matches++
-		}
-	}
-	assert.Equal(t, 1, matches, "alias should be updated, not duplicated")
-
-	updated := findModelByName(cfg, "shared")
-	require.NotNil(t, updated)
-	assert.Equal(t, "m2", updated.Model)
-	assert.Equal(t, "https://b.example/v1", updated.APIBase)
-	assert.Equal(t, "k2", updated.APIKeys[0].String())
-}
-
-func TestRunAdd_RejectsUnsupportedType(t *testing.T) {
-	initTest(t)
-
-	err := runAdd(addOptions{
-		apiBase:   "https://x/v1",
-		apiKey:    "k",
-		modelID:   "m",
-		alias:     "a",
-		modelType: "anthropic",
-		stdout:    &bytes.Buffer{},
-	})
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "unsupported --type")
-}

cmd/picoclaw/internal/model/command.go

@@ -1,139 +0,0 @@
-package model
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-// LocalModel is a special model name that indicates that the model is local and with or without api_key.
-const LocalModel = "local-model"
-
-func NewModelCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "model [model_name]",
-		Short: "Show or change the default model",
-		Long: `Show or change the default model configuration.
-
-If no argument is provided, shows the current default model.
-If a model name is provided, sets it as the default model.
-
-To onboard a model from a custom OpenAI-compatible endpoint (fetch the
-available list online and pick one), use the 'add' subcommand:
-
-  picoclaw model add --help
-
-Examples:
-  picoclaw model                    # Show current default model
-  picoclaw model gpt-5.2           # Set gpt-5.2 as default
-  picoclaw model claude-sonnet-4.6 # Set claude-sonnet-4.6 as default
-  picoclaw model local-model       # Set local VLLM server as default
-  picoclaw model add -b URL -k KEY # Add a model from a custom endpoint
-
-Note: 'local-model' is a special value for using a local VLLM server
-(running at localhost:8000 by default) which does not require an API key.`,
-		Args: cobra.MaximumNArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			configPath := internal.GetConfigPath()
-
-			// Load current config
-			cfg, err := config.LoadConfig(configPath)
-			if err != nil {
-				return fmt.Errorf("failed to load config: %w", err)
-			}
-
-			if len(args) == 0 {
-				// Show current default model
-				showCurrentModel(cfg)
-				return nil
-			}
-
-			// Set new default model
-			modelName := args[0]
-			return setDefaultModel(configPath, cfg, modelName)
-		},
-	}
-
-	cmd.AddCommand(newAddCommand())
-
-	return cmd
-}
-
-func showCurrentModel(cfg *config.Config) {
-	defaultModel := cfg.Agents.Defaults.ModelName
-
-	if defaultModel == "" {
-		fmt.Println("No default model is currently set.")
-		fmt.Println("\nAvailable models in your config:")
-		listAvailableModels(cfg)
-	} else {
-		fmt.Printf("Current default model: %s\n", defaultModel)
-		fmt.Println("\nAvailable models in your config:")
-		listAvailableModels(cfg)
-	}
-
-	fmt.Println("\nTip: 'picoclaw model add -b URL -k KEY' adds a model from a custom")
-	fmt.Println("     OpenAI-compatible endpoint (see 'picoclaw model add --help').")
-}
-
-func listAvailableModels(cfg *config.Config) {
-	if len(cfg.ModelList) == 0 {
-		fmt.Println("  No models configured in model_list")
-		return
-	}
-
-	defaultModel := cfg.Agents.Defaults.ModelName
-
-	for _, model := range cfg.ModelList {
-		marker := "  "
-		if model.ModelName == defaultModel {
-			marker = "> "
-		}
-		if !model.Enabled {
-			continue
-		}
-		fmt.Printf("%s- %s (%s)\n", marker, model.ModelName, model.Model)
-	}
-}
-
-func setDefaultModel(configPath string, cfg *config.Config, modelName string) error {
-	// Validate that the model exists in model_list
-	modelFound := false
-	for _, model := range cfg.ModelList {
-		if model.Enabled && model.ModelName == modelName {
-			modelFound = true
-			break
-		}
-	}
-
-	if !modelFound && modelName != LocalModel {
-		return fmt.Errorf("cannot found model '%s' in config", modelName)
-	}
-
-	// Update the default model
-	// Clear old model field and set new model_name
-	oldModel := cfg.Agents.Defaults.ModelName
-
-	cfg.Agents.Defaults.ModelName = modelName
-
-	// Save config back to file
-	if err := config.SaveConfig(configPath, cfg); err != nil {
-		return fmt.Errorf("failed to save config: %w", err)
-	}
-
-	fmt.Printf("✓ Default model changed from '%s' to '%s'\n",
-		formatModelName(oldModel), modelName)
-	fmt.Println("\nThe new default model will be used for all agent interactions.")
-
-	return nil
-}
-
-func formatModelName(name string) string {
-	if name == "" {
-		return "(none)"
-	}
-	return name
-}

cmd/picoclaw/internal/model/command_test.go

@@ -1,408 +0,0 @@
-package model
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-var configPath = ""
-
-func initTest(t *testing.T) {
-	tmpDir := t.TempDir()
-	configPath = filepath.Join(tmpDir, "config.json")
-	_ = os.Setenv("PICOCLAW_CONFIG", configPath)
-}
-
-// captureStdout captures stdout during the execution of fn and returns the captured output
-func captureStdout(fn func()) string {
-	oldStdout := os.Stdout
-	r, w, _ := os.Pipe()
-	os.Stdout = w
-
-	fn()
-
-	w.Close()
-	os.Stdout = oldStdout
-
-	var buf bytes.Buffer
-	io.Copy(&buf, r)
-	return buf.String()
-}
-
-func TestNewModelCommand(t *testing.T) {
-	cmd := NewModelCommand()
-
-	require.NotNil(t, cmd)
-
-	assert.Equal(t, "model [model_name]", cmd.Use)
-	assert.Equal(t, "Show or change the default model", cmd.Short)
-
-	assert.Len(t, cmd.Aliases, 0)
-
-	assert.False(t, cmd.HasFlags())
-
-	assert.Nil(t, cmd.Run)
-	assert.NotNil(t, cmd.RunE)
-
-	assert.Nil(t, cmd.PersistentPreRunE)
-	assert.Nil(t, cmd.PersistentPreRun)
-	assert.Nil(t, cmd.PersistentPostRun)
-}
-
-func TestShowCurrentModel_WithDefaultModel(t *testing.T) {
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "gpt-4",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "gpt-4",
-				Model:     "openai/gpt-4",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{
-				ModelName: "claude-3",
-				Model:     "anthropic/claude-3",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	output := captureStdout(func() {
-		showCurrentModel(cfg)
-	})
-
-	assert.Contains(t, output, "Current default model: gpt-4")
-	assert.Contains(t, output, "Available models in your config:")
-	assert.Contains(t, output, "gpt-4")
-	assert.Contains(t, output, "claude-3")
-}
-
-func TestShowCurrentModel_NoDefaultModel(t *testing.T) {
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "gpt-4",
-				Model:     "openai/gpt-4",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	output := captureStdout(func() {
-		showCurrentModel(cfg)
-	})
-
-	assert.Contains(t, output, "No default model is currently set.")
-	assert.Contains(t, output, "Available models in your config:")
-}
-
-func TestListAvailableModels_Empty(t *testing.T) {
-	cfg := &config.Config{
-		ModelList: []*config.ModelConfig{},
-	}
-
-	output := captureStdout(func() {
-		listAvailableModels(cfg)
-	})
-
-	assert.Contains(t, output, "No models configured in model_list")
-}
-
-func TestListAvailableModels_WithModels(t *testing.T) {
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "gpt-4",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "gpt-4",
-				Model:     "openai/gpt-4",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{
-				ModelName: "claude-3",
-				Model:     "anthropic/claude-3",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{ModelName: "no-key-model", Model: "openai/test"},
-		},
-	}
-
-	output := captureStdout(func() {
-		listAvailableModels(cfg)
-	})
-
-	assert.NotEmpty(t, output)
-	assert.Contains(t, output, "> - gpt-4 (openai/gpt-4)")
-	assert.Contains(t, output, "claude-3 (anthropic/claude-3)")
-	assert.NotContains(t, output, "no-key-model")
-}
-
-func TestSetDefaultModel_ValidModel(t *testing.T) {
-	initTest(t)
-
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "old-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "new-model",
-				Model:     "openai/new-model",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{
-				ModelName: "old-model",
-				Model:     "openai/old-model",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	output := captureStdout(func() {
-		err := setDefaultModel(configPath, cfg, "new-model")
-		assert.NoError(t, err)
-	})
-
-	assert.Contains(t, output, "Default model changed from 'old-model' to 'new-model'")
-
-	// Verify config was updated
-	updatedCfg, err := config.LoadConfig(configPath)
-	require.NoError(t, err)
-	assert.Equal(t, "new-model", updatedCfg.Agents.Defaults.ModelName)
-}
-
-func TestSetDefaultModel_InvalidModel(t *testing.T) {
-	initTest(t)
-
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "existing-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "existing-model",
-				Model:     "openai/existing",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	assert.Error(t, setDefaultModel(configPath, cfg, "nonexistent-model"))
-}
-
-func TestSetDefaultModel_ModelWithoutAPIKey(t *testing.T) {
-	initTest(t)
-
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "existing-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "existing-model",
-				Model:     "openai/existing",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{ModelName: "no-key-model", Model: "openai/nokey"},
-		},
-	}
-
-	assert.Error(t, setDefaultModel(configPath, cfg, "no-key-model"))
-}
-
-func TestSetDefaultModel_SaveConfigError(t *testing.T) {
-	// Use an invalid path to trigger save error
-	invalidPath := "/nonexistent/directory/config.json"
-
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "old-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "new-model",
-				Model:     "openai/new-model",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	err := setDefaultModel(invalidPath, cfg, "new-model")
-
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "failed to save config")
-}
-
-func TestFormatModelName(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected string
-	}{
-		{"empty string", "", "(none)"},
-		{"simple model", "gpt-4", "gpt-4"},
-		{"model with version", "claude-sonnet-4.6", "claude-sonnet-4.6"},
-		{"model with spaces", "my model", "my model"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := formatModelName(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestModelCommandExecution_Show(t *testing.T) {
-	initTest(t)
-
-	// Create a test config
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "test-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "test-model",
-				Model:     "openai/test",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	err := config.SaveConfig(configPath, cfg)
-	require.NoError(t, err)
-
-	cmd := NewModelCommand()
-
-	output := captureStdout(func() {
-		err = cmd.RunE(cmd, []string{})
-		assert.NoError(t, err)
-	})
-
-	assert.Contains(t, output, "Current default model: test-model")
-}
-
-func TestModelCommandExecution_Set(t *testing.T) {
-	initTest(t)
-
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "old-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "old-model",
-				Model:     "openai/old",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{
-				ModelName: "new-model",
-				Model:     "openai/new",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	err := config.SaveConfig(configPath, cfg)
-	require.NoError(t, err)
-
-	cmd := NewModelCommand()
-
-	output := captureStdout(func() {
-		err = cmd.RunE(cmd, []string{"new-model"})
-		assert.NoError(t, err)
-	})
-
-	assert.Contains(t, output, "Default model changed from 'old-model' to 'new-model'")
-}
-
-func TestModelCommandExecution_TooManyArgs(t *testing.T) {
-	cmd := NewModelCommand()
-
-	err := cmd.RunE(cmd, []string{"model1", "model2"})
-
-	assert.Error(t, err)
-}
-
-func TestListAvailableModels_MarkerLogic(t *testing.T) {
-	cfg := &config.Config{
-		Agents: config.AgentsConfig{
-			Defaults: config.AgentDefaults{
-				ModelName: "middle-model",
-			},
-		},
-		ModelList: []*config.ModelConfig{
-			{
-				ModelName: "first-model",
-				Model:     "openai/first",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{
-				ModelName: "middle-model",
-				Model:     "openai/middle",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-			{
-				ModelName: "last-model",
-				Model:     "openai/last",
-				APIKeys:   config.SecureStrings{config.NewSecureString("test")},
-				Enabled:   true,
-			},
-		},
-	}
-
-	output := captureStdout(func() {
-		listAvailableModels(cfg)
-	})
-
-	assert.Contains(t, output, "  - first-model (openai/first)")
-	assert.Contains(t, output, "> - middle-model (openai/middle)")
-	assert.Contains(t, output, "  - last-model (openai/last)")
-}

cmd/picoclaw/internal/model/online.go

@@ -1,77 +0,0 @@
-package model
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-)
-
-type modelEntry struct {
-	ID          string `json:"id"`
-	Name        string `json:"name"`
-	Description string `json:"description"`
-}
-
-type modelsAPIResponse struct {
-	Data []modelEntry `json:"data"`
-}
-
-// fetchOpenAIModels GETs <baseURL>/models with Bearer auth and accepts both the
-// {data:[…]} envelope and a bare array shape used by various OpenAI-compatible servers.
-func fetchOpenAIModels(baseURL, apiKey string) ([]modelEntry, error) {
-	if strings.TrimSpace(baseURL) == "" {
-		return nil, fmt.Errorf("api base is required")
-	}
-	if strings.TrimSpace(apiKey) == "" {
-		return nil, fmt.Errorf("api key is required")
-	}
-
-	url := strings.TrimRight(baseURL, "/") + "/models"
-
-	client := &http.Client{Timeout: 15 * time.Second}
-	req, err := http.NewRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return nil, fmt.Errorf("build request: %w", err)
-	}
-	req.Header.Set("Authorization", "Bearer "+apiKey)
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(io.LimitReader(resp.Body, 512))
-		return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("read response: %w", err)
-	}
-
-	// {"data": [...]} envelope. Distinguish "envelope shape with empty list"
-	// from "object without a data key" via Data being non-nil after unmarshal:
-	// json.Unmarshal sets Data to []modelEntry{} for `{"data":[]}` but leaves
-	// it as nil when "data" is absent or null.
-	var envelope modelsAPIResponse
-	if err := json.Unmarshal(body, &envelope); err == nil && envelope.Data != nil {
-		return envelope.Data, nil
-	}
-
-	// Bare-array shape, including `[]`.
-	var arr []modelEntry
-	if err := json.Unmarshal(body, &arr); err == nil {
-		return arr, nil
-	}
-
-	preview := body
-	if len(preview) > 256 {
-		preview = preview[:256]
-	}
-	return nil, fmt.Errorf("decode response: unrecognized shape: %s", strings.TrimSpace(string(preview)))
-}

cmd/picoclaw/internal/onboard/command.go

@@ -6,29 +6,19 @@ import (
 	"github.com/spf13/cobra"
 )
 
-//go:generate go run ../../../../scripts/copydir.go ../../../../workspace ./workspace
+//go:generate cp -r ../../../../workspace .
 //go:embed workspace
 var embeddedFiles embed.FS
 
 func NewOnboardCommand() *cobra.Command {
-	var encrypt bool
-
 	cmd := &cobra.Command{
 		Use:     "onboard",
 		Aliases: []string{"o"},
 		Short:   "Initialize picoclaw configuration and workspace",
-		// Run without subcommands → original onboard flow
 		Run: func(cmd *cobra.Command, args []string) {
-			if len(args) == 0 {
+			onboard()
-				onboard(encrypt)
-			} else {
-				_ = cmd.Help()
-			}
 		},
 	}
 
-	cmd.Flags().BoolVar(&encrypt, "enc", false,
-		"Enable credential encryption (generates SSH key and prompts for passphrase)")
-
 	return cmd
 }

cmd/picoclaw/internal/onboard/command_test.go

@@ -24,9 +24,6 @@ func TestNewOnboardCommand(t *testing.T) {
 	assert.Nil(t, cmd.PersistentPreRun)
 	assert.Nil(t, cmd.PersistentPostRun)
 
-	assert.True(t, cmd.HasFlags())
+	assert.False(t, cmd.HasFlags())
-	encFlag := cmd.Flags().Lookup("enc")
-	require.NotNil(t, encFlag, "expected --enc flag to be registered")
-	assert.Equal(t, "false", encFlag.DefValue, "--enc should default to false")
 	assert.False(t, cmd.HasSubCommands())
 }

cmd/picoclaw/internal/onboard/helpers.go

@@ -6,72 +6,25 @@ import (
 	"os"
 	"path/filepath"
 
-	"golang.org/x/term"
-
 	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
-	"github.com/sipeed/picoclaw/cmd/picoclaw/internal/cliui"
 	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/credential"
 )
 
-func onboard(encrypt bool) {
+func onboard() {
 	configPath := internal.GetConfigPath()
 
-	configExists := false
 	if _, err := os.Stat(configPath); err == nil {
-		configExists = true
+		fmt.Printf("Config already exists at %s\n", configPath)
-		if encrypt {
+		fmt.Print("Overwrite? (y/n): ")
-			// Only ask for confirmation when *both* config and SSH key already exist,
+		var response string
-			// indicating a full re-onboard that would reset the config to defaults.
+		fmt.Scanln(&response)
-			sshKeyPath, _ := credential.DefaultSSHKeyPath()
+		if response != "y" {
-			if _, err := os.Stat(sshKeyPath); err == nil {
+			fmt.Println("Aborted.")
-				// Both exist — confirm a full reset.
+			return
-				fmt.Printf("Config already exists at %s\n", configPath)
-				fmt.Print("Overwrite config with defaults? (y/n): ")
-				var response string
-				fmt.Scanln(&response)
-				if response != "y" {
-					fmt.Println("Aborted.")
-					return
-				}
-				configExists = false // user agreed to reset; treat as fresh
-			}
-			// Config exists but SSH key is missing — keep existing config, only add SSH key.
 		}
 	}
 
-	var err error
+	cfg := config.DefaultConfig()
-	if encrypt {
-		fmt.Println("\nSet up credential encryption")
-		fmt.Println("-----------------------------")
-		passphrase, pErr := promptPassphrase()
-		if pErr != nil {
-			fmt.Printf("Error: %v\n", pErr)
-			os.Exit(1)
-		}
-		// Expose the passphrase to credential.PassphraseProvider (which calls
-		// os.Getenv by default) so that SaveConfig can encrypt api_keys.
-		// This process is a one-shot CLI tool; the env var is never exposed outside
-		// the current process and disappears when it exits.
-		os.Setenv(credential.PassphraseEnvVar, passphrase)
-
-		if err = setupSSHKey(); err != nil {
-			fmt.Printf("Error generating SSH key: %v\n", err)
-			os.Exit(1)
-		}
-	}
-
-	var cfg *config.Config
-	if configExists {
-		// Preserve the existing config; SaveConfig will re-encrypt api_keys with the new passphrase.
-		cfg, err = config.LoadConfig(configPath)
-		if err != nil {
-			fmt.Printf("Error loading existing config: %v\n", err)
-			os.Exit(1)
-		}
-	} else {
-		cfg = config.DefaultConfig()
-	}
 	if err := config.SaveConfig(configPath, cfg); err != nil {
 		fmt.Printf("Error saving config: %v\n", err)
 		os.Exit(1)
@@ -80,62 +33,17 @@ func onboard(encrypt bool) {
 	workspace := cfg.WorkspacePath()
 	createWorkspaceTemplates(workspace)
 
-	cliui.PrintOnboardComplete(internal.Logo, encrypt, configPath)
+	fmt.Printf("%s picoclaw is ready!\n", internal.Logo)
-}
+	fmt.Println("\nNext steps:")
-
+	fmt.Println("  1. Add your API key to", configPath)
-// promptPassphrase reads the encryption passphrase twice from the terminal
+	fmt.Println("")
-// (with echo disabled) and returns it. Returns an error if the passphrase is
+	fmt.Println("     Recommended:")
-// empty or if the two inputs do not match.
+	fmt.Println("     - OpenRouter: https://openrouter.ai/keys (access 100+ models)")
-func promptPassphrase() (string, error) {
+	fmt.Println("     - Ollama:     https://ollama.com (local, free)")
-	fmt.Print("Enter passphrase for credential encryption: ")
+	fmt.Println("")
-	p1, err := term.ReadPassword(int(os.Stdin.Fd()))
+	fmt.Println("     See README.md for 17+ supported providers.")
-	fmt.Println()
+	fmt.Println("")
-	if err != nil {
+	fmt.Println("  2. Chat: picoclaw agent -m \"Hello!\"")
-		return "", fmt.Errorf("reading passphrase: %w", err)
-	}
-	if len(p1) == 0 {
-		return "", fmt.Errorf("passphrase must not be empty")
-	}
-
-	fmt.Print("Confirm passphrase: ")
-	p2, err := term.ReadPassword(int(os.Stdin.Fd()))
-	fmt.Println()
-	if err != nil {
-		return "", fmt.Errorf("reading passphrase confirmation: %w", err)
-	}
-
-	if string(p1) != string(p2) {
-		return "", fmt.Errorf("passphrases do not match")
-	}
-	return string(p1), nil
-}
-
-// setupSSHKey generates the picoclaw-specific SSH key at ~/.ssh/picoclaw_ed25519.key.
-// If the key already exists the user is warned and asked to confirm overwrite.
-// Answering anything other than "y" keeps the existing key (not an error).
-func setupSSHKey() error {
-	keyPath, err := credential.DefaultSSHKeyPath()
-	if err != nil {
-		return fmt.Errorf("cannot determine SSH key path: %w", err)
-	}
-
-	if _, err := os.Stat(keyPath); err == nil {
-		fmt.Printf("\n⚠️  WARNING: %s already exists.\n", keyPath)
-		fmt.Println("    Overwriting will invalidate any credentials previously encrypted with this key.")
-		fmt.Print("    Overwrite? (y/n): ")
-		var response string
-		fmt.Scanln(&response)
-		if response != "y" {
-			fmt.Println("Keeping existing SSH key.")
-			return nil
-		}
-	}
-
-	if err := credential.GenerateSSHKey(keyPath); err != nil {
-		return err
-	}
-	fmt.Printf("SSH key generated: %s\n", keyPath)
-	return nil
 }
 
 func createWorkspaceTemplates(workspace string) {
@@ -172,9 +80,6 @@ func copyEmbeddedToTarget(targetDir string) error {
 		if err != nil {
 			return fmt.Errorf("Failed to get relative path for %s: %v\n", path, err)
 		}
-		if new_path == "AGENTS.md" || new_path == "IDENTITY.md" {
-			return nil
-		}
 
 		// Build target file path
 		targetPath := filepath.Join(targetDir, new_path)

cmd/picoclaw/internal/onboard/helpers_test.go

@@ -1,37 +0,0 @@
-package onboard
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestCopyEmbeddedToTargetUsesStructuredAgentFiles(t *testing.T) {
-	targetDir := t.TempDir()
-
-	if err := copyEmbeddedToTarget(targetDir); err != nil {
-		t.Fatalf("copyEmbeddedToTarget() error = %v", err)
-	}
-
-	agentPath := filepath.Join(targetDir, "AGENT.md")
-	if _, err := os.Stat(agentPath); err != nil {
-		t.Fatalf("expected %s to exist: %v", agentPath, err)
-	}
-
-	soulPath := filepath.Join(targetDir, "SOUL.md")
-	if _, err := os.Stat(soulPath); err != nil {
-		t.Fatalf("expected %s to exist: %v", soulPath, err)
-	}
-
-	userPath := filepath.Join(targetDir, "USER.md")
-	if _, err := os.Stat(userPath); err != nil {
-		t.Fatalf("expected %s to exist: %v", userPath, err)
-	}
-
-	for _, legacyName := range []string{"AGENTS.md", "IDENTITY.md"} {
-		legacyPath := filepath.Join(targetDir, legacyName)
-		if _, err := os.Stat(legacyPath); !os.IsNotExist(err) {
-			t.Fatalf("expected legacy file %s to be absent, got err=%v", legacyPath, err)
-		}
-	}
-}

cmd/picoclaw/internal/skills/command.go

@@ -12,6 +12,7 @@ import (
 
 type deps struct {
 	workspace    string
+	installer    *skills.SkillInstaller
 	skillsLoader *skills.SkillsLoader
 }
 
@@ -28,6 +29,7 @@ func NewSkillsCommand() *cobra.Command {
 			}
 
 			d.workspace = cfg.WorkspacePath()
+			d.installer = skills.NewSkillInstaller(d.workspace)
 
 			// get global config directory and builtin skills directory
 			globalDir := filepath.Dir(internal.GetConfigPath())
@@ -42,6 +44,13 @@ func NewSkillsCommand() *cobra.Command {
 		},
 	}
 
+	installerFn := func() (*skills.SkillInstaller, error) {
+		if d.installer == nil {
+			return nil, fmt.Errorf("skills installer is not initialized")
+		}
+		return d.installer, nil
+	}
+
 	loaderFn := func() (*skills.SkillsLoader, error) {
 		if d.skillsLoader == nil {
 			return nil, fmt.Errorf("skills loader is not initialized")
@@ -58,11 +67,11 @@ func NewSkillsCommand() *cobra.Command {
 
 	cmd.AddCommand(
 		newListCommand(loaderFn),
-		newInstallCommand(),
+		newInstallCommand(installerFn),
 		newInstallBuiltinCommand(workspaceFn),
 		newListBuiltinCommand(),
-		newRemoveCommand(),
+		newRemoveCommand(installerFn),
-		newSearchCommand(),
+		newSearchCommand(installerFn),
 		newShowCommand(loaderFn),
 	)
 

cmd/picoclaw/internal/skills/helpers.go

@@ -2,7 +2,6 @@ package skills
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -12,23 +11,10 @@ import (
 
 	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
 	"github.com/sipeed/picoclaw/pkg/config"
-	"github.com/sipeed/picoclaw/pkg/fileutil"
 	"github.com/sipeed/picoclaw/pkg/skills"
 	"github.com/sipeed/picoclaw/pkg/utils"
 )
 
-const skillsSearchMaxResults = 20
-
-type installedSkillOriginMeta struct {
-	Version          int    `json:"version"`
-	OriginKind       string `json:"origin_kind,omitempty"`
-	Registry         string `json:"registry,omitempty"`
-	Slug             string `json:"slug,omitempty"`
-	RegistryURL      string `json:"registry_url,omitempty"`
-	InstalledVersion string `json:"installed_version,omitempty"`
-	InstalledAt      int64  `json:"installed_at"`
-}
-
 func skillsListCmd(loader *skills.SkillsLoader) {
 	allSkills := loader.ListSkills()
 
@@ -47,32 +33,50 @@ func skillsListCmd(loader *skills.SkillsLoader) {
 	}
 }
 
+func skillsInstallCmd(installer *skills.SkillInstaller, repo string) error {
+	fmt.Printf("Installing skill from %s...\n", repo)
+
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	if err := installer.InstallFromGitHub(ctx, repo); err != nil {
+		return fmt.Errorf("failed to install skill: %w", err)
+	}
+
+	fmt.Printf("\u2713 Skill '%s' installed successfully!\n", filepath.Base(repo))
+
+	return nil
+}
+
 // skillsInstallFromRegistry installs a skill from a named registry (e.g. clawhub).
-func skillsInstallFromRegistry(cfg *config.Config, registryName, target string) error {
+func skillsInstallFromRegistry(cfg *config.Config, registryName, slug string) error {
 	err := utils.ValidateSkillIdentifier(registryName)
 	if err != nil {
 		return fmt.Errorf("✗  invalid registry name: %w", err)
 	}
 
-	registryMgr := skills.NewRegistryManagerFromToolsConfig(cfg.Tools.Skills)
+	err = utils.ValidateSkillIdentifier(slug)
+	if err != nil {
+		return fmt.Errorf("✗  invalid slug: %w", err)
+	}
+
+	fmt.Printf("Installing skill '%s' from %s registry...\n", slug, registryName)
+
+	registryMgr := skills.NewRegistryManagerFromConfig(skills.RegistryConfig{
+		MaxConcurrentSearches: cfg.Tools.Skills.MaxConcurrentSearches,
+		ClawHub:               skills.ClawHubConfig(cfg.Tools.Skills.Registries.ClawHub),
+	})
 
 	registry := registryMgr.GetRegistry(registryName)
 	if registry == nil {
 		return fmt.Errorf("✗  registry '%s' not found or not enabled. check your config.json.", registryName)
 	}
 
-	dirName, err := registry.ResolveInstallDirName(target)
-	if err != nil {
-		return fmt.Errorf("✗  invalid install target %q: %w", target, err)
-	}
-
-	fmt.Printf("Installing skill '%s' from %s registry...\n", target, registryName)
-
 	workspace := cfg.WorkspacePath()
-	targetDir := filepath.Join(workspace, "skills", dirName)
+	targetDir := filepath.Join(workspace, "skills", slug)
 
 	if _, err = os.Stat(targetDir); err == nil {
-		return fmt.Errorf("\u2717 skill '%s' already installed at %s", dirName, targetDir)
+		return fmt.Errorf("\u2717 skill '%s' already installed at %s", slug, targetDir)
 	}
 
 	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
@@ -82,7 +86,7 @@ func skillsInstallFromRegistry(cfg *config.Config, registryName, target string)
 		return fmt.Errorf("\u2717 failed to create skills directory: %v", err)
 	}
 
-	result, err := registry.DownloadAndInstall(ctx, target, "", targetDir)
+	result, err := registry.DownloadAndInstall(ctx, slug, "", targetDir)
 	if err != nil {
 		rmErr := os.RemoveAll(targetDir)
 		if rmErr != nil {
@@ -97,34 +101,14 @@ func skillsInstallFromRegistry(cfg *config.Config, registryName, target string)
 			fmt.Printf("\u2717 Failed to remove partial install: %v\n", rmErr)
 		}
 
-		return fmt.Errorf("\u2717 Skill '%s' is flagged as malicious and cannot be installed.\n", target)
+		return fmt.Errorf("\u2717 Skill '%s' is flagged as malicious and cannot be installed.\n", slug)
 	}
 
 	if result.IsSuspicious {
-		fmt.Printf("\u26a0\ufe0f  Warning: skill '%s' is flagged as suspicious.\n", target)
+		fmt.Printf("\u26a0\ufe0f  Warning: skill '%s' is flagged as suspicious.\n", slug)
 	}
 
-	if !workspaceHasValidSkillDirectory(workspace, dirName) {
+	fmt.Printf("\u2713 Skill '%s' v%s installed successfully!\n", slug, result.Version)
-		_ = os.RemoveAll(targetDir)
-		return fmt.Errorf("✗ failed to install skill: registry archive for %q is not a valid skill", target)
-	}
-
-	normalizedSlug, registryURL := skills.BuildInstallMetadataForRegistryInstance(registry, target, result.Version)
-	installedAt := time.Now().UnixMilli()
-	if err := writeInstalledSkillOriginMeta(targetDir, installedSkillOriginMeta{
-		Version:          1,
-		OriginKind:       "third_party",
-		Registry:         registry.Name(),
-		Slug:             normalizedSlug,
-		RegistryURL:      registryURL,
-		InstalledVersion: result.Version,
-		InstalledAt:      installedAt,
-	}); err != nil {
-		_ = os.RemoveAll(targetDir)
-		return fmt.Errorf("✗ failed to persist skill metadata: %w", err)
-	}
-
-	fmt.Printf("\u2713 Skill '%s' v%s installed successfully!\n", dirName, result.Version)
 	if result.Summary != "" {
 		fmt.Printf("  %s\n", result.Summary)
 	}
@@ -132,51 +116,15 @@ func skillsInstallFromRegistry(cfg *config.Config, registryName, target string)
 	return nil
 }
 
-func writeInstalledSkillOriginMeta(targetDir string, meta installedSkillOriginMeta) error {
+func skillsRemoveCmd(installer *skills.SkillInstaller, skillName string) {
-	data, err := json.MarshalIndent(meta, "", "  ")
+	fmt.Printf("Removing skill '%s'...\n", skillName)
-	if err != nil {
-		return err
-	}
-	return fileutil.WriteFileAtomic(filepath.Join(targetDir, ".skill-origin.json"), data, 0o600)
-}
 
-func workspaceHasValidSkillDirectory(workspace, directory string) bool {
+	if err := installer.Uninstall(skillName); err != nil {
-	loader := skills.NewSkillsLoader(workspace, "", "")
+		fmt.Printf("✗ Failed to remove skill: %v\n", err)
-	for _, skill := range loader.ListSkills() {
+		os.Exit(1)
-		if skill.Source != "workspace" {
-			continue
-		}
-		if filepath.Base(filepath.Dir(skill.Path)) == directory {
-			return true
-		}
 	}
-	return false
-}
 
-func skillsRemoveFromWorkspace(workspace string, toolsConfig config.SkillsToolsConfig, skillName string) error {
+	fmt.Printf("✓ Skill '%s' removed successfully!\n", skillName)
-	name := strings.TrimSpace(skillName)
-	name = strings.Trim(name, "/")
-	if name == "" {
-		return fmt.Errorf("skill name is required")
-	}
-	if strings.Contains(name, "/") {
-		dirName, err := skills.GitHubInstallDirNameFromToolsConfig(toolsConfig, name)
-		if err != nil || dirName == "" {
-			return fmt.Errorf("invalid skill name %q", skillName)
-		}
-		name = dirName
-	}
-	if name == "." || name == ".." {
-		return fmt.Errorf("invalid skill name %q", skillName)
-	}
-	skillDir := filepath.Join(workspace, "skills", name)
-	if _, err := os.Stat(skillDir); os.IsNotExist(err) {
-		return fmt.Errorf("skill '%s' not found", name)
-	}
-	if err := os.RemoveAll(skillDir); err != nil {
-		return fmt.Errorf("failed to remove skill '%s': %w", name, err)
-	}
-	return nil
 }
 
 func skillsInstallBuiltinCmd(workspace string) {
@@ -267,40 +215,34 @@ func skillsListBuiltinCmd() {
 	}
 }
 
-func skillsSearchCmd(query string) {
+func skillsSearchCmd(installer *skills.SkillInstaller) {
 	fmt.Println("Searching for available skills...")
 
-	cfg, err := internal.LoadConfig()
-	if err != nil {
-		fmt.Printf("✗ Failed to load config: %v\n", err)
-		return
-	}
-
-	registryMgr := skills.NewRegistryManagerFromToolsConfig(cfg.Tools.Skills)
-
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-	results, err := registryMgr.SearchAll(ctx, query, skillsSearchMaxResults)
+	availableSkills, err := installer.ListAvailableSkills(ctx)
 	if err != nil {
 		fmt.Printf("✗ Failed to fetch skills list: %v\n", err)
 		return
 	}
 
-	if len(results) == 0 {
+	if len(availableSkills) == 0 {
 		fmt.Println("No skills available.")
 		return
 	}
 
-	fmt.Printf("\nAvailable Skills (%d):\n", len(results))
+	fmt.Printf("\nAvailable Skills (%d):\n", len(availableSkills))
 	fmt.Println("--------------------")
-	for _, result := range results {
+	for _, skill := range availableSkills {
-		fmt.Printf("  📦 %s\n", result.DisplayName)
+		fmt.Printf("  📦 %s\n", skill.Name)
-		fmt.Printf("     %s\n", result.Summary)
+		fmt.Printf("     %s\n", skill.Description)
-		fmt.Printf("     Slug: %s\n", result.Slug)
+		fmt.Printf("     Repo: %s\n", skill.Repository)
-		fmt.Printf("     Registry: %s\n", result.RegistryName)
+		if skill.Author != "" {
-		if result.Version != "" {
+			fmt.Printf("     Author: %s\n", skill.Author)
-			fmt.Printf("     Version: %s\n", result.Version)
+		}
+		if len(skill.Tags) > 0 {
+			fmt.Printf("     Tags: %v\n", skill.Tags)
 		}
 		fmt.Println()
 	}

cmd/picoclaw/internal/skills/helpers_test.go

@@ -1,191 +0,0 @@
-package skills
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/sipeed/picoclaw/pkg/config"
-)
-
-func TestSkillsInstallFromRegistryWritesOriginMetadata(t *testing.T) {
-	workspace := t.TempDir()
-	cfg := config.DefaultConfig()
-	cfg.Agents.Defaults.Workspace = workspace
-
-	var server *httptest.Server
-	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v3/repos/foo/bar":
-			require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"default_branch": "master"}))
-		case "/api/v3/repos/foo/bar/contents/.agents/skills/pr-review":
-			assert.Equal(t, "ref=master", r.URL.RawQuery)
-			require.NoError(t, json.NewEncoder(w).Encode([]map[string]any{{
-				"type":         "file",
-				"name":         "SKILL.md",
-				"download_url": server.URL + "/raw/foo/bar/master/.agents/skills/pr-review/SKILL.md",
-			}}))
-		case "/raw/foo/bar/master/.agents/skills/pr-review/SKILL.md":
-			_, _ = w.Write([]byte("---\nname: pr-review\ndescription: PR review skill\n---\n# PR Review\n"))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	githubRegistry, ok := cfg.Tools.Skills.Registries.Get("github")
-	require.True(t, ok)
-	githubRegistry.BaseURL = server.URL
-	cfg.Tools.Skills.Registries.Set("github", githubRegistry)
-
-	target := server.URL + "/foo/bar/tree/master/.agents/skills/pr-review"
-	require.NoError(t, skillsInstallFromRegistry(cfg, "github", target))
-
-	metaPath := filepath.Join(workspace, "skills", "pr-review", ".skill-origin.json")
-	data, err := os.ReadFile(metaPath)
-	require.NoError(t, err)
-
-	var meta installedSkillOriginMeta
-	require.NoError(t, json.Unmarshal(data, &meta))
-	assert.Equal(t, "third_party", meta.OriginKind)
-	assert.Equal(t, "github", meta.Registry)
-	assert.Equal(t, "foo/bar/.agents/skills/pr-review", meta.Slug)
-	assert.Equal(t, server.URL+"/foo/bar/tree/master/.agents/skills/pr-review", meta.RegistryURL)
-	assert.Equal(t, "master", meta.InstalledVersion)
-	assert.NotZero(t, meta.InstalledAt)
-}
-
-func TestSkillsInstallFromRegistryRejectsInvalidSkillArchive(t *testing.T) {
-	workspace := t.TempDir()
-	cfg := config.DefaultConfig()
-	cfg.Agents.Defaults.Workspace = workspace
-
-	var server *httptest.Server
-	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/v3/repos/foo/bar":
-			require.NoError(t, json.NewEncoder(w).Encode(map[string]any{"default_branch": "master"}))
-		case "/api/v3/repos/foo/bar/contents/.agents/skills/pr-review":
-			require.NoError(t, json.NewEncoder(w).Encode([]map[string]any{{
-				"type":         "file",
-				"name":         "SKILL.md",
-				"download_url": server.URL + "/raw/foo/bar/master/.agents/skills/pr-review/SKILL.md",
-			}}))
-		case "/raw/foo/bar/master/.agents/skills/pr-review/SKILL.md":
-			_, _ = w.Write([]byte("---\nname: bad_skill\ndescription: Invalid skill name\n---\n# Invalid\n"))
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	githubRegistry, ok := cfg.Tools.Skills.Registries.Get("github")
-	require.True(t, ok)
-	githubRegistry.BaseURL = server.URL
-	cfg.Tools.Skills.Registries.Set("github", githubRegistry)
-
-	target := server.URL + "/foo/bar/tree/master/.agents/skills/pr-review"
-	err := skillsInstallFromRegistry(cfg, "github", target)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "is not a valid skill")
-	_, statErr := os.Stat(filepath.Join(workspace, "skills", "pr-review"))
-	assert.True(t, os.IsNotExist(statErr))
-}
-
-func TestSkillsRemoveFromWorkspaceRejectsDotTarget(t *testing.T) {
-	workspace := t.TempDir()
-	skillsDir := filepath.Join(workspace, "skills")
-	require.NoError(t, os.MkdirAll(skillsDir, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(skillsDir, "keep.txt"), []byte("keep"), 0o644))
-
-	err := skillsRemoveFromWorkspace(workspace, config.DefaultConfig().Tools.Skills, ".")
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid skill name")
-
-	_, statErr := os.Stat(skillsDir)
-	assert.NoError(t, statErr)
-	_, fileErr := os.Stat(filepath.Join(skillsDir, "keep.txt"))
-	assert.NoError(t, fileErr)
-}
-
-func TestSkillsRemoveFromWorkspaceUsesLastPathSegment(t *testing.T) {
-	workspace := t.TempDir()
-	targetDir := filepath.Join(workspace, "skills", "pr-review")
-	require.NoError(t, os.MkdirAll(targetDir, 0o755))
-
-	err := skillsRemoveFromWorkspace(
-		workspace,
-		config.DefaultConfig().Tools.Skills,
-		"https://github.com/foo/bar/tree/main/.agents/skills/pr-review",
-	)
-	require.NoError(t, err)
-
-	_, statErr := os.Stat(targetDir)
-	assert.True(t, os.IsNotExist(statErr))
-}
-
-func TestSkillsRemoveFromWorkspaceSupportsRepoRootGitHubBlobURL(t *testing.T) {
-	workspace := t.TempDir()
-	targetDir := filepath.Join(workspace, "skills", "bar")
-	require.NoError(t, os.MkdirAll(targetDir, 0o755))
-
-	err := skillsRemoveFromWorkspace(
-		workspace,
-		config.DefaultConfig().Tools.Skills,
-		"https://github.com/foo/bar/blob/feature/skills-registry/SKILL.md",
-	)
-	require.NoError(t, err)
-
-	_, statErr := os.Stat(targetDir)
-	assert.True(t, os.IsNotExist(statErr))
-}
-
-func TestSkillsRemoveFromWorkspaceSupportsGitHubEnterpriseURL(t *testing.T) {
-	workspace := t.TempDir()
-	targetDir := filepath.Join(workspace, "skills", "pr-review")
-	require.NoError(t, os.MkdirAll(targetDir, 0o755))
-
-	cfg := config.DefaultConfig()
-	githubRegistry, ok := cfg.Tools.Skills.Registries.Get("github")
-	require.True(t, ok)
-	githubRegistry.BaseURL = "https://ghe.example.com/git"
-	cfg.Tools.Skills.Registries.Set("github", githubRegistry)
-
-	err := skillsRemoveFromWorkspace(
-		workspace,
-		cfg.Tools.Skills,
-		"https://ghe.example.com/git/foo/bar/tree/main/.agents/skills/pr-review",
-	)
-	require.NoError(t, err)
-
-	_, statErr := os.Stat(targetDir)
-	assert.True(t, os.IsNotExist(statErr))
-}
-
-func TestSkillsRemoveFromWorkspaceDoesNotRequireEnabledGitHubRegistry(t *testing.T) {
-	workspace := t.TempDir()
-	targetDir := filepath.Join(workspace, "skills", "pr-review")
-	require.NoError(t, os.MkdirAll(targetDir, 0o755))
-
-	cfg := config.DefaultConfig()
-	githubRegistry, ok := cfg.Tools.Skills.Registries.Get("github")
-	require.True(t, ok)
-	githubRegistry.Enabled = false
-	cfg.Tools.Skills.Registries.Set("github", githubRegistry)
-
-	err := skillsRemoveFromWorkspace(
-		workspace,
-		cfg.Tools.Skills,
-		"https://github.com/foo/bar/tree/main/.agents/skills/pr-review",
-	)
-	require.NoError(t, err)
-
-	_, statErr := os.Stat(targetDir)
-	assert.True(t, os.IsNotExist(statErr))
-}

cmd/picoclaw/internal/skills/install.go

@@ -6,22 +6,23 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/sipeed/picoclaw/cmd/picoclaw/internal"
+	"github.com/sipeed/picoclaw/pkg/skills"
 )
 
-func newInstallCommand() *cobra.Command {
+func newInstallCommand(installerFn func() (*skills.SkillInstaller, error)) *cobra.Command {
 	var registry string
 
 	cmd := &cobra.Command{
 		Use:   "install",
-		Short: "Install skill from GitHub or a registry",
+		Short: "Install skill from GitHub",
 		Example: `
 picoclaw skills install sipeed/picoclaw-skills/weather
 picoclaw skills install --registry clawhub github
 `,
 		Args: func(cmd *cobra.Command, args []string) error {
 			if registry != "" {
-				if len(args) != 1 {
+				if len(args) != 2 {
-					return fmt.Errorf("when --registry is set, exactly 1 argument is required: <slug>")
+					return fmt.Errorf("when --registry is set, exactly 2 arguments are required: <name> <slug>")
 				}
 				return nil
 			}
@@ -33,15 +34,21 @@ picoclaw skills install --registry clawhub github
 			return nil
 		},
 		RunE: func(_ *cobra.Command, args []string) error {
-			cfg, err := internal.LoadConfig()
+			installer, err := installerFn()
 			if err != nil {
 				return err
 			}
+
 			if registry != "" {
-				return skillsInstallFromRegistry(cfg, registry, args[0])
+				cfg, err := internal.LoadConfig()
+				if err != nil {
+					return err
+				}
+
+				return skillsInstallFromRegistry(cfg, args[0], args[1])
 			}
 
-			return skillsInstallFromRegistry(cfg, "github", args[0])
+			return skillsInstallCmd(installer, args[0])
 		},
 	}