diff --git a/.impeccable.md b/.impeccable.md
new file mode 100644
index 0000000..4318ac0
--- /dev/null
+++ b/.impeccable.md
@@ -0,0 +1,41 @@
+## Design Context
+
+### Users
+Existing developer users who already understand what deployment means and come to Sealos to launch a GitHub repository quickly.
+
+Their most common contexts are:
+- quickly trying a deployment path to see if it works
+- formally deploying a real project with confidence
+
+They do not need a long explanation of the product. They need a calm surface that makes the next action obvious and fast.
+
+### Brand Personality
+Reliable, convenient, calm.
+
+The interface should feel trustworthy and efficient, with very little theatricality. It should communicate capability through clarity and reduction, not through decoration.
+
+### Aesthetic Direction
+Extreme minimalist product UI with a calm, restrained tone.
+
+Reference direction from the product owner: closer to the refinement bar of Vercel, but not a copy. The page should feel precise, sparse, and intentional, with only one obvious primary action at each step.
+
+Theme requirements:
+- support both light and dark mode
+- default to the same restrained, premium feel in both themes
+- avoid decorative color usage unless it serves hierarchy
+
+Anti-references from the product owner:
+- demo-like UI
+- backend-style form pages
+- AI landing page aesthetics
+- overly explained layouts
+- decorative backgrounds or visual effects
+- redundant controls in both header and hero
+- multiple competing action buttons
+
+### Design Principles
+1. Optimize for users who already know they want to deploy.
+2. Show only the current step and make the primary action unmistakable.
+3. Prefer structural clarity over instructional copy.
+4. Remove visual noise before adding any new element.
+5. Keep the page feeling reliable and premium in both light and dark themes.
diff --git a/AGENTS.md b/AGENTS.md
index bfb03c3..e624118 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -9,6 +9,7 @@ This document contains critical rules and guidelines for AI agents working on th
 **By default, all log statements MUST use static strings only. Dynamic values are only allowed through the task-flow logging utility in `lib/utils/task-flow-logs.ts`.**
 
 #### Bad Examples (DO NOT DO THIS):
+
 ```typescript
 // BAD - Contains dynamic values
 await logger.info(`Task created: ${taskId}`)
@@ -18,6 +19,7 @@ console.error(`Error for ${provider}:`, error)
 ```
 
 #### Good Examples (DO THIS):
+
 ```typescript
 // GOOD - Static strings only
 await logger.info('Task created')
@@ -35,6 +37,7 @@ Key task flow logs may include selected dynamic values, but only when all of the
 3. The values are operational identifiers only, not secrets or user content
 
 Examples of allowed dynamic values:
+
 - `sessionId`
 - `threadId`
 - `runtimeName`
@@ -48,17 +51,20 @@ Examples of allowed dynamic values:
 - `installedSkill`
 
 Examples that remain forbidden:
+
 - tokens, secrets, API keys, passwords
 - repository URLs and file paths
 - raw user prompts or assistant content
 - branch names, commit messages, personal identifiers
 
 #### Rationale:
+
 - **Prevents data leakage**: Dynamic values in logs can expose sensitive information (user IDs, file paths, credentials, etc.) to end users
 - **Security by default**: Logs are displayed directly in the UI and returned in API responses
 - Outside the approved task-flow utility path, this applies to ALL log levels (info, error, success, command, console.log, console.error, console.warn, etc.)
 
 #### Sensitive Data That Must NEVER Appear in Logs:
+
 - Devbox runtime credentials (DEVBOX_TOKEN, DEVBOX_JWT_SIGNING_KEY)
 - User IDs and personal information
 - File paths and repository URLs
@@ -71,8 +77,9 @@ Examples that remain forbidden:
 The `redactSensitiveInfo()` function in `lib/utils/logging.ts` automatically redacts known sensitive patterns, but this is a **backup measure only**. The primary defense is to never log dynamic values in the first place.
 
 #### Current Redaction Patterns:
+
 - API keys (ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.)
-- GitHub tokens (ghp_, gho_, ghu_, ghs_, ghr_)
+- GitHub tokens (ghp*, gho*, ghu*, ghs*, ghr\_)
 - Devbox runtime credentials (DEVBOX_TOKEN, DEVBOX_JWT_SIGNING_KEY)
 - Bearer tokens
 - JSON fields (teamId, projectId)
@@ -93,6 +100,7 @@ pnpm lint
 ```
 
 **If any errors are found:**
+
 1. **Type errors**: Fix TypeScript type errors by correcting type annotations, adding missing imports, or fixing type mismatches
 2. **Lint errors**: Fix ESLint errors by following the suggested fixes or adjusting the code to meet the linting rules
 3. **Do not skip or ignore errors** - all errors must be resolved before considering the task complete
@@ -114,12 +122,14 @@ Existing components are in `components/ui/`. See [shadcn/ui docs](https://ui.sha
 **DO NOT run development servers (e.g., `npm run dev`, `pnpm dev`, `next dev`) as they will conflict with other running instances.**
 
 #### Why This Rule Exists:
+
 - Dev servers run indefinitely and block the terminal session
 - Multiple instances on the same port cause conflicts
 - The application may already be running in the user's environment
 - Long-running processes make the conversation hang for the user
 
 #### Commands to AVOID:
+
 ```bash
 # DO NOT RUN THESE:
 npm run dev
@@ -133,6 +143,7 @@ nodemon
 ```
 
 #### What to Do Instead:
+
 1. **Type checking**: Use `pnpm type-check` to verify types
 2. **Linting**: Use `pnpm lint` to check code quality
 3. **Formatting**: Use `pnpm format` when editing TypeScript/TSX files
@@ -141,11 +152,13 @@ nodemon
 6. **If the user needs to test**: Let the user run the dev server themselves
 
 #### Exception:
+
 If the user explicitly asks you to start a dev server, politely explain why you cannot do this and suggest they run it themselves instead.
 
 ### Logging Best Practices
 
 1. **Use descriptive static messages**
+
    ```typescript
    // Instead of logging the value, log the action
    await logger.info('Sandbox created successfully')
@@ -154,6 +167,7 @@ If the user explicitly asks you to start a dev server, politely explain why you
    ```
 
 2. **Server-side logging for debugging**
+
    ```typescript
    // Use console.error for server-side debugging (not shown to users)
    // But still avoid sensitive data
@@ -170,6 +184,7 @@ If the user explicitly asks you to start a dev server, politely explain why you
 ### Error Handling
 
 1. **Generic error messages to users**
+
    ```typescript
    await logger.error('Operation failed')
    // NOT: await logger.error(`Operation failed: ${error.message}`)
@@ -186,10 +201,11 @@ If the user explicitly asks you to start a dev server, politely explain why you
 When making changes that involve logging:
 
 1. **Search for dynamic values**
+
    ```bash
    # Check for logger statements with template literals
    grep -r "logger\.(info|error|success|command)\(\`.*\$\{" .
-   
+
    # Check for console statements with template literals
    grep -r "console\.(log|error|warn|info)\(\`.*\$\{" .
    ```
@@ -204,9 +220,13 @@ When making changes that involve logging:
 ### Environment Variables
 
 Never expose these in logs or to the client:
+
+- `POSTGRES_URL` - Database connection string that may contain credentials
+- `SEALOS_HOST` - Sealos cluster host configuration
 - `DEVBOX_TOKEN` - Devbox runtime API token
 - `DEVBOX_JWT_SIGNING_KEY` - Devbox JWT signing secret
-- `DEVBOX_GATEWAY_URL_TEMPLATE` - Devbox gateway URL template
+
+- `AI_GATEWAY_API_KEY` - AI Gateway API key
 - `ANTHROPIC_API_KEY` - Anthropic/Claude API key
 - `OPENAI_API_KEY` - OpenAI API key
 - `GEMINI_API_KEY` - Google Gemini API key
@@ -219,8 +239,19 @@ Never expose these in logs or to the client:
 ### Client-Safe Variables
 
 Only these variables should be exposed to the client (via `NEXT_PUBLIC_` prefix):
+
 - `NEXT_PUBLIC_AUTH_PROVIDERS` - Available auth providers
-- `NEXT_PUBLIC_GITHUB_CLIENT_ID` - GitHub OAuth client ID (public)
+
+### Runtime Variables Used By Current App Code
+
+The current codebase expects these environment variables:
+
+- Required core runtime: `POSTGRES_URL`, `SEALOS_HOST`, `DEVBOX_TOKEN`, `JWE_SECRET`, `ENCRYPTION_KEY`, `NEXT_PUBLIC_AUTH_PROVIDERS`, `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`
+- Required for Devbox JWT auth when `DEVBOX_TOKEN` is not set: `DEVBOX_JWT_SIGNING_KEY`
+- Required for AI-generated branch names, titles, and commit messages: `AI_GATEWAY_API_KEY`
+- Optional callback override for self-hosted deployments: `APP_BASE_URL`
+
+Do not rename these without updating the corresponding code paths. In particular, GitHub OAuth currently uses `GITHUB_CLIENT_ID` on the server, not `NEXT_PUBLIC_GITHUB_CLIENT_ID`.
 
 ## Architecture Guidelines
 
@@ -229,6 +260,7 @@ Only these variables should be exposed to the client (via `NEXT_PUBLIC_` prefix)
 The repository page uses a nested routing structure with separate pages for each tab:
 
 #### Route Structure
+
 ```
 app/repos/[owner]/[repo]/
 ├── layout.tsx           # Shared layout with navigation tabs
@@ -242,12 +274,14 @@ app/repos/[owner]/[repo]/
 ```
 
 #### Components
+
 - `components/repo-layout.tsx` - Shared layout component with tab navigation
 - `components/repo-commits.tsx` - Commits list component
 - `components/repo-issues.tsx` - Issues list component
 - `components/repo-pull-requests.tsx` - Pull requests list component
 
 #### API Routes
+
 ```
 app/api/repos/[owner]/[repo]/
 ├── commits/route.ts         # GET - Fetch commits
@@ -256,6 +290,7 @@ app/api/repos/[owner]/[repo]/
 ```
 
 #### Key Features
+
 1. **Tab Navigation**: Uses Next.js Link components for client-side navigation between tabs
 2. **Separate Pages**: Each tab renders on its own route (commits, issues, pull-requests)
 3. **Default Route**: Visiting `/repos/[owner]/[repo]` redirects to `/repos/[owner]/[repo]/commits`
@@ -263,6 +298,7 @@ app/api/repos/[owner]/[repo]/
 5. **GitHub Integration**: All data is fetched from GitHub API using Octokit client
 
 #### Adding New Tabs
+
 To add a new tab to the repository page:
 
 1. Create a new directory under `app/repos/[owner]/[repo]/[tab-name]/`
@@ -291,6 +327,7 @@ Before submitting changes, verify:
 ## Questions?
 
 If you need to log information for debugging purposes:
+
 1. Use server-side console logs (not shown to users)
 2. Still avoid logging sensitive credentials
 3. Consider adding better error handling instead of logging details
@@ -300,7 +337,6 @@ If you need to log information for debugging purposes:
 
 **Remember: When in doubt, use a static string. No exceptions.**
 
-
 <!-- opensrc:start -->
 
 ## Source Code Reference
@@ -323,7 +359,9 @@ npx opensrc <owner>/<repo>      # GitHub repo (e.g., npx opensrc vercel/ai)
 ```
 
 <!-- opensrc:end -->
+
 4. **Use task-flow logs for approved runtime identifiers**
+
    ```typescript
    import { formatKeyTaskLogMessage, TASK_FLOW_LOGS } from '@/lib/utils/task-flow-logs'
 
diff --git a/README.md b/README.md
index 166fc11..e24fb07 100644
--- a/README.md
+++ b/README.md
@@ -4,24 +4,13 @@ A template for building AI-powered coding agents that supports Claude Code, Open
 
 ![Coding Agent Template Screenshot](screenshot.png)
 
-## Deploy Your Own
-
-You can deploy your own version of the coding agent template to Vercel with one click:
-
-[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fvercel-labs%2Fcoding-agent-template&env=DEVBOX_TOKEN,DEVBOX_GATEWAY_URL_TEMPLATE,JWE_SECRET,ENCRYPTION_KEY&envDescription=Required+environment+variables+for+the+coding+agent+template.+You+must+also+configure+at+least+one+OAuth+provider+(GitHub+or+Vercel)+after+deployment.+Optional+API+keys+can+be+added+later.&stores=%5B%7B%22type%22%3A%22postgres%22%7D%5D&project-name=coding-agent-template&repository-name=coding-agent-template)
-
-**What happens during deployment:**
-- **Automatic Database Setup**: A Neon Postgres database is automatically created and connected to your project
-- **Environment Configuration**: You'll be prompted to provide required environment variables (Devbox runtime credentials and encryption keys)
-- **OAuth Setup**: After deployment, you'll need to configure at least one OAuth provider (GitHub or Vercel) in your project settings for user authentication
-
 ## Features
 
 - **Multi-Agent Support**: Choose from Claude Code, OpenAI Codex CLI, GitHub Copilot CLI, Cursor CLI, Google Gemini CLI, or opencode to execute coding tasks
-- **User Authentication**: Secure sign-in with GitHub or Vercel OAuth
+- **User Authentication**: Secure sign-in with GitHub OAuth
 - **Multi-User Support**: Each user has their own tasks, API keys, and GitHub connection
 - **Devbox Runtime**: Runs code in isolated, resumable runtimes
-- **AI Gateway Integration**: Built for seamless integration with [Vercel AI Gateway](https://vercel.com/docs/ai-gateway) for model routing and observability
+- **AI Gateway Integration**: Built for model routing and observability
 - **AI-Generated Branch Names**: Automatically generates descriptive Git branch names using AI SDK 5 + AI Gateway
 - **Task Management**: Track task progress with real-time updates
 - **Persistent Storage**: Tasks stored in Neon Postgres database
@@ -34,13 +23,13 @@ You can deploy your own version of the coding agent template to Vercel with one
 For detailed setup instructions, see the [Local Development Setup](#local-development-setup) section below.
 
 **TL;DR:**
-1. Click the "Deploy with Vercel" button above (automatic database setup!)
-2. Configure OAuth (GitHub or Vercel) in your project settings
-3. Users sign in and start creating tasks
+1. Clone the repository and install dependencies
+2. Configure GitHub OAuth and required environment variables
+3. Initialize the database and start creating tasks
 
 Or run locally:
 ```bash
-git clone https://github.com/vercel-labs/coding-agent-template.git
+git clone <your-repository-url>
 cd coding-agent-template
 pnpm install
 # Set up .env.local with required variables
@@ -50,7 +39,7 @@ pnpm dev
 
 ## Usage
 
-1. **Sign In**: Authenticate with GitHub or Vercel
+1. **Sign In**: Authenticate with GitHub
 2. **Create a Task**: Enter a repository URL and describe what you want the AI to do
 3. **Monitor Progress**: Watch real-time logs as the agent works
 4. **Review Results**: See the changes made and the branch created
@@ -60,7 +49,7 @@ pnpm dev
 
 ### Maximum Duration
 
-The maximum duration setting controls how long the Vercel sandbox will stay alive from the moment it's created. You can select timeouts ranging from 5 minutes to 5 hours.
+The maximum duration setting controls how long the runtime sandbox will stay alive from the moment it's created. You can select timeouts ranging from 5 minutes to 5 hours.
 
 - The sandbox is created at the start of the task
 - The timeout begins when the sandbox is created
@@ -123,14 +112,14 @@ When Keep Alive is enabled, the sandbox stays alive after task completion for th
 
 1. **Task Creation**: When you submit a task, it's stored in the database
 2. **AI Branch Name Generation**: AI SDK 5 + AI Gateway automatically generates a descriptive branch name based on your task (non-blocking using Next.js 15's `after()`)
-3. **Sandbox Setup**: A Vercel sandbox is created with your repository
+3. **Sandbox Setup**: A Devbox runtime is created with your repository
 4. **Agent Execution**: Your chosen coding agent (Claude Code, Codex CLI, GitHub Copilot CLI, Cursor CLI, Gemini CLI, or opencode) analyzes your prompt and makes changes
 5. **Git Operations**: Changes are committed and pushed to the AI-generated branch
 6. **Cleanup**: The sandbox is shut down to free resources
 
 ## AI Branch Name Generation
 
-The system automatically generates descriptive Git branch names using AI SDK 5 and Vercel AI Gateway. This feature:
+The system automatically generates descriptive Git branch names using AI SDK 5 and AI Gateway. This feature:
 
 - **Non-blocking**: Uses Next.js 15's `after()` function to generate names without delaying task creation
 - **Descriptive**: Creates meaningful branch names like `feature/user-authentication-A1b2C3` or `fix/memory-leak-parser-X9y8Z7`
@@ -150,10 +139,10 @@ The system automatically generates descriptive Git branch names using AI SDK 5 a
 - **Frontend**: Next.js 15, React 19, Tailwind CSS
 - **UI Components**: shadcn/ui
 - **Database**: PostgreSQL with Drizzle ORM
-- **AI SDK**: AI SDK 5 with Vercel AI Gateway integration
+- **AI SDK**: AI SDK 5
 - **AI Agents**: Claude Code, OpenAI Codex CLI, GitHub Copilot CLI, Cursor CLI, Google Gemini CLI, opencode
 - **Runtime**: Devbox-based execution environment
-- **Authentication**: Next Auth (OAuth with GitHub/Vercel)
+- **Authentication**: OAuth with GitHub
 - **Git**: Automated branching and commits with AI-generated branch names
 
 ## MCP Server Support
@@ -173,7 +162,7 @@ Connect MCP Servers to extend Claude Code with additional tools and integrations
 ### 1. Clone the repository
 
 ```bash
-git clone https://github.com/vercel-labs/coding-agent-template.git
+git clone <your-repository-url>
 cd coding-agent-template
 ```
 
@@ -191,51 +180,32 @@ Create a `.env.local` file with your values:
 
 These are set once by you (the app developer) and are used for core infrastructure:
 
-- `POSTGRES_URL`: Your PostgreSQL connection string (automatically provided when deploying to Vercel via the Neon integration, or set manually for local development)
+- `POSTGRES_URL`: Your PostgreSQL connection string
 - `DEVBOX_TOKEN`: Token used to provision and access the Devbox runtime API
-- `DEVBOX_GATEWAY_URL_TEMPLATE`: URL template used to derive runtime gateway and preview URLs, for example `http://127.0.0.1:{port}`
+- `SEALOS_HOST`: Sealos host entrypoint, for example `staging-usw-1.sealos.io`
 - `JWE_SECRET`: Base64-encoded secret for session encryption (generate with: `openssl rand -base64 32`)
 - `ENCRYPTION_KEY`: 32-byte hex string for encrypting user API keys and tokens (generate with: `openssl rand -hex 32`)
 
-> **Note**: When deploying to Vercel using the "Deploy with Vercel" button, the database is automatically provisioned via Neon and `POSTGRES_URL` is set for you. For local development, you'll need to provide your own database connection string.
-
-#### User Authentication (Required)
-
-**You must configure at least one authentication method** (Vercel or GitHub):
+The app derives the rest from `SEALOS_HOST`:
 
-##### Configure Enabled Providers
+- `region`: `staging-usw-1`
+- `region_url`: `https://staging-usw-1.sealos.io`
+- `template_api`: `https://template.staging-usw-1.sealos.io/api/v2alpha/templates/raw`
+- `devbox_base_url`: `https://devbox-server.staging-usw-1.sealos.io`
 
-- `NEXT_PUBLIC_AUTH_PROVIDERS`: Comma-separated list of enabled auth providers
-  - `"github"` - GitHub only (default)
-  - `"vercel"` - Vercel only
-  - `"github,vercel"` - Both providers enabled
+#### User Authentication (Required)
 
-**Examples:**
+Configure GitHub OAuth for user authentication:
 
 ```bash
-# GitHub authentication only (default)
 NEXT_PUBLIC_AUTH_PROVIDERS=github
-
-# Vercel authentication only
-NEXT_PUBLIC_AUTH_PROVIDERS=vercel
-
-# Both GitHub and Vercel authentication
-NEXT_PUBLIC_AUTH_PROVIDERS=github,vercel
 ```
 
-##### Provider Configuration
-
-**Option 1: Sign in with Vercel** (if `vercel` is in `NEXT_PUBLIC_AUTH_PROVIDERS`)
-- `NEXT_PUBLIC_VERCEL_CLIENT_ID`: Your Vercel OAuth app client ID (exposed to client)
-- `VERCEL_CLIENT_SECRET`: Your Vercel OAuth app client secret
-
-**Option 2: Sign in with GitHub** (if `github` is in `NEXT_PUBLIC_AUTH_PROVIDERS`)
+Required GitHub OAuth variables:
 - `GITHUB_CLIENT_ID`: Your GitHub OAuth app client ID
 - `GITHUB_CLIENT_SECRET`: Your GitHub OAuth app client secret
 - `APP_BASE_URL`: Optional explicit public app URL for OAuth callbacks in self-hosted deployments
 
-> **Note**: Only the providers listed in `NEXT_PUBLIC_AUTH_PROVIDERS` will appear in the sign-in dialog. You must provide the OAuth credentials for each enabled provider.
-
 #### API Keys (Optional - Can be per-user)
 
 These API keys can be set globally (fallback for all users) or left unset to require users to provide their own:
@@ -252,12 +222,9 @@ These API keys can be set globally (fallback for all users) or left unset to req
 
 - ~~`GITHUB_TOKEN`~~: **No longer needed!** Users authenticate with their own GitHub accounts.
   - Users who sign in with GitHub automatically get repository access via their OAuth token
-  - Users who sign in with Vercel can connect their GitHub account from their profile to access repositories
 
 **How Authentication Works:**
 - **Sign in with GitHub**: Users get immediate repository access via their GitHub OAuth token
-- **Sign in with Vercel**: Users must connect a GitHub account from their profile to work with repositories
-- **Identity Merging**: If a user signs in with Vercel, connects GitHub, then later signs in directly with GitHub, they'll be recognized as the same user (no duplicate accounts)
 
 #### Optional Environment Variables
 
@@ -283,15 +250,6 @@ Based on your `NEXT_PUBLIC_AUTH_PROVIDERS` configuration, you'll need to create
 
 **Required Scopes**: The app will request `repo`, `read:user`, `user:email`, `read:packages`, and `write:packages` scopes to access repositories and push container images to GHCR.
 
-#### Vercel OAuth App (if using Vercel authentication)
-
-1. Go to your [Vercel Dashboard](https://vercel.com/dashboard)
-2. Navigate to Settings → Integrations → Create
-3. Configure the integration:
-   - **Redirect URL**: `http://localhost:3000/api/auth/callback/vercel`
-4. Copy the **Client ID** → use for `NEXT_PUBLIC_VERCEL_CLIENT_ID`
-5. Copy the **Client Secret** → use for `VERCEL_CLIENT_SECRET`
-
 > **Production Deployment**: Remember to add production callback URLs when deploying (e.g., `https://yourdomain.com/api/auth/github/callback`)
 
 ### 5. Set up the database
@@ -355,205 +313,3 @@ pnpm start
 - **Devbox Runtime**: Runtimes are isolated but ensure you're not exposing sensitive data in logs or outputs.
 - **User Authentication**: Each user uses their own GitHub token for repository access - no shared credentials
 - **Encryption**: All sensitive data (tokens, API keys) is encrypted at rest using per-user encryption
-
-## Changelog
-
-### Version 2.0.0 - Major Update: User Authentication & Security
-
-This release introduces **user authentication** and **major security improvements**, but contains **breaking changes** that require migration for existing deployments.
-
-#### New Features
-
-- **User Authentication System**
-  - Sign in with Vercel
-  - Sign in with GitHub
-  - Session management with encrypted tokens
-  - User profile management
-
-- **Multi-User Support**
-  - Each user has their own tasks and connectors
-  - Users can manage their own API keys (Anthropic, OpenAI, Cursor, Gemini, AI Gateway)
-  - GitHub account connection for repository access
-
-- **Security Enhancements**
-  - Per-user GitHub authentication - each user uses their own GitHub token instead of shared credentials
-  - All sensitive data (tokens, API keys, env vars) encrypted at rest
-  - Session-based authentication with JWT encryption
-  - User-scoped authorization - users can only access their own resources
-
-- **Database Enhancements**
-  - New `users` table for user profiles and OAuth accounts
-  - New `accounts` table for linked accounts (e.g., Vercel users connecting GitHub)
-  - New `keys` table for user-provided API keys
-  - Foreign key relationships ensure data integrity
-  - Soft delete support for tasks
-
-#### Breaking Changes
-
-**These changes require action if upgrading from v1.x:**
-
-1. **Database Schema Changes**
-   - `tasks` table now requires `userId` (foreign key to `users.id`)
-   - `connectors` table now requires `userId` (foreign key to `users.id`)
-   - `connectors.env` changed from `jsonb` to encrypted `text`
-   - Added `tasks.deletedAt` for soft deletes
-
-2. **API Changes**
-   - All API endpoints now require authentication
-   - Task creation requires `userId` in request body
-   - Tasks are now filtered by user ownership
-   - GitHub API access uses user's own GitHub token (no shared token fallback)
-
-3. **Environment Variables**
-   - **New Required Variables:**
-     - `JWE_SECRET`: Base64-encoded secret for session encryption (generate: `openssl rand -base64 32`)
-     - `ENCRYPTION_KEY`: 32-byte hex string for encrypting sensitive data (generate: `openssl rand -hex 32`)
-     - `NEXT_PUBLIC_AUTH_PROVIDERS`: Configure which auth providers to enable (`github`, `vercel`, or both)
-   
-   - **New OAuth Configuration (at least one required):**
-     - GitHub: `GITHUB_CLIENT_ID`, `GITHUB_CLIENT_SECRET`
-     - Vercel: `NEXT_PUBLIC_VERCEL_CLIENT_ID`, `VERCEL_CLIENT_SECRET`
-   
-   - **Changed Authentication:**
-     - `GITHUB_TOKEN` no longer used as fallback in API routes
-     - Users must connect their own GitHub account for repository access
-     - Each user's GitHub token is used for their requests
-
-4. **Authentication Required**
-   - All routes now require user authentication
-   - No anonymous access to tasks or API endpoints
-   - Users must sign in with GitHub or Vercel before creating tasks
-
-#### Migration Guide for Existing Deployments
-
-If you're upgrading from v1.x to v2.0.0, follow these steps:
-
-##### Step 1: Backup Your Database
-
-```bash
-# Create a backup of your existing database
-pg_dump $POSTGRES_URL > backup-before-v2-migration.sql
-```
-
-##### Step 2: Add Required Environment Variables
-
-Add these new variables to your `.env.local` or Vercel project settings:
-
-```bash
-# Session encryption (REQUIRED)
-JWE_SECRET=$(openssl rand -base64 32)
-ENCRYPTION_KEY=$(openssl rand -hex 32)
-
-# Configure auth providers (REQUIRED - choose at least one)
-NEXT_PUBLIC_AUTH_PROVIDERS=github  # or "vercel" or "github,vercel"
-
-# GitHub OAuth (if using GitHub authentication)
-GITHUB_CLIENT_ID=your_github_client_id
-GITHUB_CLIENT_SECRET=your_github_client_secret
-
-# Optional explicit public URL for OAuth callbacks in self-hosted deployments
-APP_BASE_URL=http://localhost:3000
-
-# Vercel OAuth (if using Vercel authentication)
-NEXT_PUBLIC_VERCEL_CLIENT_ID=your_vercel_client_id
-VERCEL_CLIENT_SECRET=your_vercel_client_secret
-```
-
-##### Step 3: Set Up OAuth Applications
-
-Create OAuth applications for your chosen authentication provider(s). See the [Local Development Setup](#local-development-setup) section for detailed instructions.
-
-##### Step 4: Prepare Database Migration
-
-Before running migrations, you need to handle existing data:
-
-**Option A: Fresh Start (Recommended for Development)**
-
-If you don't have production data to preserve:
-
-```bash
-# Drop existing tables and start fresh
-pnpm db:push --force
-
-# This will create all new tables with proper structure
-```
-
-**Option B: Preserve Existing Data (Production)**
-
-If you have existing tasks/connectors to preserve:
-
-1. **Create a system user first:**
-
-```sql
--- Connect to your database and run:
-INSERT INTO users (id, provider, external_id, access_token, username, email, created_at, updated_at, last_login_at)
-VALUES (
-  'system-user-migration',
-  'github',
-  'system-migration',
-  'encrypted-placeholder-token',  -- You'll need to encrypt a placeholder
-  'System Migration User',
-  NULL,
-  NOW(),
-  NOW(),
-  NOW()
-);
-```
-
-2. **Update existing records:**
-
-```sql
--- Add userId to existing tasks
-ALTER TABLE tasks ADD COLUMN user_id TEXT;
-UPDATE tasks SET user_id = 'system-user-migration' WHERE user_id IS NULL;
-ALTER TABLE tasks ALTER COLUMN user_id SET NOT NULL;
-ALTER TABLE tasks ADD CONSTRAINT tasks_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
-
--- Add userId to existing connectors
-ALTER TABLE connectors ADD COLUMN user_id TEXT;
-UPDATE connectors SET user_id = 'system-user-migration' WHERE user_id IS NULL;
-ALTER TABLE connectors ALTER COLUMN user_id SET NOT NULL;
-ALTER TABLE connectors ADD CONSTRAINT connectors_user_id_fkey FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
-
--- Convert connector env from jsonb to encrypted text (requires app-level encryption)
--- Note: You'll need to manually encrypt existing env values using your ENCRYPTION_KEY
-```
-
-3. **Run the standard migrations:**
-
-```bash
-pnpm db:generate
-pnpm db:push
-```
-
-##### Step 5: Update Your Code
-
-Pull the latest changes:
-
-```bash
-git pull origin main
-pnpm install
-```
-
-##### Step 6: Test Authentication
-
-1. Start the development server: `pnpm dev`
-2. Navigate to `http://localhost:3000`
-3. Sign in with your configured OAuth provider
-4. Verify you can create and view tasks
-
-##### Step 7: Verify Security Fix
-
-Confirm that:
-- Users can only see their own tasks
-- File diff/files endpoints require GitHub connection
-- Users without GitHub connection see "GitHub authentication required" errors
-- No `GITHUB_TOKEN` fallback is being used in API routes
-
-#### Important Notes
-
-- **All users will need to sign in** after this upgrade - no anonymous access
-- **Existing tasks** will be owned by the system user if using Option B migration
-- **Users must connect GitHub** (if they signed in with Vercel) to access repositories
-- **API keys** can now be per-user - users can override global API keys in their profile
-- **Breaking API changes**: If you have external integrations calling your API, they'll need to be updated to include authentication
diff --git a/app/api/tasks/[taskId]/chat/interrupt/route.ts b/app/api/tasks/[taskId]/chat/interrupt/route.ts
new file mode 100644
index 0000000..5f24454
--- /dev/null
+++ b/app/api/tasks/[taskId]/chat/interrupt/route.ts
@@ -0,0 +1,75 @@
+import { and, eq, isNull } from 'drizzle-orm'
+import { NextResponse } from 'next/server'
+import { CodexGatewayApiError, interruptCodexGatewayTurn } from '@/lib/codex-gateway/client'
+import { hasActiveTurnCheckpoint } from '@/lib/codex-gateway/completion'
+import { getTaskGatewayContext } from '@/lib/codex-gateway/task'
+import { db } from '@/lib/db/client'
+import { tasks } from '@/lib/db/schema'
+import { getServerSession } from '@/lib/session/get-server-session'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+export const maxDuration = 60
+
+interface RouteParams {
+  params: Promise<{
+    taskId: string
+  }>
+}
+
+export async function POST(_request: Request, { params }: RouteParams) {
+  try {
+    const session = await getServerSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { taskId } = await params
+    const [task] = await db
+      .select()
+      .from(tasks)
+      .where(and(eq(tasks.id, taskId), eq(tasks.userId, session.user.id), isNull(tasks.deletedAt)))
+      .limit(1)
+
+    if (!task) {
+      return NextResponse.json({ error: 'Task not found' }, { status: 404 })
+    }
+
+    if (task.selectedAgent !== 'codex') {
+      return NextResponse.json({ error: 'Unsupported agent' }, { status: 400 })
+    }
+
+    if (!hasActiveTurnCheckpoint(task) || !task.activeTurnSessionId) {
+      return NextResponse.json({ error: 'Task does not have an active turn' }, { status: 409 })
+    }
+
+    const { gatewayUrl, gatewayAuthToken } = await getTaskGatewayContext(taskId, session.user.id)
+    if (!gatewayUrl) {
+      return NextResponse.json({ error: 'Gateway URL is not configured' }, { status: 400 })
+    }
+
+    const result = await interruptCodexGatewayTurn(gatewayUrl, task.activeTurnSessionId, gatewayAuthToken)
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        sessionId: result.sessionId,
+        state: result.state,
+      },
+    })
+  } catch (error) {
+    if (error instanceof CodexGatewayApiError) {
+      return NextResponse.json(
+        {
+          error: 'Failed to interrupt active turn',
+          statusCode: error.status,
+          message: error.message,
+        },
+        { status: error.status >= 400 && error.status < 500 ? error.status : 502 },
+      )
+    }
+
+    console.error('Failed to interrupt chat turn:', error)
+    return NextResponse.json({ error: 'Failed to interrupt active turn' }, { status: 500 })
+  }
+}
diff --git a/app/api/tasks/[taskId]/chat/turn/route.ts b/app/api/tasks/[taskId]/chat/turn/route.ts
index 4370553..53f814d 100644
--- a/app/api/tasks/[taskId]/chat/turn/route.ts
+++ b/app/api/tasks/[taskId]/chat/turn/route.ts
@@ -2,16 +2,11 @@ import { after, NextRequest, NextResponse } from 'next/server'
 import { and, eq, isNull } from 'drizzle-orm'
 import { z } from 'zod'
 import { CodexGatewayApiError } from '@/lib/codex-gateway/client'
-import { startCodexGatewayTaskTurn, waitForCodexGatewayTurnCompletion } from '@/lib/codex-gateway/runner'
-import { createTaskChatStreamDescriptor } from '@/lib/codex-gateway/stream-ticket'
+import { finalizeTaskChatV2Turn, startTaskChatV2Turn } from '@/lib/codex-gateway/chat-v2-service'
 import { db } from '@/lib/db/client'
 import { tasks } from '@/lib/db/schema'
-import { ensureTaskDevboxRuntime } from '@/lib/devbox/runtime'
 import { getServerSession } from '@/lib/session/get-server-session'
-import { appendTaskMessage } from '@/lib/task-messages'
 import { checkRateLimit } from '@/lib/utils/rate-limit'
-import { createTaskLogger } from '@/lib/utils/task-logger'
-import { formatKeyTaskLogMessage, TASK_FLOW_LOGS } from '@/lib/utils/task-flow-logs'
 
 export const runtime = 'nodejs'
 export const dynamic = 'force-dynamic'
@@ -80,58 +75,15 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     }
 
     const prompt = parsed.data.prompt || parsed.data.message || ''
-    const logger = createTaskLogger(taskId)
-    let userMessagePersisted = false
-    const userInputReceivedLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.USER_INPUT_RECEIVED, {
-      promptChars: prompt.length,
+    const result = await startTaskChatV2Turn({
+      task,
+      prompt,
       source: 'chat-turn',
     })
-    await logger.info(userInputReceivedLog)
-    console.info(userInputReceivedLog)
-
-    try {
-      await appendTaskMessage({
-        taskId: resolvedTaskId,
-        role: 'user',
-        content: prompt,
-      })
-      userMessagePersisted = true
-      const userInputSavedLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.USER_INPUT_SAVED, {
-        promptChars: prompt.length,
-        source: 'chat-turn',
-      })
-      await logger.info(userInputSavedLog)
-      console.info(userInputSavedLog)
-    } catch {
-      console.error('Failed to persist chat turn user message')
-    }
-
-    await db
-      .update(tasks)
-      .set({
-        status: 'processing',
-        progress: 0,
-        error: null,
-        completedAt: null,
-        updatedAt: new Date(),
-      })
-      .where(eq(tasks.id, resolvedTaskId))
-
-    await ensureTaskDevboxRuntime(task, { logger })
-
-    const startedTurn = await startCodexGatewayTaskTurn(resolvedTaskId, prompt, {
-      appendUserMessage: !userMessagePersisted,
-      model: task.selectedModel,
-    })
-    const stream = await createTaskChatStreamDescriptor({
-      taskId: resolvedTaskId,
-      userId: session.user.id,
-      sessionId: startedTurn.sessionId,
-    })
 
     after(async () => {
       try {
-        await waitForCodexGatewayTurnCompletion(startedTurn)
+        await finalizeTaskChatV2Turn(result.startedTurn)
       } catch (error) {
         console.error('Failed to finalize chat turn:', error)
 
@@ -143,8 +95,6 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
             updatedAt: new Date(),
           })
           .where(eq(tasks.id, resolvedTaskId))
-
-        await logger.error('Failed to finalize chat turn')
       }
     })
 
@@ -152,14 +102,16 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
       success: true,
       data: {
         session: {
-          sessionId: startedTurn.sessionId,
+          sessionId: result.startedTurn.sessionId,
+          threadId: result.startedTurn.threadId,
+          turnId: result.startedTurn.turnId,
         },
-        stream,
+        stream: result.stream,
         turn: {
-          transcriptCursor: startedTurn.transcriptCursor,
+          transcriptCursor: result.startedTurn.transcriptCursor,
           turnAccepted: true,
-          turnStartedAt: startedTurn.startedAt.toISOString(),
-          streamUrl: stream.streamUrl,
+          turnStartedAt: result.startedTurn.startedAt.toISOString(),
+          streamUrl: result.stream.streamUrl,
         },
       },
     })
diff --git a/app/api/tasks/[taskId]/chat/v2/route.ts b/app/api/tasks/[taskId]/chat/v2/route.ts
new file mode 100644
index 0000000..72d2f9e
--- /dev/null
+++ b/app/api/tasks/[taskId]/chat/v2/route.ts
@@ -0,0 +1,228 @@
+import { after, NextRequest, NextResponse } from 'next/server'
+import { and, asc, eq, isNull } from 'drizzle-orm'
+import { z } from 'zod'
+import { CodexGatewayApiError } from '@/lib/codex-gateway/client'
+import { finalizeTaskChatV2Turn, startTaskChatV2Turn } from '@/lib/codex-gateway/chat-v2-service'
+import {
+  hasActiveTurnCheckpoint,
+  reconcileIncompleteTurnSafely,
+  shouldAttemptTurnReconciliation,
+} from '@/lib/codex-gateway/completion'
+import { db } from '@/lib/db/client'
+import { taskMessages, tasks } from '@/lib/db/schema'
+import { reconcileProjectedTaskMessages } from '@/lib/task-event-projection'
+import {
+  closeTaskChatV2StreamDescriptor,
+  ensureTaskChatV2StreamDescriptor,
+  getActiveTaskChatV2StreamDescriptor,
+} from '@/lib/task-chat-v2'
+import { listTaskEvents } from '@/lib/task-events'
+import { getServerSession } from '@/lib/session/get-server-session'
+import { checkRateLimit } from '@/lib/utils/rate-limit'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+export const maxDuration = 300
+
+const turnSchema = z.object({
+  prompt: z.string().trim().min(1, 'Prompt is required'),
+})
+
+interface RouteParams {
+  params: Promise<{
+    taskId: string
+  }>
+}
+
+async function getOwnedTask(taskId: string, userId: string) {
+  const [task] = await db
+    .select()
+    .from(tasks)
+    .where(and(eq(tasks.id, taskId), eq(tasks.userId, userId), isNull(tasks.deletedAt)))
+    .limit(1)
+
+  return task || null
+}
+
+export async function GET(_request: NextRequest, { params }: RouteParams) {
+  try {
+    const session = await getServerSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { taskId } = await params
+    let task = await getOwnedTask(taskId, session.user.id)
+
+    if (!task) {
+      return NextResponse.json({ error: 'Task not found' }, { status: 404 })
+    }
+
+    if (
+      task.selectedAgent === 'codex' &&
+      hasActiveTurnCheckpoint(task) &&
+      shouldAttemptTurnReconciliation(task, 5_000)
+    ) {
+      try {
+        task = (await reconcileIncompleteTurnSafely(task.id, 2_500)) || task
+      } catch {
+        console.error('Failed to reconcile incomplete Codex turn')
+      }
+    }
+
+    await reconcileProjectedTaskMessages(taskId)
+
+    const refreshedTask = (await getOwnedTask(taskId, session.user.id)) || task
+    const messages = await db
+      .select()
+      .from(taskMessages)
+      .where(eq(taskMessages.taskId, taskId))
+      .orderBy(asc(taskMessages.createdAt))
+
+    let stream = await getActiveTaskChatV2StreamDescriptor(taskId)
+
+    if (
+      refreshedTask.selectedAgent === 'codex' &&
+      hasActiveTurnCheckpoint(refreshedTask) &&
+      refreshedTask.activeTurnSessionId
+    ) {
+      stream = await ensureTaskChatV2StreamDescriptor({
+        taskId,
+        sessionId: refreshedTask.activeTurnSessionId,
+        threadId: null,
+        turnId: null,
+        startedAt: refreshedTask.activeTurnStartedAt || undefined,
+      })
+    } else if (stream) {
+      await closeTaskChatV2StreamDescriptor(taskId)
+      stream = null
+    }
+
+    const events = await listTaskEvents(taskId, { limit: 200 })
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        task: refreshedTask,
+        messages,
+        events,
+        stream,
+      },
+    })
+  } catch (error) {
+    console.error('Failed to fetch chat v2 state:', error)
+    return NextResponse.json({ error: 'Failed to fetch chat state' }, { status: 500 })
+  }
+}
+
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  let taskId: string | null = null
+
+  try {
+    const session = await getServerSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const rateLimit = await checkRateLimit(session.user.id)
+    if (!rateLimit.allowed) {
+      return NextResponse.json(
+        {
+          error: 'Rate limit exceeded',
+          message: `You have reached the daily limit of ${rateLimit.total} messages (tasks + follow-ups). Your limit will reset at ${rateLimit.resetAt.toISOString()}`,
+          remaining: rateLimit.remaining,
+          total: rateLimit.total,
+          resetAt: rateLimit.resetAt.toISOString(),
+        },
+        { status: 429 },
+      )
+    }
+
+    ;({ taskId } = await params)
+    const resolvedTaskId = taskId
+
+    const body = await request.json().catch(() => ({}))
+    const parsed = turnSchema.safeParse(body)
+    if (!parsed.success) {
+      return NextResponse.json({ error: 'Prompt is required' }, { status: 400 })
+    }
+
+    const task = await getOwnedTask(resolvedTaskId, session.user.id)
+    if (!task) {
+      return NextResponse.json({ error: 'Task not found' }, { status: 404 })
+    }
+
+    if (task.selectedAgent !== 'codex') {
+      return NextResponse.json({ error: 'Unsupported agent' }, { status: 400 })
+    }
+
+    const result = await startTaskChatV2Turn({
+      task,
+      prompt: parsed.data.prompt,
+      source: 'chat-v2',
+    })
+
+    after(async () => {
+      try {
+        await finalizeTaskChatV2Turn(result.startedTurn)
+      } catch (error) {
+        console.error('Failed to finalize chat v2 turn:', error)
+
+        await db
+          .update(tasks)
+          .set({
+            status: 'error',
+            error: 'Failed to finalize chat turn',
+            updatedAt: new Date(),
+          })
+          .where(eq(tasks.id, resolvedTaskId))
+      }
+    })
+
+    return NextResponse.json({
+      success: true,
+      data: {
+        session: {
+          sessionId: result.startedTurn.sessionId,
+          threadId: result.startedTurn.threadId,
+          turnId: result.startedTurn.turnId,
+        },
+        stream: result.stream,
+        turn: {
+          transcriptCursor: result.startedTurn.transcriptCursor,
+          turnAccepted: true,
+          turnStartedAt: result.startedTurn.startedAt.toISOString(),
+        },
+      },
+    })
+  } catch (error) {
+    if (taskId) {
+      try {
+        await db
+          .update(tasks)
+          .set({
+            status: 'error',
+            error: 'Failed to start chat turn',
+            updatedAt: new Date(),
+          })
+          .where(eq(tasks.id, taskId))
+      } catch {
+        console.error('Failed to mark chat v2 turn as errored')
+      }
+    }
+
+    if (error instanceof CodexGatewayApiError) {
+      return NextResponse.json(
+        {
+          error: 'Failed to start chat turn',
+          statusCode: error.status,
+          message: error.message,
+        },
+        { status: error.status >= 400 && error.status < 500 ? error.status : 502 },
+      )
+    }
+
+    console.error('Failed to start chat v2 turn:', error)
+    return NextResponse.json({ error: 'Failed to start chat turn' }, { status: 500 })
+  }
+}
diff --git a/app/api/tasks/[taskId]/chat/v2/stream/route.ts b/app/api/tasks/[taskId]/chat/v2/stream/route.ts
new file mode 100644
index 0000000..4c63bb6
--- /dev/null
+++ b/app/api/tasks/[taskId]/chat/v2/stream/route.ts
@@ -0,0 +1,295 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getCodexGatewayEventStreamUrl } from '@/lib/codex-gateway/client'
+import { getTaskGatewayContext } from '@/lib/codex-gateway/task'
+import type { CodexGatewayState } from '@/lib/codex-gateway/types'
+import { closeTaskStream, getTaskStream, recordTaskEvent, touchTaskStream } from '@/lib/task-events'
+import { getServerSession } from '@/lib/session/get-server-session'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+export const maxDuration = 300
+
+interface RouteParams {
+  params: Promise<{
+    taskId: string
+  }>
+}
+
+function mapGatewayEventKind(eventName: string) {
+  switch (eventName) {
+    case 'session':
+      return 'gateway.session.opened' as const
+    case 'state':
+      return 'gateway.state.snapshot' as const
+    case 'notification':
+      return 'gateway.notification' as const
+    case 'server-request':
+      return 'gateway.server_request' as const
+    case 'warning':
+      return 'gateway.warning' as const
+    case 'session-closed':
+      return 'gateway.session.closed' as const
+    default:
+      return null
+  }
+}
+
+function parseSseBlock(block: string): {
+  dataText: string
+  eventName: string
+} | null {
+  if (!block.trim()) {
+    return null
+  }
+
+  let eventName = 'message'
+  const dataLines: string[] = []
+
+  for (const line of block.split(/\r?\n/)) {
+    if (line.startsWith('event:')) {
+      eventName = line.slice('event:'.length).trim() || 'message'
+      continue
+    }
+
+    if (line.startsWith('data:')) {
+      dataLines.push(line.slice('data:'.length).trimStart())
+    }
+  }
+
+  return {
+    eventName,
+    dataText: dataLines.join('\n'),
+  }
+}
+
+async function persistGatewayEvent(input: {
+  eventName: string
+  payload: Record<string, unknown> | null
+  sessionId: string
+  streamId: string
+  taskId: string
+  transcriptCursor: number | null
+}) {
+  const eventKind = mapGatewayEventKind(input.eventName)
+
+  if (!eventKind) {
+    return
+  }
+
+  if (eventKind === 'gateway.session.opened') {
+    const nextSessionId =
+      typeof input.payload?.id === 'string' && input.payload.id.trim() ? input.payload.id.trim() : input.sessionId
+
+    await touchTaskStream(input.streamId, { sessionId: nextSessionId })
+    await recordTaskEvent({
+      taskId: input.taskId,
+      streamId: input.streamId,
+      kind: eventKind,
+      sessionId: nextSessionId,
+      payload: input.payload,
+    })
+    return
+  }
+
+  if (eventKind === 'gateway.state.snapshot') {
+    const state = (input.payload || {}) as CodexGatewayState & Record<string, unknown>
+
+    await touchTaskStream(input.streamId, {
+      threadId: state.threadId || null,
+      turnId: state.currentTurnId || null,
+    })
+
+    await recordTaskEvent({
+      taskId: input.taskId,
+      streamId: input.streamId,
+      kind: eventKind,
+      sessionId: input.sessionId,
+      threadId: state.threadId || null,
+      turnId: state.currentTurnId || null,
+      payload: {
+        ...state,
+        transcriptCursor: input.transcriptCursor,
+      },
+    })
+
+    if (!state.activeTurn && state.lastTurnStatus) {
+      await closeTaskStream(input.streamId, 'closed')
+    }
+
+    return
+  }
+
+  await recordTaskEvent({
+    taskId: input.taskId,
+    streamId: input.streamId,
+    kind: eventKind,
+    sessionId: input.sessionId,
+    payload: input.payload,
+  })
+
+  if (eventKind === 'gateway.session.closed') {
+    await closeTaskStream(input.streamId, 'closed')
+  }
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  const decoder = new TextDecoder()
+  let streamId: string | null = null
+  let taskId: string | null = null
+
+  try {
+    const session = await getServerSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    ;({ taskId } = await params)
+    const resolvedTaskId = taskId
+    streamId = request.nextUrl.searchParams.get('streamId')
+
+    if (!streamId) {
+      return NextResponse.json({ error: 'Missing stream id' }, { status: 400 })
+    }
+
+    const resolvedStreamId = streamId
+
+    const stream = await getTaskStream(resolvedStreamId)
+    if (!stream || stream.taskId !== resolvedTaskId || stream.status !== 'active') {
+      return NextResponse.json({ error: 'Stream not found' }, { status: 404 })
+    }
+
+    const { task, gatewayUrl, gatewayAuthToken } = await getTaskGatewayContext(resolvedTaskId, session.user.id)
+
+    if (!task) {
+      return NextResponse.json({ error: 'Task not found' }, { status: 404 })
+    }
+
+    if (!gatewayUrl) {
+      return NextResponse.json({ error: 'Gateway URL is not configured' }, { status: 400 })
+    }
+
+    if (task.activeTurnSessionId && task.activeTurnSessionId !== stream.sessionId) {
+      await closeTaskStream(resolvedStreamId, 'errored')
+      return NextResponse.json({ error: 'Stream session is no longer active' }, { status: 410 })
+    }
+
+    const upstream = await fetch(getCodexGatewayEventStreamUrl(gatewayUrl, stream.sessionId, gatewayAuthToken), {
+      headers: {
+        accept: 'text/event-stream',
+      },
+      cache: 'no-store',
+      signal: AbortSignal.timeout(15_000),
+    })
+
+    if (!upstream.ok || !upstream.body) {
+      await closeTaskStream(resolvedStreamId, 'errored')
+      return NextResponse.json({ error: 'Failed to connect to Codex gateway events' }, { status: 502 })
+    }
+
+    const headers = new Headers()
+    headers.set('content-type', 'text/event-stream; charset=utf-8')
+    headers.set('cache-control', 'no-cache, no-transform')
+    headers.set('connection', 'keep-alive')
+    headers.set('x-accel-buffering', 'no')
+
+    const transcriptCursor =
+      task.activeTurnSessionId === stream.sessionId && typeof task.activeTurnTranscriptCursor === 'number'
+        ? task.activeTurnTranscriptCursor
+        : null
+
+    const reader = upstream.body.getReader()
+    let sseBuffer = ''
+
+    const handleSseBlock = async (block: string) => {
+      const parsedBlock = parseSseBlock(block)
+      if (!parsedBlock || !parsedBlock.dataText) {
+        return
+      }
+
+      try {
+        const payload = JSON.parse(parsedBlock.dataText) as Record<string, unknown>
+        await persistGatewayEvent({
+          taskId: resolvedTaskId,
+          streamId: resolvedStreamId,
+          sessionId: stream.sessionId,
+          eventName: parsedBlock.eventName,
+          payload,
+          transcriptCursor,
+        })
+      } catch {
+        console.error('Failed to persist gateway stream event')
+      }
+    }
+
+    const flushBufferedEvents = async (flushAll: boolean) => {
+      while (true) {
+        const separatorMatch = sseBuffer.match(/\r?\n\r?\n/)
+        if (!separatorMatch || separatorMatch.index === undefined) {
+          break
+        }
+
+        const block = sseBuffer.slice(0, separatorMatch.index)
+        sseBuffer = sseBuffer.slice(separatorMatch.index + separatorMatch[0].length)
+        await handleSseBlock(block)
+      }
+
+      if (flushAll && sseBuffer.trim()) {
+        const finalBlock = sseBuffer
+        sseBuffer = ''
+        await handleSseBlock(finalBlock)
+      }
+    }
+
+    const streamResponse = new ReadableStream<Uint8Array>({
+      async start(controller) {
+        try {
+          while (true) {
+            const { done, value } = await reader.read()
+
+            if (done) {
+              break
+            }
+
+            if (!value) {
+              continue
+            }
+
+            controller.enqueue(value)
+            sseBuffer += decoder.decode(value, { stream: true })
+            await flushBufferedEvents(false)
+          }
+
+          sseBuffer += decoder.decode()
+          await flushBufferedEvents(true)
+          controller.close()
+        } catch (error) {
+          await closeTaskStream(resolvedStreamId, 'errored')
+          try {
+            controller.close()
+          } catch {
+            // Ignore close errors after upstream socket termination.
+          }
+        } finally {
+          reader.releaseLock()
+        }
+      },
+      async cancel() {
+        await reader.cancel()
+      },
+    })
+
+    return new Response(streamResponse, {
+      status: 200,
+      headers,
+    })
+  } catch (error) {
+    if (streamId) {
+      await closeTaskStream(streamId, 'errored').catch(() => {
+        console.error('Failed to close chat v2 stream after proxy error')
+      })
+    }
+
+    console.error('Failed to proxy chat v2 stream:', error)
+    return NextResponse.json({ error: 'Failed to proxy chat stream' }, { status: 500 })
+  }
+}
diff --git a/app/api/tasks/[taskId]/continue/route.ts b/app/api/tasks/[taskId]/continue/route.ts
index 7c845fe..02b09f2 100644
--- a/app/api/tasks/[taskId]/continue/route.ts
+++ b/app/api/tasks/[taskId]/continue/route.ts
@@ -4,6 +4,7 @@ import { db } from '@/lib/db/client'
 import { tasks } from '@/lib/db/schema'
 import { startCodexGatewayTaskTurn, waitForCodexGatewayTurnCompletion } from '@/lib/codex-gateway/runner'
 import { ensureTaskDevboxRuntime } from '@/lib/devbox/runtime'
+import { prependSealosDeployContext } from '@/lib/sealos-deploy-context'
 import { checkRateLimit } from '@/lib/utils/rate-limit'
 import { createTaskLogger } from '@/lib/utils/task-logger'
 import { getServerSession } from '@/lib/session/get-server-session'
@@ -82,9 +83,10 @@ export async function POST(req: NextRequest, context: { params: Promise<{ taskId
       const logger = createTaskLogger(taskId)
 
       try {
-        await ensureTaskDevboxRuntime(task, { logger })
+        const runtime = await ensureTaskDevboxRuntime(task, { logger })
+        const gatewayPrompt = prependSealosDeployContext(trimmedMessage, runtime.namespace || task.runtimeNamespace)
 
-        const startedTurn = await startCodexGatewayTaskTurn(taskId, trimmedMessage, {
+        const startedTurn = await startCodexGatewayTaskTurn(taskId, gatewayPrompt, {
           appendUserMessage: !userMessagePersisted,
           model: task.selectedModel,
         })
diff --git a/app/api/tasks/[taskId]/events/route.ts b/app/api/tasks/[taskId]/events/route.ts
new file mode 100644
index 0000000..71d4761
--- /dev/null
+++ b/app/api/tasks/[taskId]/events/route.ts
@@ -0,0 +1,49 @@
+import { and, eq, isNull } from 'drizzle-orm'
+import { NextRequest, NextResponse } from 'next/server'
+import { db } from '@/lib/db/client'
+import { tasks } from '@/lib/db/schema'
+import { listTaskEvents } from '@/lib/task-events'
+import { getServerSession } from '@/lib/session/get-server-session'
+
+export const runtime = 'nodejs'
+export const dynamic = 'force-dynamic'
+export const maxDuration = 60
+
+interface RouteParams {
+  params: Promise<{
+    taskId: string
+  }>
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const session = await getServerSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { taskId } = await params
+    const [task] = await db
+      .select({ id: tasks.id })
+      .from(tasks)
+      .where(and(eq(tasks.id, taskId), eq(tasks.userId, session.user.id), isNull(tasks.deletedAt)))
+      .limit(1)
+
+    if (!task) {
+      return NextResponse.json({ error: 'Task not found' }, { status: 404 })
+    }
+
+    const limitParam = Number.parseInt(request.nextUrl.searchParams.get('limit') || '', 10)
+    const events = await listTaskEvents(taskId, {
+      limit: Number.isFinite(limitParam) ? limitParam : 200,
+    })
+
+    return NextResponse.json({
+      success: true,
+      events,
+    })
+  } catch (error) {
+    console.error('Failed to fetch task events:', error)
+    return NextResponse.json({ error: 'Failed to fetch task events' }, { status: 500 })
+  }
+}
diff --git a/app/api/tasks/[taskId]/gateway/session/route.ts b/app/api/tasks/[taskId]/gateway/session/route.ts
index 46165d8..b5e8287 100644
--- a/app/api/tasks/[taskId]/gateway/session/route.ts
+++ b/app/api/tasks/[taskId]/gateway/session/route.ts
@@ -30,7 +30,7 @@ function createGatewayUnavailableResponse() {
   return NextResponse.json(
     {
       error: 'Gateway URL is not configured',
-      message: 'Set DEVBOX_GATEWAY_URL_TEMPLATE or persist gatewayUrl for this task runtime',
+      message: 'Gateway URL is not available from the Devbox runtime',
     },
     { status: 400 },
   )
diff --git a/app/api/tasks/[taskId]/gateway/turn/route.ts b/app/api/tasks/[taskId]/gateway/turn/route.ts
index ba50c6e..c178b71 100644
--- a/app/api/tasks/[taskId]/gateway/turn/route.ts
+++ b/app/api/tasks/[taskId]/gateway/turn/route.ts
@@ -6,7 +6,9 @@ import { tasks } from '@/lib/db/schema'
 import { CodexGatewayApiError } from '@/lib/codex-gateway/client'
 import { startCodexGatewayTaskTurn, waitForCodexGatewayTurnCompletion } from '@/lib/codex-gateway/runner'
 import { getTaskGatewayContext } from '@/lib/codex-gateway/task'
+import { prependSealosDeployContext } from '@/lib/sealos-deploy-context'
 import { getServerSession } from '@/lib/session/get-server-session'
+import { appendTaskMessage } from '@/lib/task-messages'
 import { createTaskLogger } from '@/lib/utils/task-logger'
 
 const turnSchema = z.object({
@@ -45,10 +47,25 @@ export async function POST(request: NextRequest, { params }: RouteParams) {
     }
 
     const prompt = parsed.data.prompt
-    const startedTurn = await startCodexGatewayTaskTurn(taskId, prompt, {
-      appendUserMessage: true,
-      model: task.selectedModel,
-    })
+
+    try {
+      await appendTaskMessage({
+        taskId,
+        role: 'user',
+        content: prompt,
+      })
+    } catch {
+      console.error('Failed to persist gateway turn user message')
+    }
+
+    const startedTurn = await startCodexGatewayTaskTurn(
+      taskId,
+      prependSealosDeployContext(prompt, task.runtimeNamespace),
+      {
+        appendUserMessage: false,
+        model: task.selectedModel,
+      },
+    )
 
     after(async () => {
       try {
diff --git a/app/api/tasks/[taskId]/messages/route.ts b/app/api/tasks/[taskId]/messages/route.ts
index a67f58c..7344724 100644
--- a/app/api/tasks/[taskId]/messages/route.ts
+++ b/app/api/tasks/[taskId]/messages/route.ts
@@ -3,7 +3,12 @@ import { getServerSession } from '@/lib/session/get-server-session'
 import { db } from '@/lib/db/client'
 import { taskMessages, tasks } from '@/lib/db/schema'
 import { eq, and, asc, isNull } from 'drizzle-orm'
-import { hasActiveTurnCheckpoint, reconcileIncompleteTurn } from '@/lib/codex-gateway/completion'
+import {
+  hasActiveTurnCheckpoint,
+  reconcileIncompleteTurnSafely,
+  shouldAttemptTurnReconciliation,
+} from '@/lib/codex-gateway/completion'
+import { reconcileProjectedTaskMessages } from '@/lib/task-event-projection'
 
 export async function GET(req: NextRequest, context: { params: Promise<{ taskId: string }> }) {
   try {
@@ -26,14 +31,20 @@ export async function GET(req: NextRequest, context: { params: Promise<{ taskId:
       return NextResponse.json({ error: 'Task not found' }, { status: 404 })
     }
 
-    if (task[0].selectedAgent === 'codex' && hasActiveTurnCheckpoint(task[0])) {
+    if (
+      task[0].selectedAgent === 'codex' &&
+      hasActiveTurnCheckpoint(task[0]) &&
+      shouldAttemptTurnReconciliation(task[0], 5_000)
+    ) {
       try {
-        await reconcileIncompleteTurn(taskId)
+        await reconcileIncompleteTurnSafely(taskId, 2_500)
       } catch {
         console.error('Failed to reconcile incomplete Codex turn')
       }
     }
 
+    await reconcileProjectedTaskMessages(taskId)
+
     // Fetch all messages for this task, ordered by creation time
     const messages = await db
       .select()
diff --git a/app/api/tasks/[taskId]/route.ts b/app/api/tasks/[taskId]/route.ts
index 602570d..03cc59c 100644
--- a/app/api/tasks/[taskId]/route.ts
+++ b/app/api/tasks/[taskId]/route.ts
@@ -6,8 +6,13 @@ import { createTaskLogger } from '@/lib/utils/task-logger'
 import { deleteDevbox, DevboxApiError } from '@/lib/devbox/client'
 import { getServerSession } from '@/lib/session/get-server-session'
 import { CodexGatewayApiError, deleteCodexGatewaySession } from '@/lib/codex-gateway/client'
-import { hasActiveTurnCheckpoint, reconcileIncompleteTurn } from '@/lib/codex-gateway/completion'
+import {
+  hasActiveTurnCheckpoint,
+  reconcileIncompleteTurnSafely,
+  shouldAttemptTurnReconciliation,
+} from '@/lib/codex-gateway/completion'
 import { getTaskGatewayContext } from '@/lib/codex-gateway/task'
+import { closeTaskChatV2StreamDescriptor } from '@/lib/task-chat-v2'
 
 interface RouteParams {
   params: Promise<{
@@ -35,9 +40,13 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
 
     let currentTask = task[0]
 
-    if (currentTask.selectedAgent === 'codex' && hasActiveTurnCheckpoint(currentTask)) {
+    if (
+      currentTask.selectedAgent === 'codex' &&
+      hasActiveTurnCheckpoint(currentTask) &&
+      shouldAttemptTurnReconciliation(currentTask)
+    ) {
       try {
-        currentTask = (await reconcileIncompleteTurn(currentTask.id)) || currentTask
+        currentTask = (await reconcileIncompleteTurnSafely(currentTask.id)) || currentTask
       } catch {
         console.error('Failed to reconcile incomplete Codex turn')
       }
@@ -127,6 +136,10 @@ export async function PATCH(request: NextRequest, { params }: RouteParams) {
           .where(eq(tasks.id, taskId))
           .returning()
 
+        await closeTaskChatV2StreamDescriptor(taskId).catch(() => {
+          console.error('Failed to close active chat stream during stop')
+        })
+
         if (existingTask.runtimeName) {
           try {
             await deleteDevbox(existingTask.runtimeName)
diff --git a/app/api/tasks/route.ts b/app/api/tasks/route.ts
index 1fbac32..cb8cb9b 100644
--- a/app/api/tasks/route.ts
+++ b/app/api/tasks/route.ts
@@ -1,17 +1,14 @@
 import { NextRequest, NextResponse, after } from 'next/server'
 import { and, desc, eq, isNull, or } from 'drizzle-orm'
-import { startCodexGatewayTaskTurn, waitForCodexGatewayTurnCompletion } from '@/lib/codex-gateway/runner'
+import { finalizeTaskChatV2Turn, startTaskChatV2Turn } from '@/lib/codex-gateway/chat-v2-service'
 import { FORCED_CODEX_MODEL } from '@/lib/codex/defaults'
 import { db } from '@/lib/db/client'
 import { insertTaskSchema, tasks } from '@/lib/db/schema'
-import { ensureTaskDevboxRuntime } from '@/lib/devbox/runtime'
 import { getServerSession } from '@/lib/session/get-server-session'
-import { appendTaskMessage } from '@/lib/task-messages'
 import { generateBranchName, createFallbackBranchName } from '@/lib/utils/branch-name-generator'
 import { generateId } from '@/lib/utils/id'
 import { checkRateLimit } from '@/lib/utils/rate-limit'
 import { createTaskLogger } from '@/lib/utils/task-logger'
-import { formatKeyTaskLogMessage, TASK_FLOW_LOGS } from '@/lib/utils/task-flow-logs'
 import { generateTaskTitle, createFallbackTitle } from '@/lib/utils/title-generator'
 
 export const runtime = 'nodejs'
@@ -190,44 +187,16 @@ export async function POST(request: NextRequest) {
       }
     })
 
-    const logger = createTaskLogger(taskId)
-    let userMessagePersisted = false
-    const userInputReceivedLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.USER_INPUT_RECEIVED, {
-      promptChars: validatedData.prompt.length,
-      source: 'task-create',
-      selectedModel,
-    })
-    await logger.info(userInputReceivedLog)
-    console.info(userInputReceivedLog)
-
     try {
-      await appendTaskMessage({
-        taskId,
-        role: 'user',
-        content: validatedData.prompt,
-      })
-      userMessagePersisted = true
-      const userInputSavedLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.USER_INPUT_SAVED, {
-        promptChars: validatedData.prompt.length,
+      const startedTurn = await startTaskChatV2Turn({
+        task: newTask,
+        prompt: validatedData.prompt,
         source: 'task-create',
       })
-      await logger.info(userInputSavedLog)
-      console.info(userInputSavedLog)
-    } catch {
-      console.error('Failed to persist task user message')
-    }
-
-    try {
-      await ensureTaskDevboxRuntime(newTask, { logger })
-
-      const startedTurn = await startCodexGatewayTaskTurn(taskId, validatedData.prompt, {
-        appendUserMessage: !userMessagePersisted,
-        model: selectedModel,
-      })
 
       after(async () => {
         try {
-          await waitForCodexGatewayTurnCompletion(startedTurn)
+          await finalizeTaskChatV2Turn(startedTurn.startedTurn)
         } catch {
           console.error('Failed to finalize Codex task')
 
@@ -240,6 +209,7 @@ export async function POST(request: NextRequest) {
             })
             .where(eq(tasks.id, taskId))
 
+          const logger = createTaskLogger(taskId)
           await logger.error('Failed to finalize Codex task')
         }
       })
@@ -255,6 +225,7 @@ export async function POST(request: NextRequest) {
         })
         .where(eq(tasks.id, taskId))
 
+      const logger = createTaskLogger(taskId)
       await logger.error('Failed to start Codex gateway task')
       return NextResponse.json({ error: 'Failed to start Codex gateway task' }, { status: 500 })
     }
diff --git a/app/globals.css b/app/globals.css
index 888964a..246fec2 100644
--- a/app/globals.css
+++ b/app/globals.css
@@ -8,6 +8,7 @@
 @theme inline {
   --color-background: var(--background);
   --color-foreground: var(--foreground);
+  --font-display: var(--font-commissioner);
   --font-sans: var(--font-geist-sans);
   --font-mono: var(--font-geist-mono);
   --color-sidebar-ring: var(--sidebar-ring);
@@ -120,6 +121,86 @@
   }
   body {
     @apply bg-background text-foreground;
+    font-kerning: normal;
+    text-rendering: optimizeLegibility;
+  }
+}
+
+@layer utilities {
+  .sealos-eyebrow {
+    color: color-mix(in oklab, var(--foreground) 44%, var(--background));
+    font-size: 0.68rem;
+    font-weight: 600;
+    letter-spacing: 0.18em;
+    line-height: 1;
+    text-transform: uppercase;
+  }
+
+  .sealos-hero-title {
+    font-family: var(--font-display), var(--font-sans), sans-serif;
+    font-size: clamp(2.5rem, 5vw, 3.8rem);
+    font-weight: 600;
+    letter-spacing: -0.062em;
+    line-height: 0.92;
+    text-wrap: balance;
+  }
+
+  .sealos-section-title {
+    font-family: var(--font-display), var(--font-sans), sans-serif;
+    font-size: clamp(1.35rem, 2vw, 1.75rem);
+    font-weight: 600;
+    letter-spacing: -0.05em;
+    line-height: 1.02;
+    text-wrap: balance;
+  }
+
+  .sealos-body {
+    max-width: 34rem;
+    color: var(--muted-foreground);
+    font-size: 0.95rem;
+    font-weight: 400;
+    letter-spacing: -0.012em;
+    line-height: 1.68;
+    text-wrap: pretty;
+  }
+
+  .sealos-meta-label {
+    color: var(--muted-foreground);
+    font-size: 0.72rem;
+    font-weight: 600;
+    letter-spacing: 0.16em;
+    line-height: 1;
+    text-transform: uppercase;
+  }
+
+  .sealos-meta-value {
+    color: var(--foreground);
+    font-size: 0.98rem;
+    font-weight: 600;
+    letter-spacing: -0.028em;
+    line-height: 1.2;
+  }
+
+  .sealos-command-text {
+    color: var(--foreground);
+    font-size: 1.02rem;
+    font-weight: 400;
+    letter-spacing: -0.018em;
+    line-height: 1.72;
+  }
+
+  .sealos-helper {
+    color: var(--muted-foreground);
+    font-size: 0.78rem;
+    font-weight: 400;
+    letter-spacing: -0.006em;
+    line-height: 1.45;
+  }
+
+  .sealos-action-text {
+    font-size: 0.93rem;
+    font-weight: 600;
+    letter-spacing: -0.022em;
   }
 }
 
diff --git a/app/layout.tsx b/app/layout.tsx
index 4b71bc6..07e5831 100644
--- a/app/layout.tsx
+++ b/app/layout.tsx
@@ -1,5 +1,5 @@
 import type { Metadata } from 'next'
-import { Geist, Geist_Mono } from 'next/font/google'
+import { Commissioner, Geist, Geist_Mono } from 'next/font/google'
 import './globals.css'
 import { Toaster } from '@/components/ui/sonner'
 import { ThemeProvider } from '@/components/theme-provider'
@@ -19,6 +19,12 @@ const geistMono = Geist_Mono({
   subsets: ['latin'],
 })
 
+const commissioner = Commissioner({
+  variable: '--font-commissioner',
+  subsets: ['latin'],
+  weight: ['500', '600'],
+})
+
 export const metadata: Metadata = {
   title: 'Analyze and Ship to Sealos',
   description:
@@ -32,7 +38,7 @@ export default function RootLayout({
 }>) {
   return (
     <html lang="en" suppressHydrationWarning>
-      <body className={`${geistSans.variable} ${geistMono.variable} antialiased`}>
+      <body className={`${geistSans.variable} ${geistMono.variable} ${commissioner.variable} antialiased`}>
         <JotaiProvider>
           <ThemeProvider attribute="class" defaultTheme="system" enableSystem disableTransitionOnChange>
             <SessionProvider />
diff --git a/codex-gateway b/codex-gateway
new file mode 160000
index 0000000..4b43a42
--- /dev/null
+++ b/codex-gateway
@@ -0,0 +1 @@
+Subproject commit 4b43a42503d18484d616ec565df979f121f3be51
diff --git a/components/home-page-content.tsx b/components/home-page-content.tsx
index 4ac7a0c..05c14ef 100644
--- a/components/home-page-content.tsx
+++ b/components/home-page-content.tsx
@@ -29,7 +29,6 @@ import { multiRepoModeAtom, selectedReposAtom } from '@/lib/atoms/multi-repo'
 import { sessionAtom } from '@/lib/atoms/session'
 import { githubConnectionAtom, githubConnectionInitializedAtom } from '@/lib/atoms/github-connection'
 import { OpenRepoUrlDialog } from '@/components/open-repo-url-dialog'
-import { MultiRepoDialog } from '@/components/multi-repo-dialog'
 
 interface HomePageContentProps {
   initialSelectedOwner?: string
@@ -62,7 +61,6 @@ export function HomePageContent({
   const [loadingGitHub, setLoadingGitHub] = useState(false)
   const [isRefreshing, setIsRefreshing] = useState(false)
   const [showOpenRepoDialog, setShowOpenRepoDialog] = useState(false)
-  const [showMultiRepoDialog, setShowMultiRepoDialog] = useState(false)
   const router = useRouter()
   const searchParams = useSearchParams()
   const { refreshTasks, addTaskOptimistically } = useTasks()
@@ -265,7 +263,6 @@ export function HomePageContent({
             onOwnerChange={handleOwnerChange}
             onRepoChange={handleRepoChange}
             size="sm"
-            onMultiRepoClick={() => setShowMultiRepoDialog(true)}
           />
           <DropdownMenu>
             <DropdownMenuTrigger asChild>
@@ -557,6 +554,7 @@ export function HomePageContent({
         <TaskForm
           onSubmit={handleTaskSubmit}
           isSubmitting={isSubmitting}
+          isAuthenticated={Boolean(user)}
           selectedOwner={selectedOwner}
           selectedRepo={selectedRepo}
           initialInstallDependencies={initialInstallDependencies}
@@ -572,7 +570,6 @@ export function HomePageContent({
 
       {/* Dialogs */}
       <OpenRepoUrlDialog open={showOpenRepoDialog} onOpenChange={setShowOpenRepoDialog} onSubmit={handleOpenRepoUrl} />
-      <MultiRepoDialog open={showMultiRepoDialog} onOpenChange={setShowMultiRepoDialog} />
 
       {/* Sign In Dialog */}
       <Dialog open={showSignInDialog} onOpenChange={setShowSignInDialog}>
diff --git a/components/home-page-mobile-footer.tsx b/components/home-page-mobile-footer.tsx
index c347e14..9441aac 100644
--- a/components/home-page-mobile-footer.tsx
+++ b/components/home-page-mobile-footer.tsx
@@ -2,7 +2,6 @@
 
 import { Button } from '@/components/ui/button'
 import { GitHubIcon } from '@/components/icons/github-icon'
-import { VERCEL_DEPLOY_URL } from '@/lib/constants'
 import { formatAbbreviatedNumber } from '@/lib/utils/format-number'
 
 const GITHUB_REPO_URL = 'https://github.com/vercel-labs/coding-agent-template'
@@ -15,7 +14,6 @@ export function HomePageMobileFooter({ initialStars = 1200 }: HomePageMobileFoot
   return (
     <div className="md:hidden fixed bottom-0 left-0 right-0 bg-background/95 backdrop-blur supports-[backdrop-filter]:bg-background/60 z-20">
       <div className="flex items-center justify-center gap-3 p-4">
-        {/* GitHub Stars Button */}
         <Button asChild variant="ghost" size="default">
           <a
             href={GITHUB_REPO_URL}
@@ -27,26 +25,6 @@ export function HomePageMobileFooter({ initialStars = 1200 }: HomePageMobileFoot
             <span className="text-sm font-medium">{formatAbbreviatedNumber(initialStars)}</span>
           </a>
         </Button>
-
-        {/* Deploy to Vercel Button */}
-        {/* <Button
-          asChild
-          variant="default"
-          size="default"
-          className="bg-black text-white border-black hover:bg-black/90 dark:bg-white dark:text-black dark:border-white dark:hover:bg-white/90"
-        >
-          <a
-            href={VERCEL_DEPLOY_URL}
-            target="_blank"
-            rel="noopener noreferrer"
-            className="flex items-center justify-center gap-2"
-          >
-            <svg viewBox="0 0 76 65" className="h-3.5 w-3.5" fill="currentColor">
-              <path d="M37.5274 0L75.0548 65H0L37.5274 0Z" />
-            </svg>
-            <span className="text-sm font-medium">Deploy Your Own</span>
-          </a>
-        </Button> */}
       </div>
     </div>
   )
diff --git a/components/repo-selector.tsx b/components/repo-selector.tsx
index 83708d0..4cc66a6 100644
--- a/components/repo-selector.tsx
+++ b/components/repo-selector.tsx
@@ -3,11 +3,10 @@
 import { useState, useEffect, useRef } from 'react'
 import { Input } from '@/components/ui/input'
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
-import { Lock, Loader2, Layers } from 'lucide-react'
+import { Lock, Loader2 } from 'lucide-react'
 import { useAtomValue, useSetAtom, useAtom } from 'jotai'
 import { githubConnectionAtom } from '@/lib/atoms/github-connection'
 import { githubOwnersAtom, githubReposAtomFamily } from '@/lib/atoms/github-cache'
-import { multiRepoModeAtom, selectedReposAtom } from '@/lib/atoms/multi-repo'
 
 interface GitHubOwner {
   login: string
@@ -31,7 +30,6 @@ interface RepoSelectorProps {
   onRepoChange: (repo: string) => void
   disabled?: boolean
   size?: 'sm' | 'default'
-  onMultiRepoClick?: () => void
 }
 
 export function RepoSelector({
@@ -41,7 +39,6 @@ export function RepoSelector({
   onRepoChange,
   disabled = false,
   size = 'default',
-  onMultiRepoClick,
 }: RepoSelectorProps) {
   const [repoFilter, setRepoFilter] = useState('')
   // Initialize with selected owner to prevent flash
@@ -54,10 +51,6 @@ export function RepoSelector({
   const [temporaryOwner, setTemporaryOwner] = useState<GitHubOwner | null>(null)
   const [temporaryRepo, setTemporaryRepo] = useState<GitHubRepo | null>(null)
 
-  // Multi-repo mode state
-  const [multiRepoMode, setMultiRepoMode] = useAtom(multiRepoModeAtom)
-  const selectedRepos = useAtomValue(selectedReposAtom)
-
   // Ref for the filter input to focus it when dropdown opens
   const filterInputRef = useRef<HTMLInputElement>(null)
 
@@ -413,16 +406,6 @@ export function RepoSelector({
   }
 
   const handleOwnerChange = (value: string) => {
-    if (value === '__many__') {
-      // Enable multi-repo mode
-      setMultiRepoMode(true)
-      onMultiRepoClick?.()
-      return
-    }
-
-    // Disable multi-repo mode when selecting a specific owner
-    setMultiRepoMode(false)
-
     onOwnerChange(value)
     onRepoChange('') // Reset repo when owner changes
     setRepoFilter('') // Reset filter when owner changes
@@ -482,22 +465,13 @@ export function RepoSelector({
 
   return (
     <div className="flex items-center gap-1 sm:gap-2 h-8">
-      <Select
-        value={multiRepoMode ? '__many__' : selectedOwner}
-        onValueChange={handleOwnerChange}
-        disabled={disabled || showOwnersLoading}
-      >
+      <Select value={selectedOwner} onValueChange={handleOwnerChange} disabled={disabled || showOwnersLoading}>
         <SelectTrigger className={ownerTriggerClassName}>
           {showOwnersLoading ? (
             <div className="flex items-center gap-2">
               <Loader2 className="h-3 w-3 animate-spin" />
               <span>Loading...</span>
             </div>
-          ) : multiRepoMode ? (
-            <div className="flex items-center gap-2">
-              <Layers className="h-4 w-4" />
-              <span className="hidden sm:inline">Multi-repo</span>
-            </div>
           ) : size === 'sm' && selectedOwnerData ? (
             // Mobile: Show only avatar
             <div className="flex items-center gap-1">
@@ -515,14 +489,6 @@ export function RepoSelector({
           )}
         </SelectTrigger>
         <SelectContent>
-          {/* Multi-repo option */}
-          <SelectItem value="__many__">
-            <div className="flex items-center gap-2">
-              <Layers className="h-4 w-4" />
-              <span>Multi-repo</span>
-            </div>
-          </SelectItem>
-          <div className="h-px bg-border my-1" />
           {displayedOwners &&
             displayedOwners.map((owner) => (
               <SelectItem key={owner.login} value={owner.login}>
@@ -535,84 +501,74 @@ export function RepoSelector({
         </SelectContent>
       </Select>
 
-      {/* Show "X repo(s) selected" button in multi-repo mode, or regular repo dropdown otherwise */}
-      {multiRepoMode ? (
-        <button
-          onClick={onMultiRepoClick}
-          className="h-9 px-3 text-xs rounded-md bg-transparent dark:bg-input/30 hover:bg-accent dark:hover:bg-input/50 transition-colors"
-        >
-          {selectedRepos.length} repo{selectedRepos.length !== 1 ? 's' : ''} selected
-        </button>
-      ) : (
-        selectedOwner && (
-          <>
-            <span className="text-muted-foreground text-xs">/</span>
-
-            <Select
-              value={selectedRepo}
-              onValueChange={handleRepoChange}
-              disabled={disabled || showReposLoading}
-              onOpenChange={setRepoDropdownOpen}
-            >
-              <SelectTrigger className={repoTriggerClassName}>
-                {showReposLoading ? (
-                  <div className="flex items-center gap-2">
-                    <Loader2 className="h-3 w-3 animate-spin" />
-                    <span>Loading...</span>
-                  </div>
-                ) : (
-                  <SelectValue placeholder="Repo" />
-                )}
-              </SelectTrigger>
-              <SelectContent>
-                {repos && repos.length > 0 && (
-                  <div className="p-2 border-b">
-                    <Input
-                      ref={filterInputRef}
-                      placeholder={
-                        (repos?.length || 0) > 50
-                          ? `Filter ${repos?.length || 0} repositories...`
-                          : 'Filter repositories...'
-                      }
-                      value={repoFilter}
-                      onChange={(e) => setRepoFilter(e.target.value)}
-                      disabled={disabled}
-                      className="text-base md:text-sm h-8"
-                      onClick={(e) => e.stopPropagation()}
-                      onKeyDown={(e) => e.stopPropagation()}
-                    />
-                  </div>
-                )}
-                {filteredRepos.length === 0 && repoFilter ? (
-                  <div className="p-2 text-sm text-muted-foreground text-center">
-                    No repositories match &quot;{repoFilter}&quot;
-                  </div>
-                ) : showReposLoading ? (
-                  <div className="p-4 flex items-center justify-center gap-2 text-sm text-muted-foreground">
-                    <Loader2 className="h-4 w-4 animate-spin" />
-                    <span>Loading repositories...</span>
-                  </div>
-                ) : (
-                  <>
-                    {displayedRepos.map((repo) => (
-                      <SelectItem key={repo.full_name} value={repo.name}>
-                        <div className="flex items-center gap-2">
-                          <span className="font-medium">{repo.name}</span>
-                          {repo.private && <Lock className="h-3 w-3 text-muted-foreground" />}
-                        </div>
-                      </SelectItem>
-                    ))}
-                    {hasMoreRepos && (
-                      <div className="p-2 text-xs text-muted-foreground text-center border-t">
-                        Showing first 50 of {repos?.length || 0} repositories. Use filter to find more.
+      {selectedOwner && (
+        <>
+          <span className="text-muted-foreground text-xs">/</span>
+
+          <Select
+            value={selectedRepo}
+            onValueChange={handleRepoChange}
+            disabled={disabled || showReposLoading}
+            onOpenChange={setRepoDropdownOpen}
+          >
+            <SelectTrigger className={repoTriggerClassName}>
+              {showReposLoading ? (
+                <div className="flex items-center gap-2">
+                  <Loader2 className="h-3 w-3 animate-spin" />
+                  <span>Loading...</span>
+                </div>
+              ) : (
+                <SelectValue placeholder="Repo" />
+              )}
+            </SelectTrigger>
+            <SelectContent>
+              {repos && repos.length > 0 && (
+                <div className="p-2 border-b">
+                  <Input
+                    ref={filterInputRef}
+                    placeholder={
+                      (repos?.length || 0) > 50
+                        ? `Filter ${repos?.length || 0} repositories...`
+                        : 'Filter repositories...'
+                    }
+                    value={repoFilter}
+                    onChange={(e) => setRepoFilter(e.target.value)}
+                    disabled={disabled}
+                    className="text-base md:text-sm h-8"
+                    onClick={(e) => e.stopPropagation()}
+                    onKeyDown={(e) => e.stopPropagation()}
+                  />
+                </div>
+              )}
+              {filteredRepos.length === 0 && repoFilter ? (
+                <div className="p-2 text-sm text-muted-foreground text-center">
+                  No repositories match &quot;{repoFilter}&quot;
+                </div>
+              ) : showReposLoading ? (
+                <div className="p-4 flex items-center justify-center gap-2 text-sm text-muted-foreground">
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                  <span>Loading repositories...</span>
+                </div>
+              ) : (
+                <>
+                  {displayedRepos.map((repo) => (
+                    <SelectItem key={repo.full_name} value={repo.name}>
+                      <div className="flex items-center gap-2">
+                        <span className="font-medium">{repo.name}</span>
+                        {repo.private && <Lock className="h-3 w-3 text-muted-foreground" />}
                       </div>
-                    )}
-                  </>
-                )}
-              </SelectContent>
-            </Select>
-          </>
-        )
+                    </SelectItem>
+                  ))}
+                  {hasMoreRepos && (
+                    <div className="p-2 text-xs text-muted-foreground text-center border-t">
+                      Showing first 50 of {repos?.length || 0} repositories. Use filter to find more.
+                    </div>
+                  )}
+                </>
+              )}
+            </SelectContent>
+          </Select>
+        </>
       )}
     </div>
   )
diff --git a/components/sealos-home-page-content.tsx b/components/sealos-home-page-content.tsx
index 9d1d5e8..f46145e 100644
--- a/components/sealos-home-page-content.tsx
+++ b/components/sealos-home-page-content.tsx
@@ -53,6 +53,13 @@ export function SealosHomePageContent({
   const githubConnectionInitialized = useAtomValue(githubConnectionInitializedAtom)
   const isGitHubAuthUser = session.authProvider === 'github'
   const { github: hasGitHub, vercel: hasVercel } = getEnabledAuthProviders()
+  const isAuthenticated = Boolean(user)
+  const visibleSelectedOwner = isAuthenticated ? selectedOwner : ''
+  const visibleSelectedRepo = isAuthenticated ? selectedRepo : ''
+  const hasSelectedRepo = Boolean(visibleSelectedOwner && visibleSelectedRepo)
+  const canSelectRepository =
+    isAuthenticated &&
+    (githubConnection.connected || isGitHubAuthUser || Boolean(selectedOwner) || Boolean(selectedRepo))
 
   const handleOwnerChange = (owner: string) => {
     setSelectedOwnerState(owner)
@@ -86,7 +93,7 @@ export function SealosHomePageContent({
 
     if (!data.repoUrl) {
       toast.error('Please select a repository', {
-        description: 'Choose a GitHub repository from the header before starting the task.',
+        description: 'Choose a GitHub repository before starting the task.',
       })
       return
     }
@@ -137,23 +144,69 @@ export function SealosHomePageContent({
     window.location.href = '/api/auth/github/signin'
   }
 
-  const headerLeftActions = (
-    <div className="flex min-w-0 flex-1 items-center gap-2">
-      {!githubConnectionInitialized ? null : githubConnection.connected ||
-        isGitHubAuthUser ||
-        selectedOwner ||
-        selectedRepo ? (
-        <RepoSelector
-          selectedOwner={selectedOwner}
-          selectedRepo={selectedRepo}
-          onOwnerChange={handleOwnerChange}
-          onRepoChange={handleRepoChange}
-          size="sm"
-        />
-      ) : user ? (
-        <Button onClick={handleConnectGitHub} variant="outline" size="sm" className="h-8 flex-shrink-0">
-          <GitHubIcon className="mr-2 h-4 w-4" />
-          Connect GitHub
+  const openSignIn = () => {
+    setShowSignInDialog(true)
+  }
+
+  const commandDisabled = !isAuthenticated || !hasSelectedRepo
+  const pageDescription = !isAuthenticated
+    ? 'Stay on the same deploy surface. Sign in, choose a repository, then run the command.'
+    : 'Choose a GitHub repository, then tell Sealos what to launch. The shell stays the same from setup to deploy.'
+
+  const commandPlaceholder = !isAuthenticated
+    ? 'Sign in to choose a repository and unlock deploy.'
+    : hasSelectedRepo
+      ? 'Prepare this repo for Sealos with /sealos-deploy.'
+      : 'Choose a repository above to unlock the deploy command.'
+
+  const commandHelperText = !isAuthenticated
+    ? 'Sign in to choose a repository and unlock deploy.'
+    : hasSelectedRepo
+      ? ''
+      : canSelectRepository
+        ? 'Select a repository above to continue.'
+        : 'Connect GitHub to choose a repository.'
+
+  const commandHeader = (
+    <div className="flex flex-col gap-3 border-b border-border/60 pb-4 sm:flex-row sm:items-end sm:justify-between">
+      <div className="min-w-0">
+        <div className="sealos-meta-label">Repository</div>
+
+        <div className="mt-3 min-w-0">
+          {!isAuthenticated ? (
+            <div className="sealos-helper">Sign in to choose a GitHub repository.</div>
+          ) : !githubConnectionInitialized ? (
+            <div className="sealos-helper">Checking your GitHub connection...</div>
+          ) : canSelectRepository ? (
+            <div className="inline-flex max-w-full items-center rounded-full border border-border/70 bg-muted/20 px-2.5 py-1.5">
+              <RepoSelector
+                selectedOwner={selectedOwner}
+                selectedRepo={selectedRepo}
+                onOwnerChange={handleOwnerChange}
+                onRepoChange={handleRepoChange}
+              />
+            </div>
+          ) : (
+            <Button
+              type="button"
+              variant="outline"
+              onClick={handleConnectGitHub}
+              className="sealos-action-text h-10 rounded-full px-4"
+            >
+              <GitHubIcon className="h-4 w-4" />
+              Connect GitHub
+            </Button>
+          )}
+        </div>
+      </div>
+
+      {!isAuthenticated ? (
+        <Button
+          type="button"
+          onClick={openSignIn}
+          className="sealos-action-text h-10 rounded-full px-4 sm:flex-shrink-0"
+        >
+          Sign in
         </Button>
       ) : null}
     </div>
@@ -162,18 +215,33 @@ export function SealosHomePageContent({
   return (
     <div className="flex flex-1 flex-col bg-background">
       <div className="p-3">
-        <SharedHeader leftActions={headerLeftActions} initialStars={initialStars} />
+        <SharedHeader initialStars={initialStars} hideUserAction={!user} />
       </div>
 
       <div className="flex flex-1 items-center justify-center px-4 pb-8">
-        <TaskForm
-          onSubmit={handleTaskSubmit}
-          isSubmitting={isSubmitting}
-          selectedOwner={selectedOwner}
-          selectedRepo={selectedRepo}
-          initialMaxDuration={initialMaxDuration}
-          maxSandboxDuration={maxSandboxDuration}
-        />
+        <div className="w-full max-w-3xl">
+          <div className="mb-7 text-center">
+            <div className="sealos-eyebrow">Deploy to Sealos</div>
+            <h1 className="sealos-section-title mt-4 text-foreground sm:text-[2.5rem]">Deploy with one command</h1>
+            <p className="sealos-body mx-auto mt-3">{pageDescription}</p>
+          </div>
+
+          <TaskForm
+            onSubmit={handleTaskSubmit}
+            isSubmitting={isSubmitting}
+            isAuthenticated={isAuthenticated}
+            selectedOwner={visibleSelectedOwner}
+            selectedRepo={visibleSelectedRepo}
+            variant="command"
+            commandDisabled={commandDisabled}
+            commandPlaceholder={commandPlaceholder}
+            commandHelperText={commandHelperText}
+            alwaysShowCommandHelper={commandDisabled}
+            commandHeader={commandHeader}
+            initialMaxDuration={initialMaxDuration}
+            maxSandboxDuration={maxSandboxDuration}
+          />
+        </div>
       </div>
 
       <Dialog open={showSignInDialog} onOpenChange={setShowSignInDialog}>
diff --git a/components/shared-header.tsx b/components/shared-header.tsx
index 504d50b..07cdccd 100644
--- a/components/shared-header.tsx
+++ b/components/shared-header.tsx
@@ -5,14 +5,13 @@ import { Menu } from 'lucide-react'
 import { useTasks } from '@/components/app-layout'
 import { User } from '@/components/auth/user'
 import { GitHubStarsButton } from '@/components/github-stars-button'
-import { VERCEL_DEPLOY_URL } from '@/lib/constants'
 
 interface SharedHeaderProps {
   leftActions?: React.ReactNode
   extraActions?: React.ReactNode
   initialStars?: number
   hideStars?: boolean
-  hideDeployButton?: boolean
+  hideUserAction?: boolean
 }
 
 export function SharedHeader({
@@ -20,7 +19,7 @@ export function SharedHeader({
   extraActions,
   initialStars = 1200,
   hideStars = true,
-  hideDeployButton = true,
+  hideUserAction = false,
 }: SharedHeaderProps) {
   const { toggleSidebar } = useTasks()
 
@@ -39,30 +38,9 @@ export function SharedHeader({
         <div className="flex items-center gap-2 flex-shrink-0">
           {!hideStars && <GitHubStarsButton initialStars={initialStars} />}
 
-          {!hideDeployButton && (
-            <Button
-              asChild
-              variant="outline"
-              size="sm"
-              className="h-8 sm:px-3 px-0 sm:w-auto w-8 bg-black text-white border-black hover:bg-black/90 dark:bg-white dark:text-black dark:border-white dark:hover:bg-white/90"
-            >
-              <a
-                href={VERCEL_DEPLOY_URL}
-                target="_blank"
-                rel="noopener noreferrer"
-                className="flex items-center gap-1.5"
-              >
-                <svg viewBox="0 0 76 65" className="h-3 w-3" fill="currentColor">
-                  <path d="M37.5274 0L75.0548 65H0L37.5274 0Z" />
-                </svg>
-                <span className="hidden sm:inline">Deploy Your Own</span>
-              </a>
-            </Button>
-          )}
-
           {extraActions}
 
-          <User />
+          {!hideUserAction ? <User /> : null}
         </div>
       </div>
     </div>
diff --git a/components/task-agent-activity.tsx b/components/task-agent-activity.tsx
new file mode 100644
index 0000000..3773c22
--- /dev/null
+++ b/components/task-agent-activity.tsx
@@ -0,0 +1,126 @@
+'use client'
+
+import { memo, useMemo } from 'react'
+import { AlertCircle, CheckCircle2, Loader2, ShieldAlert } from 'lucide-react'
+import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from '@/components/ui/accordion'
+import type { TaskAgentActivityItem } from '@/lib/task-agent-events'
+import { cn } from '@/lib/utils'
+
+interface TaskAgentActivityProps {
+  isStreaming: boolean
+  items: TaskAgentActivityItem[]
+}
+
+function getToneIcon(tone: TaskAgentActivityItem['tone']) {
+  if (tone === 'success') {
+    return <CheckCircle2 className="h-3.5 w-3.5 text-green-600" />
+  }
+
+  if (tone === 'error') {
+    return <AlertCircle className="h-3.5 w-3.5 text-red-500" />
+  }
+
+  if (tone === 'warning') {
+    return <ShieldAlert className="h-3.5 w-3.5 text-amber-500" />
+  }
+
+  return <Loader2 className="h-3.5 w-3.5 text-muted-foreground" />
+}
+
+export const TaskAgentActivity = memo(function TaskAgentActivity({ isStreaming, items }: TaskAgentActivityProps) {
+  const visibleItems = useMemo(() => {
+    const recentItems = [...items].toSorted((left, right) => left.occurredAt.localeCompare(right.occurredAt)).slice(-12)
+    const latestByGroup = new Map<string, TaskAgentActivityItem>()
+
+    for (const item of recentItems) {
+      latestByGroup.set(item.groupKey, item)
+    }
+
+    return Array.from(latestByGroup.values())
+      .toSorted((left, right) => right.occurredAt.localeCompare(left.occurredAt))
+      .slice(0, 4)
+  }, [items])
+
+  const latestItem = visibleItems[0]
+
+  if (!latestItem && !isStreaming) {
+    return null
+  }
+
+  const summaryLabel = latestItem?.label || 'Preparing response'
+  const summaryDetail = latestItem?.detail || (isStreaming ? 'Agent is working on the next reply' : 'Recent activity')
+  const summaryTone = latestItem?.tone || 'default'
+
+  if (visibleItems.length === 0) {
+    return (
+      <div className="rounded-2xl border bg-muted/10 px-3 py-2.5">
+        <div className="flex items-center gap-2">
+          <div className="flex-shrink-0">{getToneIcon(summaryTone)}</div>
+          <div className="min-w-0 flex-1">
+            <div className="truncate text-sm font-medium">{summaryLabel}</div>
+            <div className="truncate text-xs text-muted-foreground">{summaryDetail}</div>
+          </div>
+          {isStreaming ? (
+            <div className="flex items-center gap-1.5 text-xs text-muted-foreground">
+              <Loader2 className="h-3 w-3 animate-spin" />
+              Live
+            </div>
+          ) : null}
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <Accordion type="single" collapsible className="rounded-2xl border bg-muted/10">
+      <AccordionItem value="activity" className="border-none">
+        <AccordionTrigger className="items-center px-3 py-2.5 hover:no-underline">
+          <div className="flex min-w-0 flex-1 items-center gap-2">
+            <div className="mt-0.5 flex-shrink-0">{getToneIcon(summaryTone)}</div>
+            <div className="min-w-0 flex-1">
+              <div className="truncate text-sm font-medium">{summaryLabel}</div>
+              <div className="truncate text-xs text-muted-foreground">{summaryDetail}</div>
+            </div>
+            {isStreaming ? (
+              <div className="flex flex-shrink-0 items-center gap-1.5 text-xs text-muted-foreground">
+                <Loader2 className="h-3 w-3 animate-spin" />
+                Live
+              </div>
+            ) : null}
+          </div>
+        </AccordionTrigger>
+        <AccordionContent className="border-t px-3 pb-3">
+          <div className="space-y-2 pt-3">
+            {visibleItems.map((item) => (
+              <div key={item.id} className="flex items-start gap-2 text-sm">
+                <div className="mt-0.5 flex-shrink-0">{getToneIcon(item.tone)}</div>
+                <div className="min-w-0 flex-1">
+                  <div className="flex items-center gap-2">
+                    <span className="truncate font-medium">{item.label}</span>
+                    <span className="text-[11px] text-muted-foreground">
+                      {new Date(item.occurredAt).toLocaleTimeString([], {
+                        hour: '2-digit',
+                        minute: '2-digit',
+                      })}
+                    </span>
+                  </div>
+                  {item.detail ? (
+                    <div
+                      className={cn(
+                        'truncate text-xs text-muted-foreground',
+                        item.tone === 'error' && 'text-red-500/80',
+                        item.tone === 'warning' && 'text-amber-600/80',
+                      )}
+                    >
+                      {item.detail}
+                    </div>
+                  ) : null}
+                </div>
+              </div>
+            ))}
+          </div>
+        </AccordionContent>
+      </AccordionItem>
+    </Accordion>
+  )
+})
diff --git a/components/task-chat-transcript.tsx b/components/task-chat-transcript.tsx
index 46f089c..975323a 100644
--- a/components/task-chat-transcript.tsx
+++ b/components/task-chat-transcript.tsx
@@ -3,14 +3,18 @@
 import { memo, useDeferredValue, useEffect, useMemo, useRef } from 'react'
 import { Check, Copy, Loader2, RotateCcw } from 'lucide-react'
 import type { LogEntry, Task } from '@/lib/db/schema'
+import { TaskAgentActivity } from '@/components/task-agent-activity'
 import type { ChatTaskMessage } from '@/lib/task-chat'
 import { buildChatTurns, parseTaskAgentMessage } from '@/lib/task-chat'
+import type { TaskAgentActivityItem } from '@/lib/task-agent-events'
 import { TaskChatMarkdown } from '@/components/task-chat-markdown'
 import { cn } from '@/lib/utils'
 
 interface TaskChatTranscriptProps {
+  activityItems: TaskAgentActivityItem[]
   copiedMessageId: string | null
   isGatewayTask: boolean
+  isStreaming: boolean
   logs: LogEntry[]
   messages: ChatTaskMessage[]
   onCopyMessage: (messageId: string, content: string) => void
@@ -23,8 +27,10 @@ function isTaskProcessing(status: Task['status']): boolean {
 }
 
 export const TaskChatTranscript = memo(function TaskChatTranscript({
+  activityItems,
   copiedMessageId,
   isGatewayTask,
+  isStreaming,
   logs,
   messages,
   onCopyMessage,
@@ -35,7 +41,7 @@ export const TaskChatTranscript = memo(function TaskChatTranscript({
   const wasAtBottomRef = useRef(true)
   const deferredMessages = useDeferredValue(messages)
   const turns = useMemo(() => buildChatTurns(deferredMessages), [deferredMessages])
-  const isProcessing = isTaskProcessing(status)
+  const isProcessing = isStreaming || isTaskProcessing(status)
 
   const visibleLogs = useMemo(() => logs.filter((entry) => !entry.message.startsWith('[SERVER]')).slice(-6), [logs])
 
@@ -129,6 +135,10 @@ export const TaskChatTranscript = memo(function TaskChatTranscript({
                 </div>
               ) : null}
 
+              {isGatewayTask && isLastTurn ? (
+                <TaskAgentActivity items={activityItems} isStreaming={isStreaming} />
+              ) : null}
+
               {turn.agentMessages.map((message) => {
                 const content = parseTaskAgentMessage(message.content).trim()
                 const isStreamingMessage = message.id.startsWith('gateway-stream-')
diff --git a/components/task-chat.tsx b/components/task-chat.tsx
index 218c093..45e9d9b 100644
--- a/components/task-chat.tsx
+++ b/components/task-chat.tsx
@@ -21,7 +21,7 @@ import { TaskChatComposer } from '@/components/task-chat-composer'
 import { TaskChatMarkdown } from '@/components/task-chat-markdown'
 import { TaskChatTranscript } from '@/components/task-chat-transcript'
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from '@/components/ui/dropdown-menu'
-import { useTaskChatMessages } from '@/lib/hooks/use-task-chat-messages'
+import { useTaskAgentChatV2 } from '@/lib/hooks/use-task-agent-chat-v2'
 
 interface TaskChatProps {
   taskId: string
@@ -57,10 +57,6 @@ interface DeploymentInfo {
   createdAt?: string
 }
 
-function isTaskProcessing(status: Task['status']): boolean {
-  return status === 'processing' || status === 'pending'
-}
-
 export function TaskChat({ taskId, task, chatOnly = false }: TaskChatProps) {
   const [activeTab, setActiveTab] = useState<'chat' | 'comments' | 'actions' | 'deployments'>('chat')
   const [newMessage, setNewMessage] = useAtom(taskChatInputAtomFamily(taskId))
@@ -79,17 +75,19 @@ export function TaskChat({ taskId, task, chatOnly = false }: TaskChatProps) {
   const deploymentLoadedRef = useRef(false)
 
   const {
+    activityItems,
     error: chatError,
     isGatewayTask,
     isLoading,
     isSending,
     isStopping,
+    isStreaming,
     messages,
     refreshMessages,
     retryMessage,
     sendMessage,
     stopTask,
-  } = useTaskChatMessages(taskId, task)
+  } = useTaskAgentChatV2(taskId, task)
 
   const fetchPRComments = useCallback(
     async (showLoading = true) => {
@@ -247,11 +245,11 @@ export function TaskChat({ taskId, task, chatOnly = false }: TaskChatProps) {
   const handleStopTask = useCallback(async () => {
     const result = await stopTask()
     if (result.success) {
-      toast.success('Task stopped successfully')
+      toast.success('Generation stopped')
       return
     }
 
-    toast.error(result.error || 'Failed to stop task')
+    toast.error(result.error || 'Failed to stop generation')
   }, [stopTask])
 
   const handleCopyMessage = useCallback(async (messageId: string, content: string) => {
@@ -584,8 +582,10 @@ export function TaskChat({ taskId, task, chatOnly = false }: TaskChatProps) {
 
     return (
       <TaskChatTranscript
+        activityItems={activityItems}
         copiedMessageId={copiedMessageId}
         isGatewayTask={isGatewayTask}
+        isStreaming={isStreaming}
         logs={task.logs || []}
         messages={messages}
         onCopyMessage={handleCopyMessage}
@@ -630,7 +630,7 @@ export function TaskChat({ taskId, task, chatOnly = false }: TaskChatProps) {
         <TaskChatComposer
           value={newMessage}
           setValue={setNewMessage}
-          isProcessing={isTaskProcessing(task.status)}
+          isProcessing={isStreaming}
           isSending={isSending}
           isStopping={isStopping}
           onSend={handleSendMessage}
diff --git a/components/task-form.tsx b/components/task-form.tsx
index 49261a7..0eda820 100644
--- a/components/task-form.tsx
+++ b/components/task-form.tsx
@@ -7,6 +7,7 @@ import { Loader2, ArrowUp } from 'lucide-react'
 import { useAtom } from 'jotai'
 import { taskPromptAtom } from '@/lib/atoms/task'
 import { githubReposAtomFamily } from '@/lib/atoms/github-cache'
+import { cn } from '@/lib/utils'
 
 interface GitHubRepo {
   name: string
@@ -30,8 +31,15 @@ interface TaskFormProps {
     enableBrowser: boolean
   }) => void
   isSubmitting: boolean
+  isAuthenticated: boolean
   selectedOwner: string
   selectedRepo: string
+  commandHeader?: React.ReactNode
+  variant?: 'default' | 'command'
+  commandDisabled?: boolean
+  commandPlaceholder?: string
+  commandHelperText?: string
+  alwaysShowCommandHelper?: boolean
   initialInstallDependencies?: boolean
   initialMaxDuration?: number
   initialKeepAlive?: boolean
@@ -45,13 +53,23 @@ const FIXED_TASK_MODEL = 'gpt-5.4'
 export function TaskForm({
   onSubmit,
   isSubmitting,
+  isAuthenticated,
   selectedOwner,
   selectedRepo,
+  commandHeader,
+  variant = 'default',
+  commandDisabled = false,
+  commandPlaceholder,
+  commandHelperText,
+  alwaysShowCommandHelper = false,
   initialMaxDuration = 300,
 }: TaskFormProps) {
   const [prompt, setPrompt] = useAtom(taskPromptAtom)
   const [repos, setRepos] = useAtom(githubReposAtomFamily(selectedOwner))
   const textareaRef = useRef<HTMLTextAreaElement>(null)
+  const hasSelectedRepo = Boolean(selectedOwner && selectedRepo)
+  const isCommandVariant = variant === 'command'
+  const defaultCommand = 'Prepare this repo for Sealos with /sealos-deploy.'
 
   const handleTextareaKeyDown = (event: React.KeyboardEvent<HTMLTextAreaElement>) => {
     if (event.key !== 'Enter') {
@@ -62,15 +80,19 @@ export function TaskForm({
 
     if (!isMobile && !event.shiftKey) {
       event.preventDefault()
-      if (prompt.trim()) {
+      if (!commandDisabled && (isCommandVariant || prompt.trim())) {
         event.currentTarget.closest('form')?.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }))
       }
     }
   }
 
   useEffect(() => {
+    if (commandDisabled || (typeof window !== 'undefined' && window.matchMedia('(max-width: 768px)').matches)) {
+      return
+    }
+
     textareaRef.current?.focus()
-  }, [])
+  }, [commandDisabled])
 
   useEffect(() => {
     if (!selectedOwner) {
@@ -100,15 +122,21 @@ export function TaskForm({
   const handleSubmit = (event: React.FormEvent) => {
     event.preventDefault()
 
+    if (commandDisabled) {
+      return
+    }
+
     const trimmedPrompt = prompt.trim()
-    if (!trimmedPrompt) {
+    const effectivePrompt = trimmedPrompt || (isCommandVariant ? defaultCommand : '')
+
+    if (!effectivePrompt) {
       return
     }
 
     const selectedRepoData = repos?.find((repo) => repo.name === selectedRepo)
 
     onSubmit({
-      prompt: trimmedPrompt,
+      prompt: effectivePrompt,
       repoUrl: selectedRepoData?.clone_url || '',
       selectedAgent: FIXED_TASK_AGENT,
       selectedModel: FIXED_TASK_MODEL,
@@ -119,44 +147,126 @@ export function TaskForm({
     })
   }
 
+  const title = !isAuthenticated
+    ? 'Sign In to Deploy on Sealos'
+    : hasSelectedRepo
+      ? 'Deploy Your Project to Sealos'
+      : 'Choose a Repository to Deploy'
+
+  const description = !isAuthenticated
+    ? 'Sign in first, then choose a GitHub repository and tell Sealos how it should be analyzed, built, and deployed.'
+    : hasSelectedRepo
+      ? 'Tell Sealos what you want to do with this repository. A simple deployment request is enough.'
+      : 'Connect GitHub if needed, choose a repository, then describe how Sealos should analyze, build, and deploy it.'
+
+  const repoBannerText = hasSelectedRepo
+    ? `${selectedOwner}/${selectedRepo}`
+    : !isAuthenticated
+      ? 'Sign in to choose a GitHub repository.'
+      : 'Choose a GitHub repository from the header to begin.'
+
+  const placeholder = isCommandVariant
+    ? (commandPlaceholder ?? defaultCommand)
+    : !isAuthenticated
+      ? 'Sign in first. After that, choose a repository and describe the deployment task here.'
+      : hasSelectedRepo
+        ? 'For example: deploy this repository to Sealos.'
+        : 'Choose a repository first. Then describe how Sealos should build and deploy it.'
+
+  const helperText = isCommandVariant
+    ? (commandHelperText ?? 'Enter to deploy. Shift+Enter for a new line.')
+    : !isAuthenticated
+      ? 'Start by signing in. After you pick a repository, you can describe the deployment task here.'
+      : hasSelectedRepo
+        ? ''
+        : 'After you pick a repository, describe what Sealos should build and deploy.'
+  const showCommandHelper =
+    isCommandVariant && Boolean(helperText) && (alwaysShowCommandHelper || prompt.trim().length > 0 || isSubmitting)
+
+  if (isCommandVariant) {
+    return (
+      <form onSubmit={handleSubmit} className="w-full max-w-3xl">
+        <label htmlFor="prompt" className="sr-only">
+          Deployment command
+        </label>
+
+        <div className="rounded-[28px] border border-border/70 bg-background/95 px-4 py-4 shadow-[0_20px_56px_-44px_rgba(0,0,0,0.45)] backdrop-blur sm:px-5 sm:py-5">
+          <div className="mb-3">{commandHeader ?? <div className="sealos-meta-value">{repoBannerText}</div>}</div>
+
+          <div className="flex flex-col gap-3 sm:flex-row sm:items-center">
+            <Textarea
+              ref={textareaRef}
+              id="prompt"
+              aria-label="Deployment command"
+              placeholder={placeholder}
+              value={prompt}
+              onChange={(event) => setPrompt(event.target.value)}
+              onKeyDown={handleTextareaKeyDown}
+              disabled={isSubmitting || commandDisabled}
+              required={false}
+              rows={1}
+              className={cn(
+                'sealos-command-text h-[52px] min-h-[52px] max-h-[52px] w-full flex-1 resize-none overflow-y-auto border-0 bg-transparent px-0 py-[11px] shadow-none focus-visible:ring-0 focus-visible:ring-offset-0 md:text-[17px]',
+                commandDisabled && 'cursor-not-allowed text-muted-foreground/90',
+              )}
+            />
+
+            <Button
+              type="submit"
+              disabled={isSubmitting || commandDisabled}
+              className="sealos-action-text h-11 rounded-full px-5 sm:flex-shrink-0"
+            >
+              {isSubmitting ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <>
+                  <ArrowUp className="h-4 w-4" />
+                  Deploy
+                </>
+              )}
+            </Button>
+          </div>
+
+          {showCommandHelper ? <div className="sealos-helper mt-2">{helperText}</div> : null}
+        </div>
+      </form>
+    )
+  }
+
   return (
     <div className="w-full max-w-2xl">
       <div className="mb-8 text-center">
-        <h1 className="text-3xl font-semibold tracking-tight sm:text-4xl">Deploy Your Project to Sealos</h1>
-        <p className="mt-2 text-sm text-muted-foreground">
-          Select a GitHub repository and describe how it should be analyzed, built, and deployed.
-        </p>
+        <h1 className="sealos-section-title text-foreground sm:text-[2.4rem]">{title}</h1>
+        <p className="sealos-body mx-auto mt-3">{description}</p>
       </div>
 
       <form onSubmit={handleSubmit}>
         <div className="overflow-hidden rounded-2xl border bg-background shadow-sm">
-          <div className="border-b bg-muted/20 px-4 py-2.5 text-xs text-muted-foreground">
-            {selectedOwner && selectedRepo
-              ? `${selectedOwner}/${selectedRepo}`
-              : 'Select a GitHub repository to begin.'}
-          </div>
+          <div className="sealos-meta-label border-b bg-muted/20 px-4 py-2.5">{repoBannerText}</div>
 
           <div className="bg-transparent">
             <Textarea
               ref={textareaRef}
               id="prompt"
-              placeholder="Describe how this repository should be analyzed, built, and deployed on Sealos."
+              placeholder={placeholder}
               value={prompt}
               onChange={(event) => setPrompt(event.target.value)}
               onKeyDown={handleTextareaKeyDown}
               disabled={isSubmitting}
               required
               rows={4}
-              className="min-h-[140px] w-full resize-none border-0 bg-transparent px-4 py-4 text-sm shadow-none focus-visible:ring-0 focus-visible:ring-offset-0 sm:text-base"
+              className="sealos-command-text min-h-[140px] w-full resize-none border-0 bg-transparent px-4 py-4 shadow-none focus-visible:ring-0 focus-visible:ring-offset-0 sm:text-base"
             />
           </div>
 
           <div className="flex items-center justify-between gap-3 px-4 py-3">
-            <div className="text-xs text-muted-foreground">
-              Example: detect the runtime, build the image, and deploy it to Sealos.
-            </div>
+            {helperText ? <div className="sealos-helper">{helperText}</div> : <div />}
 
-            <Button type="submit" disabled={isSubmitting || !prompt.trim()} className="h-9 rounded-full px-3">
+            <Button
+              type="submit"
+              disabled={isSubmitting || !prompt.trim()}
+              className="sealos-action-text h-9 rounded-full px-3"
+            >
               {isSubmitting ? <Loader2 className="h-4 w-4 animate-spin" /> : <ArrowUp className="h-4 w-4" />}
             </Button>
           </div>
diff --git a/global.d.ts b/global.d.ts
new file mode 100644
index 0000000..5894ae0
--- /dev/null
+++ b/global.d.ts
@@ -0,0 +1 @@
+declare module '*.css'
diff --git a/lib/codex-gateway/chat-v2-service.ts b/lib/codex-gateway/chat-v2-service.ts
new file mode 100644
index 0000000..1beac21
--- /dev/null
+++ b/lib/codex-gateway/chat-v2-service.ts
@@ -0,0 +1,97 @@
+import { eq } from 'drizzle-orm'
+import { startCodexGatewayTaskTurn, waitForCodexGatewayTurnCompletion } from '@/lib/codex-gateway/runner'
+import { db } from '@/lib/db/client'
+import { tasks, type Task } from '@/lib/db/schema'
+import { ensureTaskDevboxRuntime } from '@/lib/devbox/runtime'
+import { prependSealosDeployContext } from '@/lib/sealos-deploy-context'
+import { ensureTaskChatV2StreamDescriptor, type TaskChatV2StreamDescriptor } from '@/lib/task-chat-v2'
+import { appendUserMessageEvent, recordTaskEvent } from '@/lib/task-events'
+import { createTaskLogger } from '@/lib/utils/task-logger'
+import { formatKeyTaskLogMessage, TASK_FLOW_LOGS } from '@/lib/utils/task-flow-logs'
+
+export interface StartTaskChatV2TurnResult {
+  source: string
+  startedTurn: Awaited<ReturnType<typeof startCodexGatewayTaskTurn>>
+  stream: TaskChatV2StreamDescriptor
+}
+
+export async function startTaskChatV2Turn(input: {
+  prompt: string
+  source: string
+  task: Task
+}): Promise<StartTaskChatV2TurnResult> {
+  const logger = createTaskLogger(input.task.id)
+  const userInputReceivedLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.USER_INPUT_RECEIVED, {
+    promptChars: input.prompt.length,
+    source: input.source,
+    selectedModel: input.task.selectedModel || undefined,
+  })
+  await logger.info(userInputReceivedLog)
+  console.info(userInputReceivedLog)
+
+  await appendUserMessageEvent({
+    taskId: input.task.id,
+    content: input.prompt,
+    source: input.source,
+  })
+
+  const userInputSavedLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.USER_INPUT_SAVED, {
+    promptChars: input.prompt.length,
+    source: input.source,
+  })
+  await logger.info(userInputSavedLog)
+  console.info(userInputSavedLog)
+
+  await db
+    .update(tasks)
+    .set({
+      status: 'processing',
+      progress: 0,
+      error: null,
+      completedAt: null,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, input.task.id))
+
+  const runtime = await ensureTaskDevboxRuntime(input.task, { logger })
+  const gatewayPrompt = prependSealosDeployContext(input.prompt, runtime.namespace || input.task.runtimeNamespace)
+
+  const startedTurn = await startCodexGatewayTaskTurn(input.task.id, gatewayPrompt, {
+    appendUserMessage: false,
+    model: input.task.selectedModel,
+  })
+
+  await recordTaskEvent({
+    taskId: input.task.id,
+    kind: 'gateway.session.opened',
+    createdAt: startedTurn.startedAt,
+    sessionId: startedTurn.sessionId,
+    threadId: startedTurn.threadId,
+    turnId: startedTurn.turnId,
+    payload: {
+      sessionId: startedTurn.sessionId,
+      threadId: startedTurn.threadId,
+      turnId: startedTurn.turnId,
+    },
+  })
+
+  const stream = await ensureTaskChatV2StreamDescriptor({
+    taskId: input.task.id,
+    sessionId: startedTurn.sessionId,
+    threadId: startedTurn.threadId,
+    turnId: startedTurn.turnId,
+    startedAt: startedTurn.startedAt,
+  })
+
+  return {
+    source: input.source,
+    startedTurn,
+    stream,
+  }
+}
+
+export async function finalizeTaskChatV2Turn(
+  startedTurn: Awaited<ReturnType<typeof startCodexGatewayTaskTurn>>,
+): Promise<void> {
+  await waitForCodexGatewayTurnCompletion(startedTurn)
+}
diff --git a/lib/codex-gateway/client.ts b/lib/codex-gateway/client.ts
index c68e319..a3dad44 100644
--- a/lib/codex-gateway/client.ts
+++ b/lib/codex-gateway/client.ts
@@ -20,6 +20,7 @@ export class CodexGatewayApiError extends Error {
 
 const CODEX_GATEWAY_STARTUP_TIMEOUT_MS = 60_000
 const CODEX_GATEWAY_STARTUP_RETRY_MS = 1_000
+const CODEX_GATEWAY_REQUEST_TIMEOUT_MS = 60_000
 
 function buildUrl(baseUrl: string, path: string): string {
   const url = new URL(baseUrl)
@@ -53,10 +54,13 @@ async function request<T>(baseUrl: string, path: string, init?: RequestInit, aut
     headers.set('authorization', `Bearer ${authToken}`)
   }
 
+  const signal = init?.signal || AbortSignal.timeout(CODEX_GATEWAY_REQUEST_TIMEOUT_MS)
+
   const response = await fetch(requestUrl, {
     ...init,
     headers,
     cache: 'no-store',
+    signal,
   })
 
   const body = await parseResponse(response)
@@ -178,6 +182,22 @@ export async function sendCodexGatewayTurn(
   )
 }
 
+export async function interruptCodexGatewayTurn(
+  baseUrl: string,
+  sessionId: string,
+  authToken?: string | null,
+): Promise<CodexGatewaySessionResponse> {
+  return await request<CodexGatewaySessionResponse>(
+    baseUrl,
+    `/api/sessions/${encodeURIComponent(sessionId)}/turn/interrupt`,
+    {
+      method: 'POST',
+      body: JSON.stringify({}),
+    },
+    authToken,
+  )
+}
+
 export async function deleteCodexGatewaySession(
   baseUrl: string,
   sessionId: string,
diff --git a/lib/codex-gateway/completion.ts b/lib/codex-gateway/completion.ts
index 3de1e28..512c496 100644
--- a/lib/codex-gateway/completion.ts
+++ b/lib/codex-gateway/completion.ts
@@ -1,10 +1,12 @@
-import { and, desc, eq } from 'drizzle-orm'
+import { eq } from 'drizzle-orm'
 import { CodexGatewayApiError, getCodexGatewaySessionState } from '@/lib/codex-gateway/client'
 import { getAssistantContentAfterCursor } from '@/lib/codex-gateway/transcript'
 import { getTaskGatewayContextById } from '@/lib/codex-gateway/task'
 import { db } from '@/lib/db/client'
-import { taskMessages, tasks, type Task } from '@/lib/db/schema'
-import { generateId } from '@/lib/utils/id'
+import { tasks, type Task } from '@/lib/db/schema'
+import { buildProjectedAssistantMessageId, projectAssistantMessage } from '@/lib/task-event-projection'
+import { appendProjectedAssistantMessageEvent, recordTaskEvent } from '@/lib/task-events'
+import { OperationTimeoutError, withTimeout } from '@/lib/utils/async'
 
 export const TURN_COMPLETION_STATES = ['pending', 'running', 'completed', 'failed'] as const
 
@@ -14,7 +16,9 @@ interface TurnCheckpointInput {
   sessionId: string
   startedAt: Date
   taskId: string
+  threadId?: string | null
   transcriptCursor: number
+  turnId?: string | null
 }
 
 interface FinalizeTurnInput {
@@ -25,6 +29,7 @@ interface FinalizeTurnInput {
   success: boolean
   taskId: string
   transcriptCursor: number
+  turnStatus?: string | null
 }
 
 export function hasActiveTurnCheckpoint(task: Task | null | undefined): boolean {
@@ -45,8 +50,20 @@ export function getPreferredCodexSessionId(task: Task | null | undefined): strin
   return task?.gatewaySessionId || null
 }
 
+export function shouldAttemptTurnReconciliation(task: Task | null | undefined, minIntervalMs = 10_000): boolean {
+  if (!hasActiveTurnCheckpoint(task)) {
+    return false
+  }
+
+  if (!task?.turnCompletionCheckedAt) {
+    return true
+  }
+
+  return Date.now() - new Date(task.turnCompletionCheckedAt).getTime() >= minIntervalMs
+}
+
 export function buildCodexAssistantMessageId(sessionId: string, transcriptCursor: number): string {
-  return `codex-agent-${sessionId}-${transcriptCursor}`
+  return buildProjectedAssistantMessageId(sessionId, transcriptCursor)
 }
 
 export async function persistAssistantMessage(
@@ -56,46 +73,10 @@ export async function persistAssistantMessage(
     messageId?: string
   },
 ): Promise<void> {
-  const trimmedContent = content.trim()
-  if (!trimmedContent) {
-    return
-  }
-
-  if (options?.messageId) {
-    await db
-      .insert(taskMessages)
-      .values({
-        id: options.messageId,
-        taskId,
-        role: 'agent',
-        content: trimmedContent,
-      })
-      .onConflictDoUpdate({
-        target: taskMessages.id,
-        set: {
-          content: trimmedContent,
-        },
-      })
-
-    return
-  }
-
-  const [latestPersistedAgentMessage] = await db
-    .select({ content: taskMessages.content })
-    .from(taskMessages)
-    .where(and(eq(taskMessages.taskId, taskId), eq(taskMessages.role, 'agent')))
-    .orderBy(desc(taskMessages.createdAt))
-    .limit(1)
-
-  if (latestPersistedAgentMessage?.content.trim() === trimmedContent) {
-    return
-  }
-
-  await db.insert(taskMessages).values({
-    id: generateId(12),
+  await projectAssistantMessage({
     taskId,
-    role: 'agent',
-    content: trimmedContent,
+    content,
+    messageId: options?.messageId,
   })
 }
 
@@ -111,6 +92,19 @@ export async function recordTurnCheckpoint(input: TurnCheckpointInput): Promise<
       updatedAt: new Date(),
     })
     .where(eq(tasks.id, input.taskId))
+
+  await recordTaskEvent({
+    taskId: input.taskId,
+    kind: 'turn.started',
+    createdAt: input.startedAt,
+    sessionId: input.sessionId,
+    threadId: input.threadId,
+    turnId: input.turnId,
+    payload: {
+      transcriptCursor: input.transcriptCursor,
+      startedAt: input.startedAt.toISOString(),
+    },
+  })
 }
 
 export async function markTurnCompletionRunning(taskId: string): Promise<void> {
@@ -124,8 +118,28 @@ export async function markTurnCompletionRunning(taskId: string): Promise<void> {
 }
 
 export async function finalizeTurnCompletion(input: FinalizeTurnInput): Promise<Task | null> {
-  await persistAssistantMessage(input.taskId, input.assistantContent, {
-    messageId: buildCodexAssistantMessageId(input.sessionId, input.transcriptCursor),
+  const interrupted = input.turnStatus === 'interrupted'
+
+  if (input.assistantContent.trim()) {
+    await appendProjectedAssistantMessageEvent({
+      taskId: input.taskId,
+      sessionId: input.sessionId,
+      transcriptCursor: input.transcriptCursor,
+      content: input.assistantContent,
+    })
+  }
+
+  await recordTaskEvent({
+    taskId: input.taskId,
+    kind: interrupted ? 'turn.interrupted' : input.success ? 'turn.completed' : 'turn.failed',
+    sessionId: input.sessionId,
+    payload: {
+      transcriptCursor: input.transcriptCursor,
+      content: input.assistantContent.trim() || null,
+      error: input.error,
+      success: input.success,
+      turnStatus: input.turnStatus || null,
+    },
   })
 
   const updates = {
@@ -134,9 +148,9 @@ export async function finalizeTurnCompletion(input: FinalizeTurnInput): Promise<
     activeTurnTranscriptCursor: null,
     turnCompletionState: input.success ? ('completed' as const) : ('failed' as const),
     turnCompletionCheckedAt: new Date(),
-    status: input.success ? ('completed' as const) : ('error' as const),
-    progress: input.success ? 100 : 0,
-    error: input.success ? null : input.error,
+    status: interrupted || input.success ? ('completed' as const) : ('error' as const),
+    progress: interrupted || input.success ? 100 : 0,
+    error: interrupted || input.success ? null : input.error,
     updatedAt: new Date(),
     ...(input.clearGatewaySession ? { gatewaySessionId: null } : {}),
   }
@@ -180,11 +194,17 @@ export async function reconcileIncompleteTurn(taskId: string): Promise<Task | nu
       sessionId: task.activeTurnSessionId,
       transcriptCursor: task.activeTurnTranscriptCursor!,
       assistantContent,
-      success: sessionState.state.lastTurnStatus === 'completed' || sessionState.state.lastTurnStatus === 'succeeded',
+      success:
+        sessionState.state.lastTurnStatus === 'completed' ||
+        sessionState.state.lastTurnStatus === 'succeeded' ||
+        sessionState.state.lastTurnStatus === 'interrupted',
       error:
-        sessionState.state.lastTurnStatus === 'completed' || sessionState.state.lastTurnStatus === 'succeeded'
+        sessionState.state.lastTurnStatus === 'completed' ||
+        sessionState.state.lastTurnStatus === 'succeeded' ||
+        sessionState.state.lastTurnStatus === 'interrupted'
           ? null
           : 'Codex gateway turn failed',
+      turnStatus: sessionState.state.lastTurnStatus,
     })
   } catch (error) {
     if (error instanceof CodexGatewayApiError && error.status === 404) {
@@ -202,3 +222,15 @@ export async function reconcileIncompleteTurn(taskId: string): Promise<Task | nu
     throw error
   }
 }
+
+export async function reconcileIncompleteTurnSafely(taskId: string, timeoutMs = 3_000): Promise<Task | null> {
+  try {
+    return await withTimeout(reconcileIncompleteTurn(taskId), timeoutMs, 'Codex turn reconcile timed out')
+  } catch (error) {
+    if (error instanceof OperationTimeoutError) {
+      return null
+    }
+
+    throw error
+  }
+}
diff --git a/lib/codex-gateway/config.ts b/lib/codex-gateway/config.ts
index 4d8a933..8788b75 100644
--- a/lib/codex-gateway/config.ts
+++ b/lib/codex-gateway/config.ts
@@ -1,21 +1,11 @@
 import type { DevboxInfo } from '@/lib/devbox/types'
 
-const DEFAULT_CODEX_GATEWAY_PORT = '1317'
 const DEFAULT_CODEX_GATEWAY_SESSION_TTL_MS = '14400000'
 
-export function getCodexGatewayPort(): string {
-  return process.env.CODEX_GATEWAY_PORT || DEFAULT_CODEX_GATEWAY_PORT
-}
-
 export function getCodexGatewaySessionTtlMs(): string {
   return process.env.CODEX_GATEWAY_SESSION_TTL_MS || DEFAULT_CODEX_GATEWAY_SESSION_TTL_MS
 }
 
-export function getCodexGatewayUrlTemplate(): string | null {
-  const value = process.env.DEVBOX_GATEWAY_URL_TEMPLATE?.trim()
-  return value || null
-}
-
 function getObjectValue(record: Record<string, unknown>, key: string): string | null {
   const value = record[key]
   return typeof value === 'string' && value.trim() ? value.trim() : null
@@ -53,16 +43,7 @@ export function resolveCodexGatewayUrl(
     return existingUrl
   }
 
-  const template = getCodexGatewayUrlTemplate()
-  if (!template) {
-    return null
-  }
-
-  if (!runtimeName && template.includes('{name}')) {
-    return null
-  }
-
-  return template.replaceAll('{name}', runtimeName || '').replaceAll('{port}', getCodexGatewayPort())
+  return null
 }
 
 export function getCodexGatewayAuthTokenFromDevboxInfo(info?: DevboxInfo | null): string | null {
diff --git a/lib/codex-gateway/runner.ts b/lib/codex-gateway/runner.ts
index fd87bef..731383a 100644
--- a/lib/codex-gateway/runner.ts
+++ b/lib/codex-gateway/runner.ts
@@ -24,7 +24,9 @@ export interface StartedCodexGatewayTurn {
   sessionId: string
   startedAt: Date
   taskId: string
+  threadId: string | null
   transcriptCursor: number
+  turnId: string | null
 }
 
 function sleep(ms: number): Promise<void> {
@@ -40,7 +42,7 @@ function getGatewayWaitTimeoutMs(maxDuration: number | null | undefined): number
 }
 
 function isSuccessfulTurnStatus(status: string | null | undefined): boolean {
-  return status === 'completed' || status === 'succeeded'
+  return status === 'completed' || status === 'succeeded' || status === 'interrupted'
 }
 
 function getTurnTranscriptCursor(
@@ -165,9 +167,11 @@ export async function startCodexGatewayTaskTurn(
 
   const startedAt = new Date()
   const transcriptCursor = getTurnTranscriptCursor(turnResponse.state.transcript)
+  const threadId = turnResponse.state.threadId || gatewayThreadId || null
+  const turnId = turnResponse.state.currentTurnId || null
   const turnWaitingLog = formatKeyTaskLogMessage(TASK_FLOW_LOGS.GATEWAY_TURN_WAITING, {
     sessionId: gatewaySessionId,
-    threadId: turnResponse.state.threadId,
+    threadId,
     transcriptCursor,
   })
   await logger.info(turnWaitingLog)
@@ -191,15 +195,19 @@ export async function startCodexGatewayTaskTurn(
   await recordTurnCheckpoint({
     taskId,
     sessionId: gatewaySessionId,
+    threadId,
     transcriptCursor,
     startedAt,
+    turnId,
   })
 
   return {
     taskId,
     sessionId: gatewaySessionId,
     startedAt,
+    threadId,
     transcriptCursor,
+    turnId,
     gatewayUrl,
     gatewayAuthToken,
   }
@@ -247,6 +255,7 @@ export async function waitForCodexGatewayTurnCompletion(startedTurn: StartedCode
           success: false,
           error: 'Codex gateway session is no longer available',
           clearGatewaySession: true,
+          turnStatus: finalState?.state.lastTurnStatus || null,
         })
 
         await refreshTaskDevboxLease({
@@ -279,6 +288,7 @@ export async function waitForCodexGatewayTurnCompletion(startedTurn: StartedCode
       assistantContent,
       success: false,
       error: 'Codex gateway response timed out',
+      turnStatus: finalState?.state.lastTurnStatus || null,
     })
 
     await refreshTaskDevboxLease({
@@ -300,6 +310,7 @@ export async function waitForCodexGatewayTurnCompletion(startedTurn: StartedCode
       assistantContent,
       success: true,
       error: null,
+      turnStatus: finalState.state.lastTurnStatus,
     })
 
     await refreshTaskDevboxLease({
@@ -325,6 +336,7 @@ export async function waitForCodexGatewayTurnCompletion(startedTurn: StartedCode
     assistantContent,
     success: false,
     error: 'Codex gateway turn failed',
+    turnStatus: finalState.state.lastTurnStatus,
   })
 
   await refreshTaskDevboxLease({
diff --git a/lib/codex-gateway/task.ts b/lib/codex-gateway/task.ts
index af6abcd..729f613 100644
--- a/lib/codex-gateway/task.ts
+++ b/lib/codex-gateway/task.ts
@@ -41,6 +41,8 @@ export async function getTaskGatewayContext(taskId: string, userId: string) {
       if (!(error instanceof DevboxApiError)) {
         throw error
       }
+
+      console.error('Failed to load Devbox info for gateway context:', error)
     }
   }
 
@@ -71,6 +73,8 @@ export async function getTaskGatewayContextById(taskId: string) {
       if (!(error instanceof DevboxApiError)) {
         throw error
       }
+
+      console.error('Failed to load Devbox info for gateway context by id:', error)
     }
   }
 
diff --git a/lib/constants.ts b/lib/constants.ts
index c40406d..06f321e 100644
--- a/lib/constants.ts
+++ b/lib/constants.ts
@@ -3,10 +3,3 @@ export const MAX_MESSAGES_PER_DAY = parseInt(process.env.MAX_MESSAGES_PER_DAY ||
 
 // Sandbox configuration (in minutes)
 export const MAX_SANDBOX_DURATION = parseInt(process.env.MAX_SANDBOX_DURATION || '300', 10)
-
-// Vercel deployment configuration
-export const VERCEL_DEPLOY_URL =
-  'https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fvercel-labs%2Fcoding-agent-template&env=DEVBOX_TOKEN,DEVBOX_GATEWAY_URL_TEMPLATE,JWE_SECRET,ENCRYPTION_KEY&envDescription=Required+environment+variables+for+the+coding+agent+template.+You+must+also+configure+at+least+one+OAuth+provider+(GitHub+or+Vercel)+after+deployment.+Optional+API+keys+can+be+added+later.&stores=%5B%7B%22type%22%3A%22postgres%22%7D%5D&project-name=coding-agent-template&repository-name=coding-agent-template'
-
-// Vercel button URL for markdown
-export const VERCEL_DEPLOY_BUTTON_URL = `[![Deploy with Vercel](https://vercel.com/button)](${VERCEL_DEPLOY_URL})`
diff --git a/lib/db/migrations/0026_marvelous_firelord.sql b/lib/db/migrations/0026_marvelous_firelord.sql
new file mode 100644
index 0000000..b44d4d7
--- /dev/null
+++ b/lib/db/migrations/0026_marvelous_firelord.sql
@@ -0,0 +1,28 @@
+CREATE TABLE "task_events" (
+	"id" text PRIMARY KEY NOT NULL,
+	"task_id" text NOT NULL,
+	"seq" integer NOT NULL,
+	"kind" text NOT NULL,
+	"stream_id" text,
+	"session_id" text,
+	"thread_id" text,
+	"turn_id" text,
+	"payload" jsonb,
+	"created_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "task_streams" (
+	"id" text PRIMARY KEY NOT NULL,
+	"task_id" text NOT NULL,
+	"session_id" text NOT NULL,
+	"thread_id" text,
+	"turn_id" text,
+	"status" text DEFAULT 'active' NOT NULL,
+	"started_at" timestamp DEFAULT now() NOT NULL,
+	"last_event_at" timestamp DEFAULT now() NOT NULL,
+	"ended_at" timestamp
+);
+--> statement-breakpoint
+ALTER TABLE "task_events" ADD CONSTRAINT "task_events_task_id_tasks_id_fk" FOREIGN KEY ("task_id") REFERENCES "public"."tasks"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "task_streams" ADD CONSTRAINT "task_streams_task_id_tasks_id_fk" FOREIGN KEY ("task_id") REFERENCES "public"."tasks"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+CREATE UNIQUE INDEX "task_events_task_id_seq_idx" ON "task_events" USING btree ("task_id","seq");
\ No newline at end of file
diff --git a/lib/db/migrations/meta/0026_snapshot.json b/lib/db/migrations/meta/0026_snapshot.json
new file mode 100644
index 0000000..fd3911d
--- /dev/null
+++ b/lib/db/migrations/meta/0026_snapshot.json
@@ -0,0 +1,1094 @@
+{
+  "id": "5d6073f2-db34-472c-997c-eb57bce17c2e",
+  "prevId": "6d16d09f-64c4-49b6-982f-96550249958d",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.accounts": {
+      "name": "accounts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'github'"
+        },
+        "external_user_id": {
+          "name": "external_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "accounts_user_id_provider_idx": {
+          "name": "accounts_user_id_provider_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "accounts_user_id_users_id_fk": {
+          "name": "accounts_user_id_users_id_fk",
+          "tableFrom": "accounts",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.connectors": {
+      "name": "connectors",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'remote'"
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "oauth_client_id": {
+          "name": "oauth_client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "oauth_client_secret": {
+          "name": "oauth_client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "command": {
+          "name": "command",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "env": {
+          "name": "env",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'disconnected'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "connectors_user_id_users_id_fk": {
+          "name": "connectors_user_id_users_id_fk",
+          "tableFrom": "connectors",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.keys": {
+      "name": "keys",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "keys_user_id_provider_idx": {
+          "name": "keys_user_id_provider_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "keys_user_id_users_id_fk": {
+          "name": "keys_user_id_users_id_fk",
+          "tableFrom": "keys",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.settings": {
+      "name": "settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "settings_user_id_key_idx": {
+          "name": "settings_user_id_key_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "settings_user_id_users_id_fk": {
+          "name": "settings_user_id_users_id_fk",
+          "tableFrom": "settings",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.task_events": {
+      "name": "task_events",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "task_id": {
+          "name": "task_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "seq": {
+          "name": "seq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stream_id": {
+          "name": "stream_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "turn_id": {
+          "name": "turn_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "task_events_task_id_seq_idx": {
+          "name": "task_events_task_id_seq_idx",
+          "columns": [
+            {
+              "expression": "task_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "seq",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "task_events_task_id_tasks_id_fk": {
+          "name": "task_events_task_id_tasks_id_fk",
+          "tableFrom": "task_events",
+          "tableTo": "tasks",
+          "columnsFrom": [
+            "task_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.task_messages": {
+      "name": "task_messages",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "task_id": {
+          "name": "task_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "role": {
+          "name": "role",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "task_messages_task_id_tasks_id_fk": {
+          "name": "task_messages_task_id_tasks_id_fk",
+          "tableFrom": "task_messages",
+          "tableTo": "tasks",
+          "columnsFrom": [
+            "task_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.task_streams": {
+      "name": "task_streams",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "task_id": {
+          "name": "task_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "turn_id": {
+          "name": "turn_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'active'"
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_event_at": {
+          "name": "last_event_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "task_streams_task_id_tasks_id_fk": {
+          "name": "task_streams_task_id_tasks_id_fk",
+          "tableFrom": "task_streams",
+          "tableTo": "tasks",
+          "columnsFrom": [
+            "task_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tasks": {
+      "name": "tasks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "prompt": {
+          "name": "prompt",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "repo_url": {
+          "name": "repo_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "selected_agent": {
+          "name": "selected_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "default": "'claude'"
+        },
+        "selected_model": {
+          "name": "selected_model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "install_dependencies": {
+          "name": "install_dependencies",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "max_duration": {
+          "name": "max_duration",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 300
+        },
+        "keep_alive": {
+          "name": "keep_alive",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "enable_browser": {
+          "name": "enable_browser",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false,
+          "default": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "progress": {
+          "name": "progress",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 0
+        },
+        "logs": {
+          "name": "logs",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "branch_name": {
+          "name": "branch_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "runtime_provider": {
+          "name": "runtime_provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "runtime_name": {
+          "name": "runtime_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "runtime_namespace": {
+          "name": "runtime_namespace",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "runtime_state": {
+          "name": "runtime_state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "workspace_prepared_at": {
+          "name": "workspace_prepared_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "workspace_fingerprint": {
+          "name": "workspace_fingerprint",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "runtime_checked_at": {
+          "name": "runtime_checked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gateway_ready_at": {
+          "name": "gateway_ready_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gateway_url": {
+          "name": "gateway_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "gateway_session_id": {
+          "name": "gateway_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_turn_session_id": {
+          "name": "active_turn_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_turn_started_at": {
+          "name": "active_turn_started_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "active_turn_transcript_cursor": {
+          "name": "active_turn_transcript_cursor",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "turn_completion_state": {
+          "name": "turn_completion_state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "turn_completion_checked_at": {
+          "name": "turn_completion_checked_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sandbox_id": {
+          "name": "sandbox_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "agent_session_id": {
+          "name": "agent_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sandbox_url": {
+          "name": "sandbox_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "preview_url": {
+          "name": "preview_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pr_url": {
+          "name": "pr_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pr_number": {
+          "name": "pr_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pr_status": {
+          "name": "pr_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pr_merge_commit_sha": {
+          "name": "pr_merge_commit_sha",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mcp_server_ids": {
+          "name": "mcp_server_ids",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "tasks_user_id_users_id_fk": {
+          "name": "tasks_user_id_users_id_fk",
+          "tableFrom": "tasks",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_token": {
+          "name": "access_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "refresh_token": {
+          "name": "refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "username": {
+          "name": "username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "users_provider_external_id_idx": {
+          "name": "users_provider_external_id_idx",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "external_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
\ No newline at end of file
diff --git a/lib/db/migrations/meta/_journal.json b/lib/db/migrations/meta/_journal.json
index 5858a75..8c0f278 100644
--- a/lib/db/migrations/meta/_journal.json
+++ b/lib/db/migrations/meta/_journal.json
@@ -183,6 +183,13 @@
       "when": 1776607079323,
       "tag": "0025_spicy_karen_page",
       "breakpoints": true
+    },
+    {
+      "idx": 26,
+      "version": "7",
+      "when": 1776685833943,
+      "tag": "0026_marvelous_firelord",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/lib/db/schema.ts b/lib/db/schema.ts
index 16cbc17..4786ce0 100644
--- a/lib/db/schema.ts
+++ b/lib/db/schema.ts
@@ -406,6 +406,119 @@ export const selectKeySchema = z.object({
 export type Key = z.infer<typeof selectKeySchema>
 export type InsertKey = z.infer<typeof insertKeySchema>
 
+export const taskEventKindValues = [
+  'user_message.created',
+  'gateway.session.opened',
+  'gateway.state.snapshot',
+  'gateway.notification',
+  'gateway.server_request',
+  'gateway.warning',
+  'gateway.session.closed',
+  'turn.started',
+  'turn.interrupted',
+  'turn.completed',
+  'turn.failed',
+  'assistant.message.projected',
+] as const
+
+export const taskEventKindSchema = z.enum(taskEventKindValues)
+export type TaskEventKind = z.infer<typeof taskEventKindSchema>
+
+export const taskEvents = pgTable(
+  'task_events',
+  {
+    id: text('id').primaryKey(),
+    taskId: text('task_id')
+      .notNull()
+      .references(() => tasks.id, { onDelete: 'cascade' }),
+    seq: integer('seq').notNull(),
+    kind: text('kind').notNull().$type<TaskEventKind>(),
+    streamId: text('stream_id'),
+    sessionId: text('session_id'),
+    threadId: text('thread_id'),
+    turnId: text('turn_id'),
+    payload: jsonb('payload').$type<Record<string, unknown> | null>(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+  },
+  (table) => ({
+    taskSeqUnique: uniqueIndex('task_events_task_id_seq_idx').on(table.taskId, table.seq),
+  }),
+)
+
+export const insertTaskEventSchema = z.object({
+  id: z.string().optional(),
+  taskId: z.string().min(1, 'Task ID is required'),
+  seq: z.number().int().nonnegative().optional(),
+  kind: taskEventKindSchema,
+  streamId: z.string().optional(),
+  sessionId: z.string().optional(),
+  threadId: z.string().optional(),
+  turnId: z.string().optional(),
+  payload: z.record(z.string(), z.unknown()).nullable().optional(),
+  createdAt: z.date().optional(),
+})
+
+export const selectTaskEventSchema = z.object({
+  id: z.string(),
+  taskId: z.string(),
+  seq: z.number().int(),
+  kind: taskEventKindSchema,
+  streamId: z.string().nullable(),
+  sessionId: z.string().nullable(),
+  threadId: z.string().nullable(),
+  turnId: z.string().nullable(),
+  payload: z.record(z.string(), z.unknown()).nullable(),
+  createdAt: z.date(),
+})
+
+export type TaskEvent = z.infer<typeof selectTaskEventSchema>
+export type InsertTaskEvent = z.infer<typeof insertTaskEventSchema>
+
+export const taskStreamStatusValues = ['active', 'closed', 'errored'] as const
+export const taskStreamStatusSchema = z.enum(taskStreamStatusValues)
+export type TaskStreamStatus = z.infer<typeof taskStreamStatusSchema>
+
+export const taskStreams = pgTable('task_streams', {
+  id: text('id').primaryKey(),
+  taskId: text('task_id')
+    .notNull()
+    .references(() => tasks.id, { onDelete: 'cascade' }),
+  sessionId: text('session_id').notNull(),
+  threadId: text('thread_id'),
+  turnId: text('turn_id'),
+  status: text('status').notNull().$type<TaskStreamStatus>().default('active'),
+  startedAt: timestamp('started_at').defaultNow().notNull(),
+  lastEventAt: timestamp('last_event_at').defaultNow().notNull(),
+  endedAt: timestamp('ended_at'),
+})
+
+export const insertTaskStreamSchema = z.object({
+  id: z.string().optional(),
+  taskId: z.string().min(1, 'Task ID is required'),
+  sessionId: z.string().min(1, 'Session ID is required'),
+  threadId: z.string().optional(),
+  turnId: z.string().optional(),
+  status: taskStreamStatusSchema.optional(),
+  startedAt: z.date().optional(),
+  lastEventAt: z.date().optional(),
+  endedAt: z.date().optional(),
+})
+
+export const selectTaskStreamSchema = z.object({
+  id: z.string(),
+  taskId: z.string(),
+  sessionId: z.string(),
+  threadId: z.string().nullable(),
+  turnId: z.string().nullable(),
+  status: taskStreamStatusSchema,
+  startedAt: z.date(),
+  lastEventAt: z.date(),
+  endedAt: z.date().nullable(),
+})
+
+export type TaskStream = z.infer<typeof selectTaskStreamSchema>
+export type InsertTaskStream = z.infer<typeof insertTaskStreamSchema>
+
 // Task messages table - stores user and agent messages for each task
 export const taskMessages = pgTable('task_messages', {
   id: text('id').primaryKey(),
diff --git a/lib/devbox/client.ts b/lib/devbox/client.ts
index 10a3faa..dcbcedb 100644
--- a/lib/devbox/client.ts
+++ b/lib/devbox/client.ts
@@ -24,6 +24,9 @@ export class DevboxApiError extends Error {
   }
 }
 
+const DEVBOX_REQUEST_TIMEOUT_MS = 60_000
+const DEVBOX_EXEC_REQUEST_BUFFER_MS = 10_000
+
 function buildUrl(pathname: string, searchParams?: URLSearchParams, includeApiPrefix: boolean = true): string {
   const basePath = includeApiPrefix ? `${getDevboxApiPrefix()}${pathname}` : pathname
   const url = new URL(basePath, getDevboxBaseUrl())
@@ -62,41 +65,62 @@ async function devboxRequest<T>(
     skipAuth?: boolean
     searchParams?: URLSearchParams
     includeApiPrefix?: boolean
+    timeoutMs?: number
   },
 ): Promise<DevboxEnvelope<T>> {
-  const headers = new Headers(init?.headers)
+  const { headers: initHeaders, skipAuth, searchParams, includeApiPrefix, timeoutMs, ...requestInit } = init || {}
+  const headers = new Headers(initHeaders)
 
-  if (!init?.skipAuth) {
+  if (!skipAuth) {
     const token = await getDevboxAuthToken()
     headers.set('Authorization', `Bearer ${token}`)
   }
 
-  if (init?.body && !headers.has('Content-Type')) {
+  if (requestInit.body && !headers.has('Content-Type')) {
     headers.set('Content-Type', 'application/json')
   }
 
-  const response = await fetch(buildUrl(pathname, init?.searchParams, init?.includeApiPrefix), {
-    ...init,
+  const signal = requestInit.signal || AbortSignal.timeout(timeoutMs ?? DEVBOX_REQUEST_TIMEOUT_MS)
+
+  const response = await fetch(buildUrl(pathname, searchParams, includeApiPrefix), {
+    ...requestInit,
     headers,
     cache: 'no-store',
+    signal,
   })
 
   return await parseJsonResponse<T>(response)
 }
 
 export async function getDevboxHealth() {
-  return await devboxRequest<DevboxHealthData>('/healthz', {
-    method: 'GET',
-    skipAuth: true,
-    includeApiPrefix: false,
-  })
+  console.info('Devbox health request started')
+  try {
+    const result = await devboxRequest<DevboxHealthData>('/healthz', {
+      method: 'GET',
+      skipAuth: true,
+      includeApiPrefix: false,
+    })
+    console.info('Devbox health request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox health request failed:', error)
+    throw error
+  }
 }
 
 export async function createDevbox(input: CreateDevboxInput) {
-  return await devboxRequest<CreateDevboxResult>('', {
-    method: 'POST',
-    body: JSON.stringify(input),
-  })
+  console.info('Devbox create request started')
+  try {
+    const result = await devboxRequest<CreateDevboxResult>('', {
+      method: 'POST',
+      body: JSON.stringify(input),
+    })
+    console.info('Devbox create request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox create request failed:', error)
+    throw error
+  }
 }
 
 export async function listDevboxes(upstreamID?: string) {
@@ -105,46 +129,107 @@ export async function listDevboxes(upstreamID?: string) {
     searchParams.set('upstreamID', upstreamID)
   }
 
-  return await devboxRequest<{ items: DevboxListItem[] }>('', {
-    method: 'GET',
-    searchParams,
-  })
+  console.info('Devbox list request started')
+  try {
+    const result = await devboxRequest<{ items: DevboxListItem[] }>('', {
+      method: 'GET',
+      searchParams,
+    })
+    console.info('Devbox list request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox list request failed:', error)
+    throw error
+  }
 }
 
 export async function getDevbox(name: string) {
-  return await devboxRequest<DevboxInfo>(`/${encodeURIComponent(name)}`, {
-    method: 'GET',
-  })
+  console.info('Devbox get request started')
+  try {
+    const result = await devboxRequest<DevboxInfo>(`/${encodeURIComponent(name)}`, {
+      method: 'GET',
+    })
+    console.info('Devbox get request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox get request failed:', error)
+    throw error
+  }
 }
 
 export async function pauseDevbox(name: string) {
-  return await devboxRequest<PauseDevboxResult>(`/${encodeURIComponent(name)}/pause`, {
-    method: 'POST',
-  })
+  console.info('Devbox pause request started')
+  try {
+    const result = await devboxRequest<PauseDevboxResult>(`/${encodeURIComponent(name)}/pause`, {
+      method: 'POST',
+    })
+    console.info('Devbox pause request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox pause request failed:', error)
+    throw error
+  }
 }
 
 export async function refreshDevboxPause(name: string, input: RefreshPauseInput) {
-  return await devboxRequest<RefreshPauseResult>(`/${encodeURIComponent(name)}/pause/refresh`, {
-    method: 'POST',
-    body: JSON.stringify(input),
-  })
+  console.info('Devbox refresh pause request started')
+  try {
+    const result = await devboxRequest<RefreshPauseResult>(`/${encodeURIComponent(name)}/pause/refresh`, {
+      method: 'POST',
+      body: JSON.stringify(input),
+    })
+    console.info('Devbox refresh pause request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox refresh pause request failed:', error)
+    throw error
+  }
 }
 
 export async function resumeDevbox(name: string) {
-  return await devboxRequest<PauseDevboxResult>(`/${encodeURIComponent(name)}/resume`, {
-    method: 'POST',
-  })
+  console.info('Devbox resume request started')
+  try {
+    const result = await devboxRequest<PauseDevboxResult>(`/${encodeURIComponent(name)}/resume`, {
+      method: 'POST',
+    })
+    console.info('Devbox resume request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox resume request failed:', error)
+    throw error
+  }
 }
 
 export async function deleteDevbox(name: string) {
-  return await devboxRequest<DeleteDevboxResult>(`/${encodeURIComponent(name)}`, {
-    method: 'DELETE',
-  })
+  console.info('Devbox delete request started')
+  try {
+    const result = await devboxRequest<DeleteDevboxResult>(`/${encodeURIComponent(name)}`, {
+      method: 'DELETE',
+    })
+    console.info('Devbox delete request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox delete request failed:', error)
+    throw error
+  }
 }
 
 export async function execDevbox(name: string, input: DevboxExecInput) {
-  return await devboxRequest<DevboxExecResult>(`/${encodeURIComponent(name)}/exec`, {
-    method: 'POST',
-    body: JSON.stringify(input),
-  })
+  console.info('Devbox exec request started')
+  try {
+    const timeoutMs = Math.max(
+      DEVBOX_REQUEST_TIMEOUT_MS,
+      (input.timeoutSeconds ?? 60) * 1000 + DEVBOX_EXEC_REQUEST_BUFFER_MS,
+    )
+    const result = await devboxRequest<DevboxExecResult>(`/${encodeURIComponent(name)}/exec`, {
+      method: 'POST',
+      body: JSON.stringify(input),
+      timeoutMs,
+    })
+    console.info('Devbox exec request finished')
+    return result
+  } catch (error) {
+    console.error('Devbox exec request failed:', error)
+    throw error
+  }
 }
diff --git a/lib/devbox/config.ts b/lib/devbox/config.ts
index dc97e6b..dce6f59 100644
--- a/lib/devbox/config.ts
+++ b/lib/devbox/config.ts
@@ -1,6 +1,6 @@
 import { SignJWT } from 'jose'
+import { getSealosDevboxBaseUrl } from '@/lib/sealos/config'
 
-const DEFAULT_DEVBOX_BASE_URL = 'https://devbox-server.staging-usw-1.sealos.io'
 const DEVBOX_API_PREFIX = '/api/v1/devbox'
 const DEFAULT_DEVBOX_NAMESPACE = 'ns-test'
 const DEFAULT_DEVBOX_TOKEN_TTL_SECONDS = 4 * 60 * 60
@@ -16,7 +16,7 @@ function getRequiredEnv(name: string): string {
 }
 
 export function getDevboxBaseUrl(): string {
-  return process.env.DEVBOX_BASE_URL || DEFAULT_DEVBOX_BASE_URL
+  return getSealosDevboxBaseUrl()
 }
 
 export function getDevboxApiPrefix(): string {
diff --git a/lib/devbox/preview.ts b/lib/devbox/preview.ts
index b960bce..56f9cdb 100644
--- a/lib/devbox/preview.ts
+++ b/lib/devbox/preview.ts
@@ -1,7 +1,7 @@
 import { eq } from 'drizzle-orm'
 import { db } from '@/lib/db/client'
 import { type Task, tasks } from '@/lib/db/schema'
-import { buildDevboxUrl, execInTaskWorkspace, ensureOwnedTaskRuntime } from '@/lib/devbox/task-compat'
+import { buildRuntimePortUrl, execInTaskWorkspace, ensureOwnedTaskRuntime } from '@/lib/devbox/task-compat'
 
 export interface TaskPreviewRuntime {
   packageJson: Record<string, unknown>
@@ -108,7 +108,7 @@ function getDevCommand(packageJson: Record<string, unknown>, packageManager: 'pn
 }
 
 export async function ensureTaskPreviewRuntime(task: Task): Promise<TaskPreviewRuntime> {
-  const { task: runtimeTask, runtimeName } = await ensureOwnedTaskRuntime(task)
+  const { task: runtimeTask } = await ensureOwnedTaskRuntime(task)
   const packageJson = await readPackageJson(runtimeTask)
 
   if (!packageJson) {
@@ -124,7 +124,7 @@ export async function ensureTaskPreviewRuntime(task: Task): Promise<TaskPreviewR
   await installDependencies(runtimeTask, packageManager)
 
   const port = detectPreviewPort(packageJson)
-  const previewUrl = buildDevboxUrl(runtimeName, port)
+  const previewUrl = buildRuntimePortUrl(runtimeTask.gatewayUrl, port)
 
   return {
     packageJson,
diff --git a/lib/devbox/runtime.ts b/lib/devbox/runtime.ts
index 90c4f00..3a1f1ec 100644
--- a/lib/devbox/runtime.ts
+++ b/lib/devbox/runtime.ts
@@ -304,6 +304,7 @@ ${managedCodexConfigToml}EOF`,
   })
   await logger?.info(workspaceBootstrappingLog)
   console.info(workspaceBootstrappingLog)
+  console.info('Devbox workspace bootstrap started')
 
   const startedAt = Date.now()
   let lastPendingError = false
@@ -312,6 +313,7 @@ ${managedCodexConfigToml}EOF`,
     try {
       const runtime = await getDevbox(runtimeName)
       if (runtime.data.state.phase !== 'Running') {
+        console.info('Devbox workspace bootstrap waiting for runtime')
         lastPendingError = true
         if (Date.now() - startedAt >= DEVBOX_BOOTSTRAP_READY_TIMEOUT_MS) {
           break
@@ -320,10 +322,12 @@ ${managedCodexConfigToml}EOF`,
         continue
       }
 
+      console.info('Devbox workspace bootstrap exec started')
       const execResponse = await execDevbox(runtimeName, {
         command: ['sh', '-lc', bootstrapScript.join('\n')],
         timeoutSeconds: 300,
       })
+      console.info('Devbox workspace bootstrap exec finished')
 
       if (execResponse.data.exitCode !== 0) {
         console.error('Devbox workspace bootstrap failed')
@@ -346,6 +350,7 @@ ${managedCodexConfigToml}EOF`,
         error.status === 409 &&
         error.message.includes('devbox pod is not running')
       ) {
+        console.info('Devbox workspace bootstrap waiting for pod')
         lastPendingError = true
         if (Date.now() - startedAt >= DEVBOX_BOOTSTRAP_READY_TIMEOUT_MS) {
           break
@@ -354,14 +359,17 @@ ${managedCodexConfigToml}EOF`,
         continue
       }
 
+      console.error('Devbox workspace bootstrap failed:', error)
       throw error
     }
   }
 
   if (lastPendingError) {
+    console.error('Devbox workspace bootstrap timed out')
     throw new Error('Timed out waiting for Devbox workspace bootstrap')
   }
 
+  console.error('Devbox workspace bootstrap did not complete')
   throw new Error('Devbox workspace bootstrap did not complete')
 }
 
diff --git a/lib/devbox/task-compat.ts b/lib/devbox/task-compat.ts
index 002e1b7..4f54811 100644
--- a/lib/devbox/task-compat.ts
+++ b/lib/devbox/task-compat.ts
@@ -174,21 +174,15 @@ export function toTaskRelativePath(targetPath: string): string {
   return normalizeRelativePath(targetPath)
 }
 
-export function buildDevboxUrl(runtimeName: string, port: number): string | null {
-  const template = process.env.DEVBOX_GATEWAY_URL_TEMPLATE?.trim()
-  if (!template) {
+export function buildRuntimePortUrl(baseUrl: string | null | undefined, port: number): string | null {
+  const resolvedBaseUrl = baseUrl?.trim()
+  if (!resolvedBaseUrl) {
     return null
   }
 
-  if (template.includes('{name}') || template.includes('{port}')) {
-    return template.replaceAll('{name}', runtimeName).replaceAll('{port}', String(port))
-  }
-
   try {
-    const url = new URL(template)
-    if (url.port) {
-      url.port = String(port)
-    }
+    const url = new URL(resolvedBaseUrl)
+    url.port = String(port)
     return url.toString()
   } catch {
     return null
diff --git a/lib/hooks/use-task-agent-chat-v2.ts b/lib/hooks/use-task-agent-chat-v2.ts
new file mode 100644
index 0000000..e9e93b8
--- /dev/null
+++ b/lib/hooks/use-task-agent-chat-v2.ts
@@ -0,0 +1,422 @@
+'use client'
+
+import { startTransition, useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import type { CodexGatewayState } from '@/lib/codex-gateway/types'
+import type { Task, TaskEvent, TaskMessage } from '@/lib/db/schema'
+import {
+  areTaskMessagesEqual,
+  buildStreamingAgentMessage,
+  buildStreamingAgentMessageFromState,
+  combineChatMessages,
+  createOptimisticUserMessage,
+  hasPersistedAssistantContent,
+  reconcileOptimisticMessages,
+} from '@/lib/task-chat'
+import {
+  buildAgentActivityItemsFromState,
+  buildAgentActivityItemsFromTaskEvents,
+  type TaskAgentActivityItem,
+} from '@/lib/task-agent-events'
+import type { TaskChatV2StreamDescriptor } from '@/lib/task-chat-v2'
+
+interface ChatActionResult {
+  success: boolean
+  error?: string
+}
+
+interface ChatV2BootstrapResponse {
+  success: boolean
+  data?: {
+    events: TaskEvent[]
+    messages: TaskMessage[]
+    stream: TaskChatV2StreamDescriptor | null
+    task: Task
+  }
+  error?: string
+}
+
+interface ChatV2TurnResponse {
+  success: boolean
+  data?: {
+    session: {
+      sessionId: string
+      threadId: string | null
+      turnId: string | null
+    }
+    stream: TaskChatV2StreamDescriptor
+    turn: {
+      transcriptCursor: number
+      turnAccepted: boolean
+      turnStartedAt: string
+    }
+  }
+  error?: string
+}
+
+function isTaskStreaming(task: Task): boolean {
+  return (
+    Boolean(task.activeTurnSessionId) &&
+    task.turnCompletionState !== 'completed' &&
+    task.turnCompletionState !== 'failed'
+  )
+}
+
+export function useTaskAgentChatV2(taskId: string, task: Task) {
+  const [persistedMessages, setPersistedMessages] = useState<TaskMessage[]>([])
+  const [persistedEvents, setPersistedEvents] = useState<TaskEvent[]>([])
+  const [pendingMessages, setPendingMessages] = useState<ReturnType<typeof createOptimisticUserMessage>[]>([])
+  const [liveState, setLiveState] = useState<CodexGatewayState | null>(null)
+  const [retainedStreamingMessage, setRetainedStreamingMessage] = useState<TaskMessage | null>(null)
+  const [activeStream, setActiveStream] = useState<TaskChatV2StreamDescriptor | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [isSending, setIsSending] = useState(false)
+  const [isStopping, setIsStopping] = useState(false)
+  const eventSourceRef = useRef<EventSource | null>(null)
+  const reconnectTimeoutRef = useRef<number | null>(null)
+  const reconnectAttemptRef = useRef(0)
+  const lastTaskUpdateRef = useRef<string | null>(null)
+
+  const clearReconnectTimer = useCallback(() => {
+    if (reconnectTimeoutRef.current !== null) {
+      window.clearTimeout(reconnectTimeoutRef.current)
+      reconnectTimeoutRef.current = null
+    }
+  }, [])
+
+  const refreshChat = useCallback(
+    async (showLoading = true): Promise<boolean> => {
+      if (showLoading) {
+        setIsLoading(true)
+      }
+
+      setError(null)
+
+      try {
+        const response = await fetch(`/api/tasks/${taskId}/chat/v2`, {
+          cache: 'no-store',
+        })
+        const data = (await response.json()) as ChatV2BootstrapResponse
+
+        if (!response.ok || !data.success || !data.data) {
+          setError(data.error || 'Failed to fetch chat state')
+          return false
+        }
+
+        startTransition(() => {
+          setPersistedMessages((previousMessages) =>
+            areTaskMessagesEqual(previousMessages, data.data!.messages) ? previousMessages : data.data!.messages,
+          )
+          setPersistedEvents(data.data!.events)
+          setPendingMessages((previousMessages) => reconcileOptimisticMessages(previousMessages, data.data!.messages))
+          setActiveStream((previousStream) =>
+            previousStream?.streamId === data.data!.stream?.streamId ? previousStream : data.data!.stream,
+          )
+          if (!data.data!.stream) {
+            setLiveState(null)
+          }
+          setRetainedStreamingMessage((previousMessage) => {
+            if (!previousMessage) {
+              return previousMessage
+            }
+
+            return hasPersistedAssistantContent(data.data!.messages, previousMessage.content) ? null : previousMessage
+          })
+        })
+
+        return true
+      } catch {
+        setError('Failed to fetch chat state')
+        return false
+      } finally {
+        if (showLoading) {
+          setIsLoading(false)
+        }
+      }
+    },
+    [taskId],
+  )
+
+  useEffect(() => {
+    void refreshChat(true)
+  }, [refreshChat])
+
+  useEffect(() => {
+    return () => {
+      clearReconnectTimer()
+    }
+  }, [clearReconnectTimer])
+
+  useEffect(() => {
+    const taskUpdateToken = task.updatedAt ? new Date(task.updatedAt).toISOString() : null
+    if (!taskUpdateToken) {
+      return
+    }
+
+    if (!lastTaskUpdateRef.current) {
+      lastTaskUpdateRef.current = taskUpdateToken
+      return
+    }
+
+    if (lastTaskUpdateRef.current === taskUpdateToken) {
+      return
+    }
+
+    lastTaskUpdateRef.current = taskUpdateToken
+
+    if (!activeStream && !liveState?.activeTurn) {
+      void refreshChat(false)
+    }
+  }, [activeStream, liveState?.activeTurn, refreshChat, task.updatedAt])
+
+  useEffect(() => {
+    const streamUrl = activeStream?.streamUrl
+    if (!streamUrl) {
+      eventSourceRef.current?.close()
+      eventSourceRef.current = null
+      return
+    }
+
+    const source = new EventSource(streamUrl)
+    eventSourceRef.current = source
+
+    source.onopen = () => {
+      clearReconnectTimer()
+      reconnectAttemptRef.current = 0
+    }
+
+    source.addEventListener('state', (event) => {
+      const nextState = JSON.parse(event.data) as CodexGatewayState
+      const nextStreamingMessage = buildStreamingAgentMessageFromState(taskId, nextState)
+
+      startTransition(() => {
+        setLiveState(nextState)
+
+        if (nextStreamingMessage) {
+          setRetainedStreamingMessage((previousMessage) => {
+            if (!previousMessage) {
+              return nextStreamingMessage
+            }
+
+            return previousMessage.content.length >= nextStreamingMessage.content.length
+              ? previousMessage
+              : nextStreamingMessage
+          })
+        }
+      })
+
+      if (!nextState.activeTurn && nextState.lastTurnStatus) {
+        clearReconnectTimer()
+        reconnectAttemptRef.current = 0
+        setActiveStream(null)
+        source.close()
+
+        if (eventSourceRef.current === source) {
+          eventSourceRef.current = null
+        }
+
+        void refreshChat(false)
+      }
+    })
+
+    source.addEventListener('session-closed', () => {
+      clearReconnectTimer()
+      reconnectAttemptRef.current = 0
+      setActiveStream(null)
+      source.close()
+
+      if (eventSourceRef.current === source) {
+        eventSourceRef.current = null
+      }
+
+      void refreshChat(false)
+    })
+
+    source.onerror = () => {
+      if (eventSourceRef.current !== source) {
+        return
+      }
+
+      clearReconnectTimer()
+      source.close()
+
+      if (eventSourceRef.current === source) {
+        eventSourceRef.current = null
+      }
+
+      const nextAttempt = reconnectAttemptRef.current + 1
+      reconnectAttemptRef.current = nextAttempt
+      const reconnectDelayMs = Math.min(1000 * nextAttempt, 5000)
+
+      reconnectTimeoutRef.current = window.setTimeout(() => {
+        reconnectTimeoutRef.current = null
+        void refreshChat(false)
+      }, reconnectDelayMs)
+    }
+
+    return () => {
+      clearReconnectTimer()
+      source.close()
+
+      if (eventSourceRef.current === source) {
+        eventSourceRef.current = null
+      }
+    }
+  }, [activeStream, clearReconnectTimer, refreshChat, taskId])
+
+  const sendMessage = useCallback(
+    async (content: string): Promise<ChatActionResult> => {
+      const trimmedContent = content.trim()
+      if (!trimmedContent || isSending) {
+        return {
+          success: false,
+          error: 'Message is required',
+        }
+      }
+
+      const optimisticMessage = createOptimisticUserMessage(taskId, trimmedContent)
+      setPendingMessages((previousMessages) => [...previousMessages, optimisticMessage])
+      setRetainedStreamingMessage(null)
+      setLiveState(null)
+      setIsSending(true)
+
+      try {
+        const response = await fetch(`/api/tasks/${taskId}/chat/v2`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            prompt: trimmedContent,
+          }),
+        })
+
+        const data = (await response.json()) as ChatV2TurnResponse
+        if (!response.ok || !data.success || !data.data) {
+          setPendingMessages((previousMessages) =>
+            previousMessages.filter((message) => message.id !== optimisticMessage.id),
+          )
+
+          return {
+            success: false,
+            error: data.error || 'Failed to send message',
+          }
+        }
+
+        startTransition(() => {
+          clearReconnectTimer()
+          reconnectAttemptRef.current = 0
+          setActiveStream(data.data!.stream)
+        })
+
+        void refreshChat(false)
+
+        return {
+          success: true,
+        }
+      } catch {
+        setPendingMessages((previousMessages) =>
+          previousMessages.filter((message) => message.id !== optimisticMessage.id),
+        )
+        return {
+          success: false,
+          error: 'Failed to send message',
+        }
+      } finally {
+        setIsSending(false)
+      }
+    },
+    [clearReconnectTimer, isSending, refreshChat, taskId],
+  )
+
+  const retryMessage = useCallback(
+    async (content: string): Promise<ChatActionResult> => {
+      return await sendMessage(content)
+    },
+    [sendMessage],
+  )
+
+  const stopTask = useCallback(async (): Promise<ChatActionResult> => {
+    if (!activeStream && !liveState?.activeTurn && !isTaskStreaming(task)) {
+      return {
+        success: false,
+        error: 'Task does not have an active turn',
+      }
+    }
+
+    setIsStopping(true)
+
+    try {
+      const response = await fetch(`/api/tasks/${taskId}/chat/interrupt`, {
+        method: 'POST',
+      })
+
+      const data = (await response.json()) as {
+        error?: string
+      }
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: data.error || 'Failed to stop generation',
+        }
+      }
+
+      return {
+        success: true,
+      }
+    } catch {
+      return {
+        success: false,
+        error: 'Failed to stop generation',
+      }
+    } finally {
+      setIsStopping(false)
+    }
+  }, [activeStream, liveState?.activeTurn, task, taskId])
+
+  const streamingMessage = useMemo(
+    () => buildStreamingAgentMessage(taskId, liveState, persistedMessages),
+    [liveState, persistedMessages, taskId],
+  )
+
+  const activeStreamingMessage = streamingMessage || retainedStreamingMessage
+
+  const messages = useMemo(
+    () => combineChatMessages(persistedMessages, pendingMessages, activeStreamingMessage),
+    [activeStreamingMessage, pendingMessages, persistedMessages],
+  )
+
+  const activityItems = useMemo(() => {
+    const persistedActivityItems = buildAgentActivityItemsFromTaskEvents(persistedEvents)
+    const liveActivityItems = buildAgentActivityItemsFromState(liveState)
+    const seen = new Set<string>()
+
+    return [...persistedActivityItems, ...liveActivityItems]
+      .toSorted((left, right) => left.occurredAt.localeCompare(right.occurredAt))
+      .filter((item) => {
+        const key = `${item.label}|${item.detail}|${item.occurredAt}`
+        if (seen.has(key)) {
+          return false
+        }
+
+        seen.add(key)
+        return true
+      })
+  }, [liveState, persistedEvents])
+
+  return {
+    activityItems: activityItems as TaskAgentActivityItem[],
+    error,
+    isGatewayTask: true,
+    isLoading,
+    isSending,
+    isStopping,
+    isStreaming: Boolean(activeStream || liveState?.activeTurn || isTaskStreaming(task)),
+    messages,
+    refreshMessages: refreshChat,
+    retryMessage,
+    sendMessage,
+    stopTask,
+  }
+}
diff --git a/lib/hooks/use-task.ts b/lib/hooks/use-task.ts
index 1e7a711..8672f17 100644
--- a/lib/hooks/use-task.ts
+++ b/lib/hooks/use-task.ts
@@ -33,8 +33,14 @@ export function useTask(taskId: string) {
   const attemptCountRef = useRef(0)
   const hasFoundTaskRef = useRef(false)
   const pendingSandboxRefetchRef = useRef(false)
+  const inFlightRef = useRef(false)
 
   const fetchTask = useCallback(async () => {
+    if (inFlightRef.current) {
+      return
+    }
+
+    inFlightRef.current = true
     let errorOccurred = false
     try {
       const response = await fetch(`/api/tasks/${taskId}`)
@@ -70,6 +76,7 @@ export function useTask(taskId: string) {
       setError('Failed to fetch task')
       errorOccurred = true
     } finally {
+      inFlightRef.current = false
       // Only stop loading after we've either found the task or exceeded attempt threshold
       if (hasFoundTaskRef.current || attemptCountRef.current >= 3 || errorOccurred) {
         setIsLoading(false)
diff --git a/lib/sealos-deploy-context.ts b/lib/sealos-deploy-context.ts
new file mode 100644
index 0000000..4fb678f
--- /dev/null
+++ b/lib/sealos-deploy-context.ts
@@ -0,0 +1,33 @@
+import { getDevboxNamespace } from '@/lib/devbox/config'
+import { getSealosRegion, getSealosRegionUrl, getSealosTemplateApiUrl } from '@/lib/sealos/config'
+
+const SEALOS_DEPLOY_CONTEXT_HEADING = '## Sealos Deploy Context'
+
+export function buildSealosDeployContextPrompt(namespace?: string | null): string {
+  const resolvedNamespace = namespace?.trim() || getDevboxNamespace()
+  const region = getSealosRegion()
+  const regionUrl = getSealosRegionUrl()
+
+  return `${SEALOS_DEPLOY_CONTEXT_HEADING}
+
+\`\`\`json
+${JSON.stringify(
+  {
+    region,
+    region_url: regionUrl,
+    namespace: resolvedNamespace,
+    template_api: getSealosTemplateApiUrl(),
+  },
+  null,
+  2,
+)}
+\`\`\``
+}
+
+export function prependSealosDeployContext(prompt: string, namespace?: string | null): string {
+  if (prompt.includes(SEALOS_DEPLOY_CONTEXT_HEADING)) {
+    return prompt
+  }
+
+  return `${buildSealosDeployContextPrompt(namespace)}\n\n${prompt}`
+}
diff --git a/lib/sealos/config.ts b/lib/sealos/config.ts
new file mode 100644
index 0000000..e63ea18
--- /dev/null
+++ b/lib/sealos/config.ts
@@ -0,0 +1,48 @@
+function normalizeUrl(url: string): string {
+  return url.trim().replace(/\/+$/, '')
+}
+
+function getHostFromUrl(url: string): string {
+  return normalizeUrl(url).replace(/^https?:\/\//, '')
+}
+
+function deriveRegionFromHost(host: string): string {
+  return host.replace(/\.sealos\.io$/, '')
+}
+
+function normalizeHost(host: string): string {
+  return getHostFromUrl(host)
+}
+
+function getRequiredEnv(name: 'SEALOS_HOST'): string {
+  const value = process.env[name]
+  if (!value?.trim()) {
+    throw new Error('Missing required environment variable: SEALOS_HOST')
+  }
+
+  return value
+}
+
+export function getSealosHost(): string {
+  return normalizeHost(getRequiredEnv('SEALOS_HOST'))
+}
+
+export function getSealosRegion(): string {
+  return deriveRegionFromHost(getSealosHost())
+}
+
+export function getSealosRegionHost(): string {
+  return getSealosHost()
+}
+
+export function getSealosRegionUrl(): string {
+  return `https://${getSealosHost()}`
+}
+
+export function getSealosTemplateApiUrl(): string {
+  return `https://template.${getSealosRegionHost()}/api/v2alpha/templates/raw`
+}
+
+export function getSealosDevboxBaseUrl(): string {
+  return `https://devbox-server.${getSealosRegionHost()}`
+}
diff --git a/lib/task-agent-events.ts b/lib/task-agent-events.ts
new file mode 100644
index 0000000..1620a96
--- /dev/null
+++ b/lib/task-agent-events.ts
@@ -0,0 +1,331 @@
+import type { CodexGatewayState, CodexGatewaySummaryEvent } from '@/lib/codex-gateway/types'
+import type { TaskEvent } from '@/lib/db/schema'
+
+export interface TaskAgentActivityItem {
+  detail: string
+  groupKey: string
+  id: string
+  label: string
+  occurredAt: string
+  tone: 'default' | 'error' | 'success' | 'warning'
+}
+
+interface ActivitySummaryInput {
+  itemType?: string | null
+  method?: string | null
+  status?: string | null
+  textPreview?: string | null
+}
+
+function getToneFromStatus(status: string | null | undefined): TaskAgentActivityItem['tone'] {
+  if (!status) {
+    return 'default'
+  }
+
+  if (status === 'completed' || status === 'succeeded' || status === 'approved') {
+    return 'success'
+  }
+
+  if (status === 'failed' || status === 'decline' || status === 'error') {
+    return 'error'
+  }
+
+  if (status === 'interruptRequested' || status === 'interrupted' || status === 'warning') {
+    return 'warning'
+  }
+
+  return 'default'
+}
+
+function normalizeDateValue(value: unknown): string | null {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString()
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    const parsedDate = new Date(value)
+    if (!Number.isNaN(parsedDate.getTime())) {
+      return parsedDate.toISOString()
+    }
+  }
+
+  return null
+}
+
+function getEventOccurredAt(value: unknown): string {
+  return normalizeDateValue(value) || new Date(0).toISOString()
+}
+
+function normalizeOccurredAt(value: unknown, fallbackDate: unknown): string {
+  return normalizeDateValue(value) || getEventOccurredAt(fallbackDate)
+}
+
+function normalizePreview(value: string | null | undefined): string {
+  return value?.replace(/\s+/g, ' ').trim() || ''
+}
+
+function humanizeIdentifier(value: string | null | undefined): string {
+  if (!value) {
+    return 'Activity'
+  }
+
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[/-]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/^\w/, (char) => char.toUpperCase())
+}
+
+function buildLifecycleItem(
+  action: 'started' | 'completed',
+  itemType: string | null | undefined,
+  textPreview: string | null | undefined,
+  status: string | null | undefined,
+): Omit<TaskAgentActivityItem, 'id' | 'occurredAt'> | null {
+  const preview = normalizePreview(textPreview)
+  const tone = action === 'completed' ? getToneFromStatus(status) : 'default'
+
+  if (itemType === 'agentMessage' || itemType === 'userMessage') {
+    return null
+  }
+
+  if (itemType === 'commandExecution') {
+    return {
+      groupKey: 'command',
+      label: action === 'completed' ? 'Command finished' : 'Running command',
+      detail: preview || (action === 'completed' ? 'Shell command finished' : 'Executing shell command'),
+      tone,
+    }
+  }
+
+  if (itemType === 'fileChange') {
+    return {
+      groupKey: 'files',
+      label: action === 'completed' ? 'Files updated' : 'Updating files',
+      detail: preview || (action === 'completed' ? 'Workspace changes are ready' : 'Preparing workspace changes'),
+      tone,
+    }
+  }
+
+  if (itemType === 'reasoning') {
+    return {
+      groupKey: 'reasoning',
+      label: action === 'completed' ? 'Analysis complete' : 'Analyzing task',
+      detail: preview || (action === 'completed' ? 'Planning finished' : 'Thinking through the next step'),
+      tone,
+    }
+  }
+
+  const readableType = humanizeIdentifier(itemType)
+
+  return {
+    groupKey: itemType || 'activity',
+    label: action === 'completed' ? `${readableType} finished` : `${readableType} in progress`,
+    detail: preview || (action === 'completed' ? 'Step completed' : 'Working on the next step'),
+    tone,
+  }
+}
+
+function buildSummaryItemCopy(input: ActivitySummaryInput): Omit<TaskAgentActivityItem, 'id' | 'occurredAt'> | null {
+  const preview = normalizePreview(input.textPreview)
+
+  switch (input.method) {
+    case 'thread/started':
+    case 'thread/status/changed':
+    case 'item/agentMessage/delta':
+      return null
+    case 'turn/started':
+      return {
+        groupKey: 'turn',
+        label: 'Preparing response',
+        detail: 'Agent is working on the next reply',
+        tone: 'default',
+      }
+    case 'turn/completed':
+      return {
+        groupKey: 'turn',
+        label: 'Response complete',
+        detail: 'Latest reply is ready',
+        tone: 'success',
+      }
+    case 'item/started':
+      return buildLifecycleItem('started', input.itemType, preview, input.status)
+    case 'item/completed':
+      return buildLifecycleItem('completed', input.itemType, preview, input.status)
+    case 'error':
+      return {
+        groupKey: 'error',
+        label: 'Error',
+        detail: preview || 'Something went wrong',
+        tone: 'error',
+      }
+  }
+
+  if (input.method?.includes('requestApproval')) {
+    const isCommandApproval = input.method.includes('commandExecution')
+
+    return {
+      groupKey: isCommandApproval ? 'approval-command' : 'approval-files',
+      label: isCommandApproval ? 'Command approved' : 'File changes approved',
+      detail: preview || (isCommandApproval ? 'Approval was handled automatically' : 'Changes were approved'),
+      tone: 'success',
+    }
+  }
+
+  if (input.itemType) {
+    return buildLifecycleItem('started', input.itemType, preview, input.status)
+  }
+
+  if (preview) {
+    return {
+      groupKey: input.method || 'activity',
+      label: humanizeIdentifier(input.method || 'activity'),
+      detail: preview,
+      tone: getToneFromStatus(input.status),
+    }
+  }
+
+  return null
+}
+
+function buildSummaryEventItem(summaryEvent: CodexGatewaySummaryEvent, index: number): TaskAgentActivityItem | null {
+  const copy = buildSummaryItemCopy(summaryEvent)
+
+  if (!copy) {
+    return null
+  }
+
+  const occurredAt =
+    typeof summaryEvent.at === 'string' && summaryEvent.at.trim() ? summaryEvent.at : new Date(0).toISOString()
+
+  return {
+    id: `summary-${occurredAt}-${summaryEvent.method || summaryEvent.type || index}-${summaryEvent.itemId || index}`,
+    occurredAt,
+    ...copy,
+  }
+}
+
+function buildTaskEventItem(event: TaskEvent): TaskAgentActivityItem | null {
+  if (event.kind === 'gateway.warning') {
+    return {
+      id: event.id,
+      groupKey: 'warning',
+      label: 'Warning',
+      detail: typeof event.payload?.message === 'string' ? event.payload.message : 'Gateway warning',
+      occurredAt: getEventOccurredAt(event.createdAt),
+      tone: 'warning',
+    }
+  }
+
+  if (event.kind === 'gateway.session.opened') {
+    return {
+      id: event.id,
+      groupKey: 'session',
+      label: 'Session ready',
+      detail: 'Gateway session ready',
+      occurredAt: getEventOccurredAt(event.createdAt),
+      tone: 'success',
+    }
+  }
+
+  if (event.kind === 'gateway.session.closed') {
+    return {
+      id: event.id,
+      groupKey: 'session',
+      label: 'Session ended',
+      detail: typeof event.payload?.reason === 'string' ? event.payload.reason : 'Gateway session closed',
+      occurredAt: getEventOccurredAt(event.createdAt),
+      tone: 'warning',
+    }
+  }
+
+  if (event.kind === 'turn.interrupted') {
+    return {
+      id: event.id,
+      groupKey: 'turn',
+      label: 'Generation stopped',
+      detail: 'Stopped generation',
+      occurredAt: getEventOccurredAt(event.createdAt),
+      tone: 'warning',
+    }
+  }
+
+  if (event.kind === 'turn.failed') {
+    return {
+      id: event.id,
+      groupKey: 'turn',
+      label: 'Response failed',
+      detail: typeof event.payload?.error === 'string' ? event.payload.error : 'Turn failed',
+      occurredAt: getEventOccurredAt(event.createdAt),
+      tone: 'error',
+    }
+  }
+
+  return null
+}
+
+export function buildAgentActivityItemsFromTaskEvents(events: TaskEvent[]): TaskAgentActivityItem[] {
+  const items: TaskAgentActivityItem[] = []
+
+  for (const event of events) {
+    if (event.kind === 'gateway.state.snapshot') {
+      const recentEvents = Array.isArray(event.payload?.recentEvents) ? event.payload.recentEvents : []
+
+      for (const [index, summaryEvent] of recentEvents.entries()) {
+        if (!summaryEvent || typeof summaryEvent !== 'object') {
+          continue
+        }
+
+        const item = buildSummaryEventItem(
+          {
+            at: normalizeOccurredAt(summaryEvent.at, event.createdAt),
+            type: typeof summaryEvent.type === 'string' ? summaryEvent.type : 'event',
+            method: typeof summaryEvent.method === 'string' ? summaryEvent.method : null,
+            itemType: typeof summaryEvent.itemType === 'string' ? summaryEvent.itemType : null,
+            itemId: typeof summaryEvent.itemId === 'string' ? summaryEvent.itemId : null,
+            status: typeof summaryEvent.status === 'string' ? summaryEvent.status : null,
+            textPreview: typeof summaryEvent.textPreview === 'string' ? summaryEvent.textPreview : null,
+          },
+          index,
+        )
+
+        if (item) {
+          items.push(item)
+        }
+      }
+
+      continue
+    }
+
+    const item = buildTaskEventItem(event)
+    if (item) {
+      items.push(item)
+    }
+  }
+
+  const seenIds = new Set<string>()
+
+  return items
+    .toSorted((left, right) => left.occurredAt.localeCompare(right.occurredAt))
+    .filter((item) => {
+      const key = `${item.label}|${item.detail}|${item.occurredAt}`
+      if (seenIds.has(key)) {
+        return false
+      }
+
+      seenIds.add(key)
+      return true
+    })
+}
+
+export function buildAgentActivityItemsFromState(state: CodexGatewayState | null): TaskAgentActivityItem[] {
+  if (!state?.recentEvents?.length) {
+    return []
+  }
+
+  return state.recentEvents.flatMap((summaryEvent, index) => {
+    const item = buildSummaryEventItem(summaryEvent, index)
+    return item ? [item] : []
+  })
+}
diff --git a/lib/task-chat-v2.ts b/lib/task-chat-v2.ts
new file mode 100644
index 0000000..9f34d58
--- /dev/null
+++ b/lib/task-chat-v2.ts
@@ -0,0 +1,84 @@
+import type { TaskStream } from '@/lib/db/schema'
+import { closeTaskStream, createTaskStream, getActiveTaskStream } from '@/lib/task-events'
+
+export interface TaskChatV2StreamDescriptor {
+  sessionId: string
+  streamId: string
+  streamUrl: string
+  threadId: string | null
+  turnId: string | null
+}
+
+export function buildTaskChatV2StreamUrl(taskId: string, streamId: string): string {
+  return `/api/tasks/${taskId}/chat/v2/stream?streamId=${encodeURIComponent(streamId)}`
+}
+
+export function buildTaskChatV2StreamDescriptor(
+  taskId: string,
+  stream: Pick<TaskStream, 'id' | 'sessionId' | 'threadId' | 'turnId'>,
+): TaskChatV2StreamDescriptor {
+  return {
+    streamId: stream.id,
+    streamUrl: buildTaskChatV2StreamUrl(taskId, stream.id),
+    sessionId: stream.sessionId,
+    threadId: stream.threadId || null,
+    turnId: stream.turnId || null,
+  }
+}
+
+export async function createTaskChatV2StreamDescriptor(input: {
+  sessionId: string
+  startedAt?: Date
+  taskId: string
+  threadId?: string | null
+  turnId?: string | null
+}): Promise<TaskChatV2StreamDescriptor> {
+  const stream = await createTaskStream({
+    taskId: input.taskId,
+    sessionId: input.sessionId,
+    startedAt: input.startedAt,
+    threadId: input.threadId,
+    turnId: input.turnId,
+  })
+
+  return buildTaskChatV2StreamDescriptor(input.taskId, stream)
+}
+
+export async function getActiveTaskChatV2StreamDescriptor(taskId: string): Promise<TaskChatV2StreamDescriptor | null> {
+  const stream = await getActiveTaskStream(taskId)
+
+  if (!stream) {
+    return null
+  }
+
+  return buildTaskChatV2StreamDescriptor(taskId, stream)
+}
+
+export async function ensureTaskChatV2StreamDescriptor(input: {
+  sessionId: string
+  startedAt?: Date
+  taskId: string
+  threadId?: string | null
+  turnId?: string | null
+}): Promise<TaskChatV2StreamDescriptor> {
+  const activeStream = await getActiveTaskStream(input.taskId)
+
+  if (activeStream && activeStream.sessionId === input.sessionId) {
+    return buildTaskChatV2StreamDescriptor(input.taskId, activeStream)
+  }
+
+  return await createTaskChatV2StreamDescriptor(input)
+}
+
+export async function closeTaskChatV2StreamDescriptor(
+  taskId: string,
+  status: 'closed' | 'errored' = 'closed',
+): Promise<void> {
+  const activeStream = await getActiveTaskStream(taskId)
+
+  if (!activeStream) {
+    return
+  }
+
+  await closeTaskStream(activeStream.id, status)
+}
diff --git a/lib/task-event-projection.ts b/lib/task-event-projection.ts
new file mode 100644
index 0000000..3f798a5
--- /dev/null
+++ b/lib/task-event-projection.ts
@@ -0,0 +1,182 @@
+import { and, asc, desc, eq, inArray } from 'drizzle-orm'
+import { getAssistantContentAfterCursor } from '@/lib/codex-gateway/transcript'
+import { db } from '@/lib/db/client'
+import { taskEvents, taskMessages, type TaskEvent } from '@/lib/db/schema'
+import { generateId } from '@/lib/utils/id'
+
+const PROJECTABLE_EVENT_KINDS = [
+  'user_message.created',
+  'assistant.message.projected',
+  'gateway.state.snapshot',
+] as const
+
+function parseTranscriptCursor(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value
+  }
+
+  if (typeof value === 'string') {
+    const parsed = Number.parseInt(value, 10)
+    return Number.isFinite(parsed) ? parsed : null
+  }
+
+  return null
+}
+
+function extractProjectedAssistantSnapshot(event: TaskEvent): {
+  content: string
+  messageId?: string
+} | null {
+  const payload = event.payload || null
+  const sessionId = typeof payload?.sessionId === 'string' ? payload.sessionId : event.sessionId || undefined
+  const transcriptCursor = parseTranscriptCursor(payload?.transcriptCursor)
+
+  if (!sessionId || transcriptCursor === null) {
+    return null
+  }
+
+  const transcriptValue = payload?.transcript
+  if (!Array.isArray(transcriptValue)) {
+    return null
+  }
+
+  const transcript = transcriptValue.flatMap((entry) => {
+    if (!entry || typeof entry !== 'object' || typeof entry.role !== 'string' || typeof entry.text !== 'string') {
+      return []
+    }
+
+    return [{ role: entry.role, text: entry.text }]
+  })
+
+  const content = getAssistantContentAfterCursor(transcriptCursor, transcript)
+  if (!content) {
+    return null
+  }
+
+  return {
+    content,
+    messageId: buildProjectedAssistantMessageId(sessionId, transcriptCursor),
+  }
+}
+
+export function buildTaskEventUserMessageId(eventId: string): string {
+  return `task-user-event-${eventId}`
+}
+
+export function buildProjectedAssistantMessageId(sessionId: string, transcriptCursor: number): string {
+  return `codex-agent-${sessionId}-${transcriptCursor}`
+}
+
+export async function projectUserMessageFromEvent(
+  event: Pick<TaskEvent, 'id' | 'taskId' | 'payload' | 'createdAt'>,
+): Promise<void> {
+  const content = typeof event.payload?.content === 'string' ? event.payload.content.trim() : ''
+
+  if (!content) {
+    return
+  }
+
+  await db
+    .insert(taskMessages)
+    .values({
+      id: buildTaskEventUserMessageId(event.id),
+      taskId: event.taskId,
+      role: 'user',
+      content,
+      createdAt: event.createdAt,
+    })
+    .onConflictDoNothing()
+}
+
+export async function projectAssistantMessage(input: {
+  content: string
+  createdAt?: Date
+  messageId?: string
+  taskId: string
+}): Promise<void> {
+  const trimmedContent = input.content.trim()
+
+  if (!trimmedContent) {
+    return
+  }
+
+  if (input.messageId) {
+    await db
+      .insert(taskMessages)
+      .values({
+        id: input.messageId,
+        taskId: input.taskId,
+        role: 'agent',
+        content: trimmedContent,
+        createdAt: input.createdAt,
+      })
+      .onConflictDoUpdate({
+        target: taskMessages.id,
+        set: {
+          content: trimmedContent,
+        },
+      })
+
+    return
+  }
+
+  const [latestPersistedAgentMessage] = await db
+    .select({ content: taskMessages.content })
+    .from(taskMessages)
+    .where(and(eq(taskMessages.taskId, input.taskId), eq(taskMessages.role, 'agent')))
+    .orderBy(desc(taskMessages.createdAt))
+    .limit(1)
+
+  if (latestPersistedAgentMessage?.content.trim() === trimmedContent) {
+    return
+  }
+
+  await db.insert(taskMessages).values({
+    id: generateId(12),
+    taskId: input.taskId,
+    role: 'agent',
+    content: trimmedContent,
+    createdAt: input.createdAt,
+  })
+}
+
+export async function reconcileProjectedTaskMessages(taskId: string): Promise<void> {
+  const events = await db
+    .select()
+    .from(taskEvents)
+    .where(and(eq(taskEvents.taskId, taskId), inArray(taskEvents.kind, [...PROJECTABLE_EVENT_KINDS])))
+    .orderBy(asc(taskEvents.seq))
+
+  for (const event of events) {
+    if (event.kind === 'user_message.created') {
+      await projectUserMessageFromEvent(event)
+      continue
+    }
+
+    const projectedSnapshot =
+      event.kind === 'gateway.state.snapshot'
+        ? extractProjectedAssistantSnapshot(event)
+        : {
+            content: typeof event.payload?.content === 'string' ? event.payload.content.trim() : '',
+            messageId:
+              (typeof event.payload?.sessionId === 'string' ? event.payload.sessionId : event.sessionId) &&
+              parseTranscriptCursor(event.payload?.transcriptCursor) !== null
+                ? buildProjectedAssistantMessageId(
+                    (typeof event.payload?.sessionId === 'string' ? event.payload.sessionId : event.sessionId)!,
+                    parseTranscriptCursor(event.payload?.transcriptCursor)!,
+                  )
+                : undefined,
+          }
+
+    if (!projectedSnapshot?.content.trim()) {
+      continue
+    }
+
+    await projectAssistantMessage({
+      taskId,
+      content: projectedSnapshot.content,
+      messageId: projectedSnapshot.messageId,
+      createdAt: event.createdAt,
+    })
+  }
+}
diff --git a/lib/task-events.ts b/lib/task-events.ts
new file mode 100644
index 0000000..0b32e88
--- /dev/null
+++ b/lib/task-events.ts
@@ -0,0 +1,219 @@
+import { and, desc, eq, sql } from 'drizzle-orm'
+import { db } from '@/lib/db/client'
+import {
+  taskEvents,
+  taskStreams,
+  type TaskEvent,
+  type TaskEventKind,
+  type TaskStream,
+  type TaskStreamStatus,
+} from '@/lib/db/schema'
+import {
+  buildProjectedAssistantMessageId,
+  projectAssistantMessage,
+  projectUserMessageFromEvent,
+} from '@/lib/task-event-projection'
+import { generateId } from '@/lib/utils/id'
+
+interface RecordTaskEventInput {
+  createdAt?: Date
+  kind: TaskEventKind
+  payload?: Record<string, unknown> | null
+  sessionId?: string | null
+  streamId?: string | null
+  taskId: string
+  threadId?: string | null
+  turnId?: string | null
+}
+
+interface CreateTaskStreamInput {
+  id?: string
+  sessionId: string
+  startedAt?: Date
+  taskId: string
+  threadId?: string | null
+  turnId?: string | null
+}
+
+export async function recordTaskEvent(input: RecordTaskEventInput): Promise<TaskEvent> {
+  return await db.transaction(async (tx) => {
+    await tx.execute(sql`select pg_advisory_xact_lock(hashtext(${input.taskId}))`)
+
+    const [latestEvent] = await tx
+      .select({ seq: taskEvents.seq })
+      .from(taskEvents)
+      .where(eq(taskEvents.taskId, input.taskId))
+      .orderBy(desc(taskEvents.seq))
+      .limit(1)
+
+    const eventValues = {
+      id: generateId(16),
+      taskId: input.taskId,
+      seq: (latestEvent?.seq ?? 0) + 1,
+      kind: input.kind,
+      streamId: input.streamId ?? undefined,
+      sessionId: input.sessionId ?? undefined,
+      threadId: input.threadId ?? undefined,
+      turnId: input.turnId ?? undefined,
+      payload: input.payload ?? null,
+      createdAt: input.createdAt,
+    }
+
+    const [createdEvent] = await tx.insert(taskEvents).values(eventValues).returning()
+
+    return createdEvent
+  })
+}
+
+export async function appendUserMessageEvent(input: {
+  content: string
+  createdAt?: Date
+  source: string
+  taskId: string
+}): Promise<TaskEvent> {
+  const event = await recordTaskEvent({
+    taskId: input.taskId,
+    kind: 'user_message.created',
+    createdAt: input.createdAt,
+    payload: {
+      content: input.content,
+      source: input.source,
+    },
+  })
+
+  await projectUserMessageFromEvent(event)
+
+  return event
+}
+
+export async function appendProjectedAssistantMessageEvent(input: {
+  content: string
+  createdAt?: Date
+  sessionId: string
+  taskId: string
+  transcriptCursor: number
+}): Promise<TaskEvent | null> {
+  const trimmedContent = input.content.trim()
+
+  if (!trimmedContent) {
+    return null
+  }
+
+  const event = await recordTaskEvent({
+    taskId: input.taskId,
+    kind: 'assistant.message.projected',
+    createdAt: input.createdAt,
+    sessionId: input.sessionId,
+    payload: {
+      content: trimmedContent,
+      sessionId: input.sessionId,
+      transcriptCursor: input.transcriptCursor,
+    },
+  })
+
+  await projectAssistantMessage({
+    taskId: input.taskId,
+    content: trimmedContent,
+    createdAt: input.createdAt,
+    messageId: buildProjectedAssistantMessageId(input.sessionId, input.transcriptCursor),
+  })
+
+  return event
+}
+
+export async function listTaskEvents(taskId: string, options?: { limit?: number }): Promise<TaskEvent[]> {
+  const limit = Math.max(1, Math.min(options?.limit ?? 200, 1000))
+
+  const events = await db
+    .select()
+    .from(taskEvents)
+    .where(eq(taskEvents.taskId, taskId))
+    .orderBy(desc(taskEvents.seq))
+    .limit(limit)
+
+  return events.toReversed()
+}
+
+export async function createTaskStream(input: CreateTaskStreamInput): Promise<TaskStream> {
+  const createdAt = input.startedAt ?? new Date()
+
+  await db
+    .update(taskStreams)
+    .set({
+      status: 'closed',
+      lastEventAt: createdAt,
+      endedAt: createdAt,
+    })
+    .where(and(eq(taskStreams.taskId, input.taskId), eq(taskStreams.status, 'active')))
+
+  const streamValues = {
+    id: input.id ?? generateId(16),
+    taskId: input.taskId,
+    sessionId: input.sessionId,
+    threadId: input.threadId ?? undefined,
+    turnId: input.turnId ?? undefined,
+    status: 'active' as const,
+    startedAt: createdAt,
+    lastEventAt: createdAt,
+  }
+
+  const [createdStream] = await db.insert(taskStreams).values(streamValues).returning()
+  return createdStream
+}
+
+export async function getTaskStream(streamId: string): Promise<TaskStream | null> {
+  const [stream] = await db.select().from(taskStreams).where(eq(taskStreams.id, streamId)).limit(1)
+  return stream || null
+}
+
+export async function getActiveTaskStream(taskId: string): Promise<TaskStream | null> {
+  const [stream] = await db
+    .select()
+    .from(taskStreams)
+    .where(and(eq(taskStreams.taskId, taskId), eq(taskStreams.status, 'active')))
+    .orderBy(desc(taskStreams.startedAt))
+    .limit(1)
+
+  return stream || null
+}
+
+export async function touchTaskStream(
+  streamId: string,
+  input?: {
+    sessionId?: string | null
+    status?: TaskStreamStatus
+    threadId?: string | null
+    turnId?: string | null
+  },
+): Promise<TaskStream | null> {
+  const [updatedStream] = await db
+    .update(taskStreams)
+    .set({
+      lastEventAt: new Date(),
+      ...(typeof input?.sessionId === 'string' ? { sessionId: input.sessionId } : {}),
+      ...(input?.threadId !== undefined ? { threadId: input.threadId } : {}),
+      ...(input?.turnId !== undefined ? { turnId: input.turnId } : {}),
+      ...(input?.status !== undefined ? { status: input.status } : {}),
+    })
+    .where(eq(taskStreams.id, streamId))
+    .returning()
+
+  return updatedStream || null
+}
+
+export async function closeTaskStream(
+  streamId: string,
+  status: Extract<TaskStreamStatus, 'closed' | 'errored'> = 'closed',
+): Promise<TaskStream | null> {
+  const [updatedStream] = await db
+    .update(taskStreams)
+    .set({
+      status,
+      lastEventAt: new Date(),
+      endedAt: new Date(),
+    })
+    .where(eq(taskStreams.id, streamId))
+    .returning()
+
+  return updatedStream || null
+}
diff --git a/lib/utils/async.ts b/lib/utils/async.ts
new file mode 100644
index 0000000..c7067ca
--- /dev/null
+++ b/lib/utils/async.ts
@@ -0,0 +1,25 @@
+export class OperationTimeoutError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'OperationTimeoutError'
+  }
+}
+
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message: string): Promise<T> {
+  let timeoutHandle: ReturnType<typeof setTimeout> | null = null
+
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<T>((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+          reject(new OperationTimeoutError(message))
+        }, timeoutMs)
+      }),
+    ])
+  } finally {
+    if (timeoutHandle) {
+      clearTimeout(timeoutHandle)
+    }
+  }
+}
diff --git a/package.json b/package.json
index 4e0561e..0532acd 100644
--- a/package.json
+++ b/package.json
@@ -58,6 +58,7 @@
     "postgres": "^3.4.8",
     "react": "19.2.1",
     "react-dom": "19.2.1",
+    "shiki": "^3.21.0",
     "sonner": "^2.0.7",
     "streamdown": "^1.6.11",
     "tailwind-merge": "^3.4.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index e4573a8..ff8ef4e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -131,6 +131,9 @@ importers:
       react-dom:
         specifier: 19.2.1
         version: 19.2.1(react@19.2.1)
+      shiki:
+        specifier: ^3.21.0
+        version: 3.21.0
       sonner:
         specifier: ^2.0.7
         version: 2.0.7(react-dom@19.2.1(react@19.2.1))(react@19.2.1)
diff --git a/tsconfig.json b/tsconfig.json
index b1356b2..ec44b27 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -30,6 +30,7 @@
   },
   "include": [
     "next-env.d.ts",
+    "**/*.d.ts",
     "**/*.ts",
     "**/*.tsx",
     ".next/types/**/*.ts",