feat: migrate from Python Claude Agent SDK to Vercel AI SDK v6 (TypeScript)

CLAUDE.md

@@ -2,7 +2,7 @@
 
 This file provides guidance to Claude Code when working with this repository.
 
-Auto Claude is an autonomous multi-agent coding framework that plans, builds, and validates software for you. It's a monorepo with a Python backend (CLI + agent logic) and an Electron/React frontend (desktop UI).
+Auto Claude is an autonomous multi-agent coding framework that plans, builds, and validates software for you. It's a monorepo with an Electron/React frontend (desktop UI + TypeScript AI agent layer) and a Python backend (CLI utilities + Graphiti memory sidecar).
 
 > **Deep-dive reference:** [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md) | **Frontend contributing:** [apps/frontend/CONTRIBUTING.md](apps/frontend/CONTRIBUTING.md)
 
@@ -30,11 +30,11 @@ Auto Claude is a desktop application (+ CLI) where users describe a goal and AI
 
 ## Critical Rules
 
-**Claude Agent SDK only** — All AI interactions use `claude-agent-sdk`. NEVER use `anthropic.Anthropic()` directly. Always use `create_client()` from `core.client`.
+**Vercel AI SDK only** — All AI interactions use the Vercel AI SDK v6 (`ai` package) via the TypeScript agent layer in `apps/frontend/src/main/ai/`. NEVER use `@anthropic-ai/sdk` or `anthropic.Anthropic()` directly. Use `createProvider()` from `ai/providers/factory.ts` and `streamText()`/`generateText()` from the `ai` package. Provider-specific adapters (e.g., `@ai-sdk/anthropic`, `@ai-sdk/openai`) are managed through the provider registry.
 
 **i18n required** — All frontend user-facing text MUST use `react-i18next` translation keys. Never hardcode strings in JSX/TSX. Add keys to both `en/*.json` and `fr/*.json`.
 
-**Platform abstraction** — Never use `process.platform` directly. Import from `apps/frontend/src/main/platform/` or `apps/backend/core/platform/`. CI tests all three platforms.
+**Platform abstraction** — Never use `process.platform` directly. Import from `apps/frontend/src/main/platform/`. CI tests all three platforms.
 
 **No time estimates** — Never provide duration predictions. Use priority-based ordering instead.
 
@@ -68,29 +68,31 @@ To fully clear all PR review data so reviews run fresh, delete/reset these three
 ```
 autonomous-coding/
 ├── apps/
-│   ├── backend/                 # Python backend/CLI — ALL agent logic
-│   │   ├── core/                # client.py, auth.py, worktree.py, platform/
-│   │   ├── security/            # Command allowlisting, validators, hooks
-│   │   ├── agents/              # planner, coder, session management
-│   │   ├── qa/                  # reviewer, fixer, loop, criteria
-│   │   ├── spec/                # Spec creation pipeline
-│   │   ├── cli/                 # CLI commands (spec, build, workspace, QA)
-│   │   ├── context/             # Task context building, semantic search
-│   │   ├── runners/             # Standalone runners (spec, roadmap, insights, github)
-│   │   ├── services/            # Background services, recovery orchestration
-│   │   ├── integrations/        # graphiti/, linear, github
-│   │   ├── project/             # Project analysis, security profiles
-│   │   ├── merge/               # Intent-aware semantic merge for parallel agents
+│   ├── backend/                 # Python backend — Graphiti memory sidecar + CLI utilities
+│   │   ├── core/                # worktree.py, platform/
+│   │   ├── integrations/        # graphiti/ (MCP sidecar)
 │   │   └── prompts/             # Agent system prompts (.md)
 │   └── frontend/                # Electron desktop UI
 │       └── src/
 │           ├── main/            # Electron main process
+│           │   ├── ai/          # TypeScript AI agent layer (Vercel AI SDK v6)
+│           │   │   ├── providers/   # Multi-provider registry + factory (9+ providers)
+│           │   │   ├── tools/       # Builtin tools (Read, Write, Edit, Bash, Glob, Grep, etc.)
+│           │   │   ├── security/    # Bash validator, command parser, path containment
+│           │   │   ├── config/      # Agent configs (25+ types), phase config, model resolution
+│           │   │   ├── session/     # streamText() agent loop, error classification, progress
+│           │   │   ├── agent/       # Worker thread executor + bridge
+│           │   │   ├── orchestration/ # Build pipeline (planner → coder → QA)
+│           │   │   ├── runners/     # Utility runners (insights, roadmap, PR review, etc.)
+│           │   │   ├── mcp/         # MCP client integration
+│           │   │   ├── client/      # Client factory convenience constructors
+│           │   │   └── auth/        # Token resolution (reuses claude-profile/)
 │           │   ├── agent/       # Agent queue, process, state, events
 │           │   ├── claude-profile/ # Multi-profile credentials, token refresh, usage
 │           │   ├── terminal/    # PTY daemon, lifecycle, Claude integration
 │           │   ├── platform/    # Cross-platform abstraction
 │           │   ├── ipc-handlers/# 40+ handler modules by domain
-│           │   ├── services/    # SDK session recovery, profile service
+│           │   ├── services/    # Session recovery, profile service
 │           │   └── changelog/   # Changelog generation and formatting
 │           ├── preload/         # Electron preload scripts (electronAPI bridge)
 │           ├── renderer/        # React UI
@@ -117,18 +119,15 @@ autonomous-coding/
 ```bash
 npm run install:all              # Install all dependencies from root
 # Or separately:
-cd apps/backend && uv venv && uv pip install -r requirements.txt
 cd apps/frontend && npm install
 ```
 
 ### Testing
 
 | Stack | Command | Tool |
 |-------|---------|------|
-| Backend | `apps/backend/.venv/bin/pytest tests/ -v` | pytest |
 | Frontend unit | `cd apps/frontend && npm test` | Vitest |
 | Frontend E2E | `cd apps/frontend && npm run test:e2e` | Playwright |
-| All backend | `npm run test:backend` (from root) | pytest |
 
 ### Releases
 ```bash
@@ -138,13 +137,51 @@ git push && gh pr create --base main             # PR to main triggers release
 
 See [RELEASE.md](RELEASE.md) for full release process.
 
-## Backend Development
-
-### Claude Agent SDK Usage
-
-Client: `apps/backend/core/client.py` — `create_client()` returns a configured `ClaudeSDKClient` with security hooks, tool permissions, and MCP server integration.
-
-Model and thinking level are user-configurable (via the Electron UI settings or CLI override). Use `phase_config.py` helpers to resolve the correct values
+## AI Agent Layer (`apps/frontend/src/main/ai/`)
+
+All AI agent logic lives in TypeScript using the Vercel AI SDK v6. This replaces the previous Python `claude-agent-sdk` integration.
+
+### Architecture Overview
+
+- **Provider Layer** (`providers/`) — Multi-provider support via `createProviderRegistry()`. Supports Anthropic, OpenAI, Google, Bedrock, Azure, Mistral, Groq, xAI, and Ollama. Provider-specific transforms handle thinking token normalization and prompt caching.
+- **Session Runtime** (`session/`) — `runAgentSession()` uses `streamText()` with `stopWhen: stepCountIs(N)` for agentic tool-use loops. Includes error classification (429/401/400) and progress tracking.
+- **Worker Threads** (`agent/`) — Agent sessions run in `worker_threads` to avoid blocking the Electron main process. The `WorkerBridge` relays `postMessage()` events to the existing `AgentManagerEvents` interface.
+- **Build Orchestration** (`orchestration/`) — Full planner → coder → QA pipeline. Parallel subagent execution via `Promise.allSettled()`.
+- **Tools** (`tools/`) — 8 builtin tools (Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch) defined with Zod schemas via AI SDK `tool()`.
+- **Security** (`security/`) — Bash validator, command parser, and path containment ported from Python with identical allowlist behavior.
+- **Config** (`config/`) — `AGENT_CONFIGS` registry (25+ agent types), phase-aware model resolution, thinking budgets.
+
+### Key Patterns
+
+```typescript
+// Agent session using streamText()
+import { streamText, stepCountIs } from 'ai';
+
+const result = streamText({
+  model: provider,
+  system: systemPrompt,
+  messages: conversationHistory,
+  tools: toolRegistry.getToolsForAgent(agentType),
+  stopWhen: stepCountIs(1000),
+  onStepFinish: ({ toolCalls, text, usage }) => {
+    progressTracker.update(toolCalls, text);
+  },
+});
+
+// Tool definition with Zod schema
+import { tool } from 'ai';
+import { z } from 'zod';
+
+const readTool = tool({
+  description: 'Read a file from the filesystem',
+  inputSchema: z.object({
+    file_path: z.string(),
+    offset: z.number().optional(),
+    limit: z.number().optional(),
+  }),
+  execute: async ({ file_path, offset, limit }) => { /* ... */ },
+});
+```
 
 ### Agent Prompts (`apps/backend/prompts/`)
 
@@ -162,13 +199,13 @@ Each spec in `.auto-claude/specs/XXX-name/` contains: `spec.md`, `requirements.j
 
 ### Memory System (Graphiti)
 
-Graph-based semantic memory in `integrations/graphiti/`. Configured through the Electron app's onboarding/settings UI (CLI users can alternatively set `GRAPHITI_ENABLED=true` in `.env`). See [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md#memory-system) for details.
+Graph-based semantic memory accessed via MCP sidecar (`integrations/graphiti/`). The Python Graphiti sidecar remains; the AI layer connects to it via `createMCPClient` from `@ai-sdk/mcp`. Configured through the Electron app's onboarding/settings UI. See [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md#memory-system) for details.
 
 ## Frontend Development
 
 ### Tech Stack
 
-React 19, TypeScript (strict), Electron 39, Zustand 5, Tailwind CSS v4, Radix UI, xterm.js 6, Vite 7, Vitest 4, Biome 2, Motion (Framer Motion)
+React 19, TypeScript (strict), Electron 39, Vercel AI SDK v6, Zustand 5, Tailwind CSS v4, Radix UI, xterm.js 6, Vite 7, Vitest 4, Biome 2, Motion (Framer Motion)
 
 ### Path Aliases (tsconfig.json)
 
@@ -214,9 +251,9 @@ Main ↔ Renderer communication via Electron IPC:
 
 The frontend manages agent lifecycle end-to-end:
 - **`agent-queue.ts`** — Queue routing, prioritization, spec number locking
-- **`agent-process.ts`** — Spawns and manages agent subprocess communication
+- **`agent-process.ts`** — Spawns worker threads via `WorkerBridge` for agent execution
 - **`agent-state.ts`** — Tracks running agent state and status
-- **`agent-events.ts`** — Agent lifecycle events and state transitions
+- **`agent-events.ts`** — Agent lifecycle events and state transitions (structured events from worker threads)
 
 ### Claude Profile System (`src/main/claude-profile/`)
 
@@ -242,9 +279,6 @@ Full PTY-based terminal integration:
 - **Pre-commit:** Husky + lint-staged runs Biome on staged `.ts/.tsx/.js/.jsx/.json`
 - **Testing:** Vitest + React Testing Library + jsdom
 
-### Backend
-- **Linting:** Ruff
-- **Testing:** pytest (`apps/backend/.venv/bin/pytest tests/ -v`)
 
 ## i18n Guidelines
 
@@ -269,7 +303,7 @@ When adding new UI text: add keys to ALL language files, use `namespace:section.
 
 Supports Windows, macOS, Linux. CI tests all three.
 
-**Platform modules:** `apps/frontend/src/main/platform/` and `apps/backend/core/platform/`
+**Platform modules:** `apps/frontend/src/main/platform/`
 
 | Function | Purpose |
 |----------|---------|
@@ -285,17 +319,14 @@ Never hardcode paths. Use `findExecutable()` and `joinPaths()`. See [ARCHITECTUR
 QA agents can interact with the running Electron app via Chrome DevTools Protocol:
 
 1. Start app: `npm run dev:debug` (debug mode for AI self-validation via Electron MCP)
-2. Set `ELECTRON_MCP_ENABLED=true` in `apps/backend/.env`
-3. Run QA: `python run.py --spec 001 --qa`
+2. Enable Electron MCP in settings
+3. QA runs automatically through the TypeScript agent pipeline
 
 Tools: `take_screenshot`, `click_by_text`, `fill_input`, `get_page_structure`, `send_keyboard_shortcut`, `eval`. See [ARCHITECTURE.md](shared_docs/ARCHITECTURE.md#end-to-end-testing) for full capabilities.
 
 ## Running the Application
 
 ```bash
-# CLI only
-cd apps/backend && python run.py --spec 001
-
 # Desktop app
 npm start          # Production build + run
 npm run dev        # Development mode with HMR