security(auth): wire @require_permission(owner_check=True) on isolation routes

Apply the require_permission decorator to all 28 routes that take a
{thread_id} path parameter. Combined with the strict middleware
(previous commit), this gives the double-layer protection that
AUTH_TEST_PLAN test 7.5.9 documents:

  Layer 1 (AuthMiddleware): cookie + JWT validation, rejects junk
                            cookies and stamps request.state.user
  Layer 2 (@require_permission with owner_check=True): per-resource
                            ownership verification via
                            ThreadMetaStore.check_access — returns
                            404 if a different user owns the thread

The decorator's owner_check branch is rewritten to use the SQL
thread_meta_repo (the 2.0-rc persistence layer) instead of the
LangGraph store path that PR #1728 used (_store_get / get_store
in routers/threads.py). The inject_record convenience is dropped
— no caller in 2.0 needs the LangGraph blob, and the SQL repo has
a different shape.

Routes decorated (28 total):
- threads.py: delete, patch, get, get-state, post-state, post-history
- thread_runs.py: post-runs, post-runs-stream, post-runs-wait,
  list_runs, get_run, cancel_run, join_run, stream_existing_run,
  list_thread_messages, list_run_messages, list_run_events,
  thread_token_usage
- feedback.py: create, list, stats, delete
- uploads.py: upload (added Request param), list, delete
- artifacts.py: get_artifact
- suggestions.py: generate (renamed body parameter to avoid
  conflict with FastAPI Request)

Test fixes:
- test_suggestions_router.py: bypass the decorator via __wrapped__
  (the unit tests cover parsing logic, not auth — no point spinning
  up a thread_meta_repo just to test JSON unwrapping)
- test_auth_middleware.py 4 fake-cookie tests: already updated in
  the previous commit (745bf432)

Tests: 293 passed (auth + persistence + isolation + suggestions)
Lint: clean

.agent/skills/smoke-test/SKILL.md

@@ -1,181 +0,0 @@
----
-name: smoke-test
-description: End-to-end smoke test skill for DeerFlow. Guides through: 1) Pulling latest code, 2) Docker OR Local installation and deployment (user preference, default to Local if Docker network issues), 3) Service availability verification, 4) Health check, 5) Final test report. Use when the user says "run smoke test", "smoke test deployment", "verify installation", "test service availability", "end-to-end test", or similar.
----
-
-# DeerFlow Smoke Test Skill
-
-This skill guides the Agent through DeerFlow's full end-to-end smoke test workflow, including code updates, deployment (supporting both Docker and local installation modes), service availability verification, and health checks.
-
-## Deployment Mode Selection
-
-This skill supports two deployment modes:
-- **Local installation mode** (recommended, especially when network issues occur) - Run all services directly on the local machine
-- **Docker mode** - Run all services inside Docker containers
-
-**Selection strategy**:
-- If the user explicitly asks for Docker mode, use Docker
-- If network issues occur (such as slow image pulls), automatically switch to local mode
-- Default to local mode whenever possible
-
-## Structure
-
-```
-smoke-test/
-├── SKILL.md                          ← You are here - core workflow and logic
-├── scripts/
-│   ├── check_docker.sh               ← Check the Docker environment
-│   ├── check_local_env.sh            ← Check local environment dependencies
-│   ├── frontend_check.sh             ← Frontend page smoke check
-│   ├── pull_code.sh                  ← Pull the latest code
-│   ├── deploy_docker.sh              ← Docker deployment
-│   ├── deploy_local.sh               ← Local deployment
-│   └── health_check.sh               ← Service health check
-├── references/
-│   ├── SOP.md                        ← Standard operating procedure
-│   └── troubleshooting.md            ← Troubleshooting guide
-└── templates/
-    ├── report.local.template.md      ← Local mode smoke test report template
-    └── report.docker.template.md     ← Docker mode smoke test report template
-```
-
-## Standard Operating Procedure (SOP)
-
-### Phase 1: Code Update Check
-
-1. **Confirm current directory** - Verify that the current working directory is the DeerFlow project root
-2. **Check Git status** - See whether there are uncommitted changes
-3. **Pull the latest code** - Use `git pull origin main` to get the latest updates
-4. **Confirm code update** - Verify that the latest code was pulled successfully
-
-### Phase 2: Deployment Mode Selection and Environment Check
-
-**Choose deployment mode**:
-- Ask for user preference, or choose automatically based on network conditions
-- Default to local installation mode
-
-**Local mode environment check**:
-1. **Check Node.js version** - Requires 22+
-2. **Check pnpm** - Package manager
-3. **Check uv** - Python package manager
-4. **Check nginx** - Reverse proxy
-5. **Check required ports** - Confirm that ports 2026, 3000, 8001, and 2024 are not occupied
-
-**Docker mode environment check** (if Docker is selected):
-1. **Check whether Docker is installed** - Run `docker --version`
-2. **Check Docker daemon status** - Run `docker info`
-3. **Check Docker Compose availability** - Run `docker compose version`
-4. **Check required ports** - Confirm that port 2026 is not occupied
-
-### Phase 3: Configuration Preparation
-
-1. **Check whether config.yaml exists**
-   - If it does not exist, run `make config` to generate it
-   - If it already exists, check whether it needs an upgrade with `make config-upgrade`
-2. **Check the .env file**
-   - Verify that required environment variables are configured
-   - Especially model API keys such as `OPENAI_API_KEY`
-
-### Phase 4: Deployment Execution
-
-**Local mode deployment**:
-1. **Check dependencies** - Run `make check`
-2. **Install dependencies** - Run `make install`
-3. **(Optional) Pre-pull the sandbox image** - If needed, run `make setup-sandbox`
-4. **Start services** - Run `make dev-daemon` (background mode, recommended) or `make dev` (foreground mode)
-5. **Wait for startup** - Give all services enough time to start completely (90-120 seconds recommended)
-
-**Docker mode deployment** (if Docker is selected):
-1. **Initialize Docker environment** - Run `make docker-init`
-2. **Start Docker services** - Run `make docker-start`
-3. **Wait for startup** - Give all containers enough time to start completely (60 seconds recommended)
-
-### Phase 5: Service Health Check
-
-**Local mode health check**:
-1. **Check process status** - Confirm that LangGraph, Gateway, Frontend, and Nginx processes are all running
-2. **Check frontend service** - Visit `http://localhost:2026` and verify that the page loads
-3. **Check API Gateway** - Verify the `http://localhost:2026/health` endpoint
-4. **Check LangGraph service** - Verify the availability of relevant endpoints
-5. **Frontend route smoke check** - Run `bash .agent/skills/smoke-test/scripts/frontend_check.sh` to verify key routes under `/workspace`
-
-**Docker mode health check** (when using Docker):
-1. **Check container status** - Run `docker ps` and confirm that all containers are running
-2. **Check frontend service** - Visit `http://localhost:2026` and verify that the page loads
-3. **Check API Gateway** - Verify the `http://localhost:2026/health` endpoint
-4. **Check LangGraph service** - Verify the availability of relevant endpoints
-5. **Frontend route smoke check** - Run `bash .agent/skills/smoke-test/scripts/frontend_check.sh` to verify key routes under `/workspace`
-
-### Optional Functional Verification
-
-1. **List available models** - Verify that model configuration loads correctly
-2. **List available skills** - Verify that the skill directory is mounted correctly
-3. **Simple chat test** - Send a simple message to verify the end-to-end flow
-
-### Phase 6: Generate Test Report
-
-1. **Collect all test results** - Summarize execution status for each phase
-2. **Record encountered issues** - If anything fails, record the error details
-3. **Generate the final report** - Use the template that matches the selected deployment mode to create the complete test report, including overall conclusion, detailed key test cases, and explicit frontend page / route results
-4. **Provide follow-up recommendations** - Offer suggestions based on the test results
-
-## Execution Rules
-
-- **Follow the sequence** - Execute strictly in the order described above
-- **Idempotency** - Every step should be safe to repeat
-- **Error handling** - If a step fails, stop and report the issue, then provide troubleshooting suggestions
-- **Detailed logging** - Record the execution result and status of each step
-- **User confirmation** - Ask for confirmation before potentially risky operations such as overwriting config
-- **Mode preference** - Prefer local mode to avoid network-related issues
-- **Template requirement** - The final report must use the matching template under `templates/`; do not output a free-form summary instead of the template-based report
-- **Report clarity** - The execution summary must include the overall pass/fail conclusion plus per-case result explanations, and frontend smoke check results must be listed explicitly in the report
-- **Optional phase handling** - If functional verification is not executed, do not present it as a separate skipped phase in the final report
-
-## Known Acceptable Warnings
-
-The following warnings can appear during smoke testing and do not block a successful result:
-- Feishu/Lark SSL errors in Gateway logs (certificate verification failure) can be ignored if that channel is not enabled
-- Warnings in LangGraph logs about missing methods in the custom checkpointer, such as `adelete_for_runs` or `aprune`, do not affect the core functionality
-
-## Key Tools
-
-Use the following tools during execution:
-
-1. **bash** - Run shell commands
-2. **present_file** - Show generated reports and important files
-3. **task_tool** - Organize complex steps with subtasks when needed
-
-## Success Criteria
-
-Smoke test pass criteria (local mode):
-- [x] Latest code is pulled successfully
-- [x] Local environment check passes (Node.js 22+, pnpm, uv, nginx)
-- [x] Configuration files are set up correctly
-- [x] `make check` passes
-- [x] `make install` completes successfully
-- [x] `make dev` starts successfully
-- [x] All service processes run normally
-- [x] Frontend page is accessible
-- [x] Frontend route smoke check passes (`/workspace` key routes)
-- [x] API Gateway health check passes
-- [x] Test report is generated completely
-
-Smoke test pass criteria (Docker mode):
-- [x] Latest code is pulled successfully
-- [x] Docker environment check passes
-- [x] Configuration files are set up correctly
-- [x] `make docker-init` completes successfully
-- [x] `make docker-start` completes successfully
-- [x] All Docker containers run normally
-- [x] Frontend page is accessible
-- [x] Frontend route smoke check passes (`/workspace` key routes)
-- [x] API Gateway health check passes
-- [x] Test report is generated completely
-
-## Read Reference Files
-
-Before starting execution, read the following reference files:
-1. `references/SOP.md` - Detailed step-by-step operating instructions
-2. `references/troubleshooting.md` - Common issues and solutions
-3. `templates/report.local.template.md` - Local mode test report template
-4. `templates/report.docker.template.md` - Docker mode test report template

.agent/skills/smoke-test/references/SOP.md

@@ -1,452 +0,0 @@
-# DeerFlow Smoke Test Standard Operating Procedure (SOP)
-
-This document describes the detailed operating steps for each phase of the DeerFlow smoke test.
-
-## Phase 1: Code Update Check
-
-### 1.1 Confirm Current Directory
-
-**Objective**: Verify that the current working directory is the DeerFlow project root.
-
-**Steps**:
-1. Run `pwd` to view the current working directory
-2. Check whether the directory contains the following files/directories:
-   - `Makefile`
-   - `backend/`
-   - `frontend/`
-   - `config.example.yaml`
-
-**Success Criteria**: The current directory contains all of the files/directories listed above.
-
----
-
-### 1.2 Check Git Status
-
-**Objective**: Check whether there are uncommitted changes.
-
-**Steps**:
-1. Run `git status`
-2. Check whether the output includes "Changes not staged for commit" or "Untracked files"
-
-**Notes**:
-- If there are uncommitted changes, recommend that the user commit or stash them first to avoid conflicts while pulling
-- If the user confirms that they want to continue, this step can be skipped
-
----
-
-### 1.3 Pull the Latest Code
-
-**Objective**: Fetch the latest code updates.
-
-**Steps**:
-1. Run `git fetch origin main`
-2. Run `git pull origin main`
-
-**Success Criteria**:
-- The commands succeed without errors
-- The output shows "Already up to date" or indicates that new commits were pulled successfully
-
----
-
-### 1.4 Confirm Code Update
-
-**Objective**: Verify that the latest code was pulled successfully.
-
-**Steps**:
-1. Run `git log -1 --oneline` to view the latest commit
-2. Record the commit hash and message
-
----
-
-## Phase 2: Deployment Mode Selection and Environment Check
-
-### 2.1 Choose Deployment Mode
-
-**Objective**: Decide whether to use local mode or Docker mode.
-
-**Decision Flow**:
-1. Prefer local mode first to avoid network-related issues
-2. If the user explicitly requests Docker, use Docker
-3. If Docker network issues occur, switch to local mode automatically
-
----
-
-### 2.2 Local Mode Environment Check
-
-**Objective**: Verify that local development environment dependencies are satisfied.
-
-#### 2.2.1 Check Node.js Version
-
-**Steps**:
-1. If nvm is used, run `nvm use 22` to switch to Node 22+
-2. Run `node --version`
-
-**Success Criteria**: Version >= 22.x
-
-**Failure Handling**:
-- If the version is too low, ask the user to install/switch Node.js with nvm:
-  ```bash
-  nvm install 22
-  nvm use 22
-  ```
-- Or install it from the official website: https://nodejs.org/
-
----
-
-#### 2.2.2 Check pnpm
-
-**Steps**:
-1. Run `pnpm --version`
-
-**Success Criteria**: The command returns pnpm version information.
-
-**Failure Handling**:
-- If pnpm is not installed, ask the user to install it with `npm install -g pnpm`
-
----
-
-#### 2.2.3 Check uv
-
-**Steps**:
-1. Run `uv --version`
-
-**Success Criteria**: The command returns uv version information.
-
-**Failure Handling**:
-- If uv is not installed, ask the user to install uv
-
----
-
-#### 2.2.4 Check nginx
-
-**Steps**:
-1. Run `nginx -v`
-
-**Success Criteria**: The command returns nginx version information.
-
-**Failure Handling**:
-- macOS: install with Homebrew using `brew install nginx`
-- Linux: install using the system package manager
-
----
-
-#### 2.2.5 Check Required Ports
-
-**Steps**:
-1. Run the following commands to check ports:
-   ```bash
-   lsof -i :2026  # Main port
-   lsof -i :3000  # Frontend
-   lsof -i :8001  # Gateway
-   lsof -i :2024  # LangGraph
-   ```
-
-**Success Criteria**: All ports are free, or they are occupied only by DeerFlow-related processes.
-
-**Failure Handling**:
-- If a port is occupied, ask the user to stop the related process
-
----
-
-### 2.3 Docker Mode Environment Check (If Docker Is Selected)
-
-#### 2.3.1 Check Whether Docker Is Installed
-
-**Steps**:
-1. Run `docker --version`
-
-**Success Criteria**: The command returns Docker version information, such as "Docker version 24.x.x".
-
----
-
-#### 2.3.2 Check Docker Daemon Status
-
-**Steps**:
-1. Run `docker info`
-
-**Success Criteria**: The command runs successfully and shows Docker system information.
-
-**Failure Handling**:
-- If it fails, ask the user to start Docker Desktop or the Docker service
-
----
-
-#### 2.3.3 Check Docker Compose Availability
-
-**Steps**:
-1. Run `docker compose version`
-
-**Success Criteria**: The command returns Docker Compose version information.
-
----
-
-#### 2.3.4 Check Required Ports
-
-**Steps**:
-1. Run `lsof -i :2026` (macOS/Linux) or `netstat -ano | findstr :2026` (Windows)
-
-**Success Criteria**: Port 2026 is free, or it is occupied only by a DeerFlow-related process.
-
-**Failure Handling**:
-- If the port is occupied by another process, ask the user to stop that process or change the configuration
-
----
-
-## Phase 3: Configuration Preparation
-
-### 3.1 Check config.yaml
-
-**Steps**:
-1. Check whether `config.yaml` exists
-2. If it does not exist, run `make config`
-3. If it already exists, consider running `make config-upgrade` to merge new fields
-
-**Validation**:
-- Check whether at least one model is configured in config.yaml
-- Check whether the model configuration references the correct environment variables
-
----
-
-### 3.2 Check the .env File
-
-**Steps**:
-1. Check whether the `.env` file exists
-2. If it does not exist, copy it from `.env.example`
-3. Check whether the following environment variables are configured:
-   - `OPENAI_API_KEY` (or other model API keys)
-   - Other required settings
-
----
-
-## Phase 4: Deployment Execution
-
-### 4.1 Local Mode Deployment
-
-#### 4.1.1 Check Dependencies
-
-**Steps**:
-1. Run `make check`
-
-**Description**: This command validates all required tools (Node.js 22+, pnpm, uv, nginx).
-
----
-
-#### 4.1.2 Install Dependencies
-
-**Steps**:
-1. Run `make install`
-
-**Description**: This command installs both backend and frontend dependencies.
-
-**Notes**:
-- This step may take some time
-- If network issues cause failures, try using a closer or mirrored package registry
-
----
-
-#### 4.1.3 (Optional) Pre-pull the Sandbox Image
-
-**Steps**:
-1. If Docker / Container sandbox is used, run `make setup-sandbox`
-
-**Description**: This step is optional and not needed for local sandbox mode.
-
----
-
-#### 4.1.4 Start Services
-
-**Steps**:
-1. Run `make dev-daemon` (background mode)
-
-**Description**: This command starts all services (LangGraph, Gateway, Frontend, Nginx).
-
-**Notes**:
-- `make dev` runs in the foreground and stops with Ctrl+C
-- `make dev-daemon` runs in the background
-- Use `make stop` to stop services
-
----
-
-#### 4.1.5 Wait for Services to Start
-
-**Steps**:
-1. Wait 90-120 seconds for all services to start completely
-2. You can monitor startup progress by checking these log files:
-   - `logs/langgraph.log`
-   - `logs/gateway.log`
-   - `logs/frontend.log`
-   - `logs/nginx.log`
-
----
-
-### 4.2 Docker Mode Deployment (If Docker Is Selected)
-
-#### 4.2.1 Initialize the Docker Environment
-
-**Steps**:
-1. Run `make docker-init`
-
-**Description**: This command pulls the sandbox image if needed.
-
----
-
-#### 4.2.2 Start Docker Services
-
-**Steps**:
-1. Run `make docker-start`
-
-**Description**: This command builds and starts all required Docker containers.
-
----
-
-#### 4.2.3 Wait for Services to Start
-
-**Steps**:
-1. Wait 60-90 seconds for all services to start completely
-2. You can run `make docker-logs` to monitor startup progress
-
----
-
-## Phase 5: Service Health Check
-
-### 5.1 Local Mode Health Check
-
-#### 5.1.1 Check Process Status
-
-**Steps**:
-1. Run the following command to check processes:
-   ```bash
-   ps aux | grep -E "(langgraph|uvicorn|next|nginx)" | grep -v grep
-   ```
-
-**Success Criteria**: Confirm that the following processes are running:
-- LangGraph (`langgraph dev`)
-- Gateway (`uvicorn app.gateway.app:app`)
-- Frontend (`next dev` or `next start`)
-- Nginx (`nginx`)
-
----
-
-#### 5.1.2 Check Frontend Service
-
-**Steps**:
-1. Use curl or a browser to visit `http://localhost:2026`
-2. Verify that the page loads normally
-
-**Example curl command**:
-```bash
-curl -I http://localhost:2026
-```
-
-**Success Criteria**: Returns an HTTP 200 status code.
-
----
-
-#### 5.1.3 Check API Gateway
-
-**Steps**:
-1. Visit `http://localhost:2026/health`
-
-**Example curl command**:
-```bash
-curl http://localhost:2026/health
-```
-
-**Success Criteria**: Returns health status JSON.
-
----
-
-#### 5.1.4 Check LangGraph Service
-
-**Steps**:
-1. Visit relevant LangGraph endpoints to verify availability
-
----
-
-### 5.2 Docker Mode Health Check (When Using Docker)
-
-#### 5.2.1 Check Container Status
-
-**Steps**:
-1. Run `docker ps`
-2. Confirm that the following containers are running:
-   - `deer-flow-nginx`
-   - `deer-flow-frontend`
-   - `deer-flow-gateway`
-   - `deer-flow-langgraph` (if not in gateway mode)
-
----
-
-#### 5.2.2 Check Frontend Service
-
-**Steps**:
-1. Use curl or a browser to visit `http://localhost:2026`
-2. Verify that the page loads normally
-
-**Example curl command**:
-```bash
-curl -I http://localhost:2026
-```
-
-**Success Criteria**: Returns an HTTP 200 status code.
-
----
-
-#### 5.2.3 Check API Gateway
-
-**Steps**:
-1. Visit `http://localhost:2026/health`
-
-**Example curl command**:
-```bash
-curl http://localhost:2026/health
-```
-
-**Success Criteria**: Returns health status JSON.
-
----
-
-#### 5.2.4 Check LangGraph Service
-
-**Steps**:
-1. Visit relevant LangGraph endpoints to verify availability
-
----
-
-## Optional Functional Verification
-
-### 6.1 List Available Models
-
-**Steps**: Verify the model list through the API or UI.
-
----
-
-### 6.2 List Available Skills
-
-**Steps**: Verify the skill list through the API or UI.
-
----
-
-### 6.3 Simple Chat Test
-
-**Steps**: Send a simple message to test the complete workflow.
-
----
-
-## Phase 6: Generate the Test Report
-
-### 6.1 Collect Test Results
-
-Summarize the execution status of each phase and record successful and failed items.
-
-### 6.2 Record Issues
-
-If anything fails, record detailed error information.
-
-### 6.3 Generate the Report
-
-Use the template to create a complete test report.
-
-### 6.4 Provide Recommendations
-
-Provide follow-up recommendations based on the test results.

.agent/skills/smoke-test/references/troubleshooting.md

@@ -1,612 +0,0 @@
-# Troubleshooting Guide
-
-This document lists common issues encountered during DeerFlow smoke testing and how to resolve them.
-
-## Code Update Issues
-
-### Issue: `git pull` Fails with a Merge Conflict Warning
-
-**Symptoms**:
-```
-error: Your local changes to the following files would be overwritten by merge
-```
-
-**Solutions**:
-1. Option A: Commit local changes first
-   ```bash
-   git add .
-   git commit -m "Save local changes"
-   git pull origin main
-   ```
-
-2. Option B: Stash local changes
-   ```bash
-   git stash
-   git pull origin main
-   git stash pop  # Restore changes later if needed
-   ```
-
-3. Option C: Discard local changes (use with caution)
-   ```bash
-   git reset --hard HEAD
-   git pull origin main
-   ```
-
----
-
-## Local Mode Environment Issues
-
-### Issue: Node.js Version Is Too Old
-
-**Symptoms**:
-```
-Node.js version is too old. Requires 22+, got x.x.x
-```
-
-**Solutions**:
-1. Install or upgrade Node.js with nvm:
-   ```bash
-   nvm install 22
-   nvm use 22
-   ```
-
-2. Or download and install it from the official website: https://nodejs.org/
-
-3. Verify the version:
-   ```bash
-   node --version
-   ```
-
----
-
-### Issue: pnpm Is Not Installed
-
-**Symptoms**:
-```
-command not found: pnpm
-```
-
-**Solutions**:
-1. Install pnpm with npm:
-   ```bash
-   npm install -g pnpm
-   ```
-
-2. Or use the official installation script:
-   ```bash
-   curl -fsSL https://get.pnpm.io/install.sh | sh -
-   ```
-
-3. Verify the installation:
-   ```bash
-   pnpm --version
-   ```
-
----
-
-### Issue: uv Is Not Installed
-
-**Symptoms**:
-```
-command not found: uv
-```
-
-**Solutions**:
-1. Use the official installation script:
-   ```bash
-   curl -LsSf https://astral.sh/uv/install.sh | sh
-   ```
-
-2. macOS users can also install it with Homebrew:
-   ```bash
-   brew install uv
-   ```
-
-3. Verify the installation:
-   ```bash
-   uv --version
-   ```
-
----
-
-### Issue: nginx Is Not Installed
-
-**Symptoms**:
-```
-command not found: nginx
-```
-
-**Solutions**:
-1. macOS (Homebrew):
-   ```bash
-   brew install nginx
-   ```
-
-2. Ubuntu/Debian:
-   ```bash
-   sudo apt update
-   sudo apt install nginx
-   ```
-
-3. CentOS/RHEL:
-   ```bash
-   sudo yum install nginx
-   ```
-
-4. Verify the installation:
-   ```bash
-   nginx -v
-   ```
-
----
-
-### Issue: Port Is Already in Use
-
-**Symptoms**:
-```
-Error: listen EADDRINUSE: address already in use :::2026
-```
-
-**Solutions**:
-1. Find the process using the port:
-   ```bash
-   lsof -i :2026  # macOS/Linux
-   netstat -ano | findstr :2026  # Windows
-   ```
-
-2. Stop that process:
-   ```bash
-   kill -9 <PID>  # macOS/Linux
-   taskkill /PID <PID> /F  # Windows
-   ```
-
-3. Or stop DeerFlow services first:
-   ```bash
-   make stop
-   ```
-
----
-
-## Local Mode Dependency Installation Issues
-
-### Issue: `make install` Fails Due to Network Timeout
-
-**Symptoms**:
-Network timeouts or connection failures occur during dependency installation.
-
-**Solutions**:
-1. Configure pnpm to use a mirror registry:
-   ```bash
-   pnpm config set registry https://registry.npmmirror.com
-   ```
-
-2. Configure uv to use a mirror registry:
-   ```bash
-   uv pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
-   ```
-
-3. Retry the installation:
-   ```bash
-   make install
-   ```
-
----
-
-### Issue: Python Dependency Installation Fails
-
-**Symptoms**:
-Errors occur during `uv sync`.
-
-**Solutions**:
-1. Clean the uv cache:
-   ```bash
-   cd backend
-   uv cache clean
-   ```
-
-2. Resync dependencies:
-   ```bash
-   cd backend
-   uv sync
-   ```
-
-3. View detailed error logs:
-   ```bash
-   cd backend
-   uv sync --verbose
-   ```
-
----
-
-### Issue: Frontend Dependency Installation Fails
-
-**Symptoms**:
-Errors occur during `pnpm install`.
-
-**Solutions**:
-1. Clean the pnpm cache:
-   ```bash
-   cd frontend
-   pnpm store prune
-   ```
-
-2. Remove node_modules and the lock file:
-   ```bash
-   cd frontend
-   rm -rf node_modules pnpm-lock.yaml
-   ```
-
-3. Reinstall:
-   ```bash
-   cd frontend
-   pnpm install
-   ```
-
----
-
-## Local Mode Service Startup Issues
-
-### Issue: Services Exit Immediately After Startup
-
-**Symptoms**:
-Processes exit quickly after running `make dev-daemon`.
-
-**Solutions**:
-1. Check log files:
-   ```bash
-   tail -f logs/langgraph.log
-   tail -f logs/gateway.log
-   tail -f logs/frontend.log
-   tail -f logs/nginx.log
-   ```
-
-2. Check whether config.yaml is configured correctly
-3. Check environment variables in the .env file
-4. Confirm that required ports are not occupied
-5. Stop all services and restart:
-   ```bash
-   make stop
-   make dev-daemon
-   ```
-
----
-
-### Issue: Nginx Fails to Start Because Temp Directories Do Not Exist
-
-**Symptoms**:
-```
-nginx: [emerg] mkdir() "/opt/homebrew/var/run/nginx/client_body_temp" failed (2: No such file or directory)
-```
-
-**Solutions**:
-Add local temp directory configuration to `docker/nginx/nginx.local.conf` so nginx uses the repository's temp directory.
-
-Add the following at the beginning of the `http` block:
-```nginx
-client_body_temp_path temp/client_body_temp;
-proxy_temp_path temp/proxy_temp;
-fastcgi_temp_path temp/fastcgi_temp;
-uwsgi_temp_path temp/uwsgi_temp;
-scgi_temp_path temp/scgi_temp;
-```
-
-Note: The `temp/` directory under the repository root is created automatically by `make dev` or `make dev-daemon`.
-
----
-
-### Issue: Nginx Fails to Start (General)
-
-**Symptoms**:
-The nginx process fails to start or reports an error.
-
-**Solutions**:
-1. Check the nginx configuration:
-   ```bash
-   nginx -t -c docker/nginx/nginx.local.conf -p .
-   ```
-
-2. Check nginx logs:
-   ```bash
-   tail -f logs/nginx.log
-   ```
-
-3. Ensure no other nginx process is running:
-   ```bash
-   ps aux | grep nginx
-   ```
-
-4. If needed, stop existing nginx processes:
-   ```bash
-   pkill -9 nginx
-   ```
-
----
-
-### Issue: Frontend Compilation Fails
-
-**Symptoms**:
-Compilation errors appear in `frontend.log`.
-
-**Solutions**:
-1. Check frontend logs:
-   ```bash
-   tail -f logs/frontend.log
-   ```
-
-2. Check whether Node.js version is 22+
-3. Reinstall frontend dependencies:
-   ```bash
-   cd frontend
-   rm -rf node_modules .next
-   pnpm install
-   ```
-
-4. Restart services:
-   ```bash
-   make stop
-   make dev-daemon
-   ```
-
----
-
-### Issue: Gateway Fails to Start
-
-**Symptoms**:
-Errors appear in `gateway.log`.
-
-**Solutions**:
-1. Check gateway logs:
-   ```bash
-   tail -f logs/gateway.log
-   ```
-
-2. Check whether config.yaml exists and has valid formatting
-3. Check whether Python dependencies are complete:
-   ```bash
-   cd backend
-   uv sync
-   ```
-
-4. Confirm that the LangGraph service is running normally (if not in gateway mode)
-
----
-
-### Issue: LangGraph Fails to Start
-
-**Symptoms**:
-Errors appear in `langgraph.log`.
-
-**Solutions**:
-1. Check LangGraph logs:
-   ```bash
-   tail -f logs/langgraph.log
-   ```
-
-2. Check config.yaml
-3. Check whether Python dependencies are complete
-4. Confirm that port 2024 is not occupied
-
----
-
-## Docker-Related Issues
-
-### Issue: Docker Commands Cannot Run
-
-**Symptoms**:
-```
-Cannot connect to the Docker daemon
-```
-
-**Solutions**:
-1. Confirm that Docker Desktop is running
-2. macOS: check whether the Docker icon appears in the top menu bar
-3. Linux: run `sudo systemctl start docker`
-4. Run `docker info` again to verify
-
----
-
-### Issue: `make docker-init` Fails to Pull the Image
-
-**Symptoms**:
-```
-Error pulling image: connection refused
-```
-
-**Solutions**:
-1. Check network connectivity
-2. Configure a Docker image mirror if needed
-3. Check whether a proxy is required
-4. Switch to local installation mode if necessary (recommended)
-
----
-
-## Configuration File Issues
-
-### Issue: config.yaml Is Missing or Invalid
-
-**Symptoms**:
-```
-Error: could not read config.yaml
-```
-
-**Solutions**:
-1. Regenerate the configuration file:
-   ```bash
-   make config
-   ```
-
-2. Check YAML syntax:
-   - Make sure indentation is correct (use 2 spaces)
-   - Make sure there are no tab characters
-   - Check that there is a space after each colon
-
-3. Use a YAML validation tool to check the format
-
----
-
-### Issue: Model API Key Is Not Configured
-
-**Symptoms**:
-After services start, API requests fail with authentication errors.
-
-**Solutions**:
-1. Edit the .env file and add the API key:
-   ```bash
-   OPENAI_API_KEY=your-actual-api-key-here
-   ```
-
-2. Restart services (local mode):
-   ```bash
-   make stop
-   make dev-daemon
-   ```
-
-3. Restart services (Docker mode):
-   ```bash
-   make docker-stop
-   make docker-start
-   ```
-
-4. Confirm that the model configuration in config.yaml references the environment variable correctly
-
----
-
-## Service Health Check Issues
-
-### Issue: Frontend Page Is Not Accessible
-
-**Symptoms**:
-The browser shows a connection failure when visiting http://localhost:2026.
-
-**Solutions** (local mode):
-1. Confirm that the nginx process is running:
-   ```bash
-   ps aux | grep nginx
-   ```
-
-2. Check nginx logs:
-   ```bash
-   tail -f logs/nginx.log
-   ```
-
-3. Check firewall settings
-
-**Solutions** (Docker mode):
-1. Confirm that the nginx container is running:
-   ```bash
-   docker ps | grep nginx
-   ```
-
-2. Check nginx logs:
-   ```bash
-   cd docker && docker compose -p deer-flow-dev -f docker-compose-dev.yaml logs nginx
-   ```
-
-3. Check firewall settings
-
----
-
-### Issue: API Gateway Health Check Fails
-
-**Symptoms**:
-Accessing `/health` returns an error or times out.
-
-**Solutions** (local mode):
-1. Check gateway logs:
-   ```bash
-   tail -f logs/gateway.log
-   ```
-
-2. Confirm that config.yaml exists and has valid formatting
-3. Check whether Python dependencies are complete
-4. Confirm that the LangGraph service is running normally
-
-**Solutions** (Docker mode):
-1. Check gateway container logs:
-   ```bash
-   make docker-logs-gateway
-   ```
-
-2. Confirm that config.yaml is mounted correctly
-3. Check whether Python dependencies are complete
-4. Confirm that the LangGraph service is running normally
-
----
-
-## Common Diagnostic Commands
-
-### Local Mode Diagnostics
-
-#### View All Service Processes
-```bash
-ps aux | grep -E "(langgraph|uvicorn|next|nginx)" | grep -v grep
-```
-
-#### View Service Logs
-```bash
-# View all logs
-tail -f logs/*.log
-
-# View specific service logs
-tail -f logs/langgraph.log
-tail -f logs/gateway.log
-tail -f logs/frontend.log
-tail -f logs/nginx.log
-```
-
-#### Stop All Services
-```bash
-make stop
-```
-
-#### Fully Reset the Local Environment
-```bash
-make stop
-make clean
-make config
-make install
-make dev-daemon
-```
-
----
-
-### Docker Mode Diagnostics
-
-#### View All Container Status
-```bash
-docker ps -a
-```
-
-#### View Container Resource Usage
-```bash
-docker stats
-```
-
-#### Enter a Container for Debugging
-```bash
-docker exec -it deer-flow-gateway sh
-```
-
-#### Clean Up All DeerFlow-Related Containers and Images
-```bash
-make docker-stop
-cd docker && docker compose -p deer-flow-dev -f docker-compose-dev.yaml down -v
-```
-
-#### Fully Reset the Docker Environment
-```bash
-make docker-stop
-make clean
-make config
-make docker-init
-make docker-start
-```
-
----
-
-## Get More Help
-
-If the solutions above do not resolve the issue:
-1. Check the GitHub issues for the project: https://github.com/bytedance/deer-flow/issues
-2. Review the project documentation: README.md and the `backend/docs/` directory
-3. Open a new issue and include detailed error logs

.agent/skills/smoke-test/scripts/check_docker.sh

@@ -1,80 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-echo "=========================================="
-echo "  Checking Docker Environment"
-echo "=========================================="
-echo ""
-
-# Check whether Docker is installed
-if command -v docker >/dev/null 2>&1; then
-    echo "✓ Docker is installed"
-    docker --version
-else
-    echo "✗ Docker is not installed"
-    exit 1
-fi
-echo ""
-
-# Check the Docker daemon
-if docker info >/dev/null 2>&1; then
-    echo "✓ Docker daemon is running normally"
-else
-    echo "✗ Docker daemon is not running"
-    echo "  Please start Docker Desktop or the Docker service"
-    exit 1
-fi
-echo ""
-
-# Check Docker Compose
-if docker compose version >/dev/null 2>&1; then
-    echo "✓ Docker Compose is available"
-    docker compose version
-else
-    echo "✗ Docker Compose is not available"
-    exit 1
-fi
-echo ""
-
-# Check port 2026
-if ! command -v lsof >/dev/null 2>&1; then
-    echo "✗ lsof is required to check whether port 2026 is available"
-    exit 1
-fi
-
-port_2026_usage="$(lsof -nP -iTCP:2026 -sTCP:LISTEN 2>/dev/null || true)"
-if [ -n "$port_2026_usage" ]; then
-    echo "⚠  Port 2026 is already in use"
-    echo "  Occupying process:"
-    echo "$port_2026_usage"
-
-    deerflow_process_found=0
-    while IFS= read -r pid; do
-        if [ -z "$pid" ]; then
-            continue
-        fi
-
-        process_command="$(ps -p "$pid" -o command= 2>/dev/null || true)"
-        case "$process_command" in
-            *[Dd]eer[Ff]low*|*[Dd]eerflow*|*[Nn]ginx*deerflow*|*deerflow/*[Nn]ginx*)
-                deerflow_process_found=1
-                ;;
-        esac
-    done <<EOF
-$(printf '%s\n' "$port_2026_usage" | awk 'NR > 1 {print $2}')
-EOF
-
-    if [ "$deerflow_process_found" -eq 1 ]; then
-        echo "✓ Port 2026 is occupied by DeerFlow"
-    else
-        echo "✗ Port 2026 must be free before starting DeerFlow"
-        exit 1
-    fi
-else
-    echo "✓ Port 2026 is available"
-fi
-echo ""
-
-echo "=========================================="
-echo "  Docker Environment Check Complete"
-echo "=========================================="

.agent/skills/smoke-test/scripts/check_local_env.sh

@@ -1,93 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-echo "=========================================="
-echo "  Checking Local Development Environment"
-echo "=========================================="
-echo ""
-
-all_passed=true
-
-# Check Node.js
-echo "1. Checking Node.js..."
-if command -v node >/dev/null 2>&1; then
-    NODE_VERSION=$(node --version | sed 's/v//')
-    NODE_MAJOR=$(echo "$NODE_VERSION" | cut -d. -f1)
-    if [ "$NODE_MAJOR" -ge 22 ]; then
-        echo "✓ Node.js is installed (version: $NODE_VERSION)"
-    else
-        echo "✗ Node.js version is too old (current: $NODE_VERSION, required: 22+)"
-        all_passed=false
-    fi
-else
-    echo "✗ Node.js is not installed"
-    all_passed=false
-fi
-echo ""
-
-# Check pnpm
-echo "2. Checking pnpm..."
-if command -v pnpm >/dev/null 2>&1; then
-    echo "✓ pnpm is installed (version: $(pnpm --version))"
-else
-    echo "✗ pnpm is not installed"
-    echo "  Install command: npm install -g pnpm"
-    all_passed=false
-fi
-echo ""
-
-# Check uv
-echo "3. Checking uv..."
-if command -v uv >/dev/null 2>&1; then
-    echo "✓ uv is installed (version: $(uv --version))"
-else
-    echo "✗ uv is not installed"
-    all_passed=false
-fi
-echo ""
-
-# Check nginx
-echo "4. Checking nginx..."
-if command -v nginx >/dev/null 2>&1; then
-    echo "✓ nginx is installed (version: $(nginx -v 2>&1))"
-else
-    echo "✗ nginx is not installed"
-    echo "  macOS: brew install nginx"
-    echo "  Linux: install it with the system package manager"
-    all_passed=false
-fi
-echo ""
-
-# Check ports
-echo "5. Checking ports..."
-if ! command -v lsof >/dev/null 2>&1; then
-    echo "✗ lsof is not installed, so port availability cannot be verified"
-    echo "  Install lsof and rerun this check"
-    all_passed=false
-else
-    for port in 2026 3000 8001 2024; do
-        if lsof -i :$port >/dev/null 2>&1; then
-            echo "⚠  Port $port is already in use:"
-            lsof -i :$port | head -2
-            all_passed=false
-        else
-            echo "✓ Port $port is available"
-        fi
-    done
-fi
-echo ""
-
-# Summary
-echo "=========================================="
-echo "  Environment Check Summary"
-echo "=========================================="
-echo ""
-if [ "$all_passed" = true ]; then
-    echo "✅ All environment checks passed!"
-    echo ""
-    echo "Next step: run make install to install dependencies"
-    exit 0
-else
-    echo "❌ Some checks failed. Please fix the issues above first"
-    exit 1
-fi

.agent/skills/smoke-test/scripts/deploy_docker.sh

@@ -1,65 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-echo "=========================================="
-echo "  Docker Deployment"
-echo "=========================================="
-echo ""
-
-# Check config.yaml
-if [ ! -f "config.yaml" ]; then
-    echo "config.yaml does not exist. Generating it..."
-    make config
-    echo ""
-    echo "⚠  Please edit config.yaml to configure your models and API keys"
-    echo "  Then run this script again"
-    exit 1
-else
-    echo "✓ config.yaml exists"
-fi
-echo ""
-
-# Check the .env file
-if [ ! -f ".env" ]; then
-    echo ".env does not exist. Copying it from the example..."
-    if [ -f ".env.example" ]; then
-        cp .env.example .env
-        echo "✓ Created the .env file"
-    else
-        echo "⚠  .env.example does not exist. Please create the .env file manually"
-    fi
-else
-    echo "✓ .env file exists"
-fi
-echo ""
-
-# Check the frontend .env file
-if [ ! -f "frontend/.env" ]; then
-    echo "frontend/.env does not exist. Copying it from the example..."
-    if [ -f "frontend/.env.example" ]; then
-        cp frontend/.env.example frontend/.env
-        echo "✓ Created the frontend/.env file"
-    else
-        echo "⚠  frontend/.env.example does not exist. Please create frontend/.env manually"
-    fi
-else
-    echo "✓ frontend/.env file exists"
-fi
-echo ""
-# Initialize the Docker environment
-echo "Initializing the Docker environment..."
-make docker-init
-echo ""
-
-# Start Docker services
-echo "Starting Docker services..."
-make docker-start
-echo ""
-
-echo "=========================================="
-echo "  Deployment Complete"
-echo "=========================================="
-echo ""
-echo "🌐 Access URL: http://localhost:2026"
-echo "📋 View logs: make docker-logs"
-echo "🛑 Stop services: make docker-stop"

.agent/skills/smoke-test/scripts/deploy_local.sh

@@ -1,63 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-echo "=========================================="
-echo "  Local Mode Deployment"
-echo "=========================================="
-echo ""
-
-# Check config.yaml
-if [ ! -f "config.yaml" ]; then
-    echo "config.yaml does not exist. Generating it..."
-    make config
-    echo ""
-    echo "⚠  Please edit config.yaml to configure your models and API keys"
-    echo "  Then run this script again"
-    exit 1
-else
-    echo "✓ config.yaml exists"
-fi
-echo ""
-
-# Check the .env file
-if [ ! -f ".env" ]; then
-    echo ".env does not exist. Copying it from the example..."
-    if [ -f ".env.example" ]; then
-        cp .env.example .env
-        echo "✓ Created the .env file"
-    else
-        echo "⚠  .env.example does not exist. Please create the .env file manually"
-    fi
-else
-    echo "✓ .env file exists"
-fi
-echo ""
-
-# Check dependencies
-echo "Checking dependencies..."
-make check
-echo ""
-
-# Install dependencies
-echo "Installing dependencies..."
-make install
-echo ""
-
-# Start services
-echo "Starting services (background mode)..."
-make dev-daemon
-echo ""
-
-echo "=========================================="
-echo "  Deployment Complete"
-echo "=========================================="
-echo ""
-echo "🌐 Access URL: http://localhost:2026"
-echo "📋 View logs:"
-echo "   - logs/langgraph.log"
-echo "   - logs/gateway.log"
-echo "   - logs/frontend.log"
-echo "   - logs/nginx.log"
-echo "🛑 Stop services: make stop"
-echo ""
-echo "Please wait 90-120 seconds for all services to start completely, then run the health check"

.agent/skills/smoke-test/scripts/frontend_check.sh

@@ -1,70 +0,0 @@
-#!/usr/bin/env bash
-set +e
-
-echo "=========================================="
-echo "  Frontend Page Smoke Check"
-echo "=========================================="
-echo ""
-
-BASE_URL="${BASE_URL:-http://localhost:2026}"
-DOC_PATH="${DOC_PATH:-/en/docs}"
-
-all_passed=true
-
-check_status() {
-    local name="$1"
-    local url="$2"
-    local expected_re="$3"
-
-    local status
-    status="$(curl -s -o /dev/null -w "%{http_code}" -L "$url")"
-    if echo "$status" | grep -Eq "$expected_re"; then
-        echo "✓ $name ($url) -> $status"
-    else
-        echo "✗ $name ($url) -> $status (expected: $expected_re)"
-        all_passed=false
-    fi
-}
-
-check_final_url() {
-    local name="$1"
-    local url="$2"
-    local expected_path_re="$3"
-
-    local effective
-    effective="$(curl -s -o /dev/null -w "%{url_effective}" -L "$url")"
-    if echo "$effective" | grep -Eq "$expected_path_re"; then
-        echo "✓ $name redirect target -> $effective"
-    else
-        echo "✗ $name redirect target -> $effective (expected path: $expected_path_re)"
-        all_passed=false
-    fi
-}
-
-echo "1. Checking entry pages..."
-check_status "Landing page" "${BASE_URL}/" "200"
-check_status "Workspace redirect" "${BASE_URL}/workspace" "200|301|302|307|308"
-check_final_url "Workspace redirect" "${BASE_URL}/workspace" "/workspace/chats/"
-echo ""
-
-echo "2. Checking key workspace routes..."
-check_status "New chat page" "${BASE_URL}/workspace/chats/new" "200"
-check_status "Chats list page" "${BASE_URL}/workspace/chats" "200"
-check_status "Agents gallery page" "${BASE_URL}/workspace/agents" "200"
-echo ""
-
-echo "3. Checking docs route (optional)..."
-check_status "Docs page" "${BASE_URL}${DOC_PATH}" "200|404"
-echo ""
-
-echo "=========================================="
-echo "  Frontend Smoke Check Summary"
-echo "=========================================="
-echo ""
-if [ "$all_passed" = true ]; then
-    echo "✅ Frontend smoke checks passed!"
-    exit 0
-else
-    echo "❌ Frontend smoke checks failed"
-    exit 1
-fi

.agent/skills/smoke-test/scripts/health_check.sh

@@ -1,125 +0,0 @@
-#!/usr/bin/env bash
-set +e
-
-echo "=========================================="
-echo "  Service Health Check"
-echo "=========================================="
-echo ""
-
-all_passed=true
-mode="${SMOKE_TEST_MODE:-auto}"
-summary_hint="make logs"
-
-print_step() {
-    echo "$1"
-}
-
-check_http_status() {
-    local name="$1"
-    local url="$2"
-    local expected_re="$3"
-    local status
-
-    status="$(curl -s -o /dev/null -w "%{http_code}" "$url" 2>/dev/null)"
-    if echo "$status" | grep -Eq "$expected_re"; then
-        echo "✓ $name is accessible ($url -> $status)"
-    else
-        echo "✗ $name is not accessible ($url -> ${status:-000})"
-        all_passed=false
-    fi
-}
-
-check_listen_port() {
-    local name="$1"
-    local port="$2"
-
-    if lsof -nP -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1; then
-        echo "✓ $name is listening on port $port"
-    else
-        echo "✗ $name is not listening on port $port"
-        all_passed=false
-    fi
-}
-
-docker_available() {
-    command -v docker >/dev/null 2>&1 && docker info >/dev/null 2>&1
-}
-
-detect_mode() {
-    case "$mode" in
-        local|docker)
-            echo "$mode"
-            return
-            ;;
-    esac
-
-    if docker_available && docker ps --format "{{.Names}}" | grep -q "deer-flow"; then
-        echo "docker"
-    else
-        echo "local"
-    fi
-}
-
-mode="$(detect_mode)"
-
-echo "Deployment mode: $mode"
-echo ""
-
-if [ "$mode" = "docker" ]; then
-    summary_hint="make docker-logs"
-    print_step "1. Checking container status..."
-    if docker ps --format "{{.Names}}" | grep -q "deer-flow"; then
-        echo "✓ Containers are running:"
-        docker ps --format "  - {{.Names}} ({{.Status}})"
-    else
-        echo "✗ No DeerFlow-related containers are running"
-        all_passed=false
-    fi
-else
-    summary_hint="logs/{langgraph,gateway,frontend,nginx}.log"
-    print_step "1. Checking local service ports..."
-    check_listen_port "Nginx" 2026
-    check_listen_port "Frontend" 3000
-    check_listen_port "Gateway" 8001
-    check_listen_port "LangGraph" 2024
-fi
-echo ""
-
-echo "2. Waiting for services to fully start (30 seconds)..."
-sleep 30
-echo ""
-
-echo "3. Checking frontend service..."
-check_http_status "Frontend service" "http://localhost:2026" "200|301|302|307|308"
-echo ""
-
-echo "4. Checking API Gateway..."
-health_response=$(curl -s http://localhost:2026/health 2>/dev/null)
-if [ $? -eq 0 ] && [ -n "$health_response" ]; then
-    echo "✓ API Gateway health check passed"
-    echo "  Response: $health_response"
-else
-    echo "✗ API Gateway health check failed"
-    all_passed=false
-fi
-echo ""
-
-echo "5. Checking LangGraph service..."
-check_http_status "LangGraph service" "http://localhost:2024/" "200|301|302|307|308|404"
-echo ""
-
-echo "=========================================="
-echo "  Health Check Summary"
-echo "=========================================="
-echo ""
-if [ "$all_passed" = true ]; then
-    echo "✅ All checks passed!"
-    echo ""
-    echo "🌐 Application URL: http://localhost:2026"
-    exit 0
-else
-    echo "❌ Some checks failed"
-    echo ""
-    echo "Please review: $summary_hint"
-    exit 1
-fi

.agent/skills/smoke-test/scripts/pull_code.sh

@@ -1,49 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-echo "=========================================="
-echo "  Pulling the Latest Code"
-echo "=========================================="
-echo ""
-
-# Check whether the current directory is a Git repository
-if [ ! -d ".git" ]; then
-    echo "✗ The current directory is not a Git repository"
-    exit 1
-fi
-
-# Check Git status
-echo "Checking Git status..."
-if git status --porcelain | grep -q .; then
-    echo "⚠  Uncommitted changes detected:"
-    git status --short
-    echo ""
-    echo "Please commit or stash your changes before continuing"
-    echo "Options:"
-    echo "  1. git add . && git commit -m 'Save changes'"
-    echo "  2. git stash (stash changes and restore them later)"
-    echo "  3. git reset --hard HEAD (discard local changes - use with caution)"
-    exit 1
-else
-    echo "✓ Working tree is clean"
-fi
-echo ""
-
-# Fetch remote updates
-echo "Fetching remote updates..."
-git fetch origin main
-echo ""
-
-# Pull the latest code
-echo "Pulling the latest code..."
-git pull origin main
-echo ""
-
-# Show the latest commit
-echo "Latest commit:"
-git log -1 --oneline
-echo ""
-
-echo "=========================================="
-echo "  Code Update Complete"
-echo "=========================================="

.agent/skills/smoke-test/templates/report.docker.template.md

@@ -1,180 +0,0 @@
-# DeerFlow Smoke Test Report
-
-**Test Date**: {{test_date}}  
-**Test Environment**: {{test_environment}}  
-**Deployment Mode**: Docker  
-**Test Version**: {{git_commit}}
-
----
-
-## Execution Summary
-
-| Metric | Status |
-|------|------|
-| Total Test Phases | 6 |
-| Passed Phases | {{passed_stages}} |
-| Failed Phases | {{failed_stages}} |
-| Overall Conclusion | **{{overall_status}}** |
-
-### Key Test Cases
-
-| Case | Result | Details |
-|------|--------|---------|
-| Code update check | {{case_code_update}} | {{case_code_update_details}} |
-| Environment check | {{case_env_check}} | {{case_env_check_details}} |
-| Configuration preparation | {{case_config_prep}} | {{case_config_prep_details}} |
-| Deployment | {{case_deploy}} | {{case_deploy_details}} |
-| Health check | {{case_health_check}} | {{case_health_check_details}} |
-| Frontend routes | {{case_frontend_routes_overall}} | {{case_frontend_routes_details}} |
-
----
-
-## Detailed Test Results
-
-### Phase 1: Code Update Check
-
-- [x] Confirm current directory - {{status_dir_check}}
-- [x] Check Git status - {{status_git_status}}
-- [x] Pull latest code - {{status_git_pull}}
-- [x] Confirm code update - {{status_git_verify}}
-
-**Phase Status**: {{stage1_status}}
-
----
-
-### Phase 2: Docker Environment Check
-
-- [x] Docker version - {{status_docker_version}}
-- [x] Docker daemon - {{status_docker_daemon}}
-- [x] Docker Compose - {{status_docker_compose}}
-- [x] Port check - {{status_port_check}}
-
-**Phase Status**: {{stage2_status}}
-
----
-
-### Phase 3: Configuration Preparation
-
-- [x] config.yaml - {{status_config_yaml}}
-- [x] .env file - {{status_env_file}}
-- [x] Model configuration - {{status_model_config}}
-
-**Phase Status**: {{stage3_status}}
-
----
-
-### Phase 4: Docker Deployment
-
-- [x] docker-init - {{status_docker_init}}
-- [x] docker-start - {{status_docker_start}}
-- [x] Service startup wait - {{status_wait_startup}}
-
-**Phase Status**: {{stage4_status}}
-
----
-
-### Phase 5: Service Health Check
-
-- [x] Container status - {{status_containers}}
-- [x] Frontend service - {{status_frontend}}
-- [x] API Gateway - {{status_api_gateway}}
-- [x] LangGraph service - {{status_langgraph}}
-
-**Phase Status**: {{stage5_status}}
-
----
-
-### Frontend Routes Smoke Results
-
-| Route | Status | Details |
-|-------|--------|---------|
-| Landing `/` | {{landing_status}} | {{landing_details}} |
-| Workspace redirect `/workspace` | {{workspace_redirect_status}} | target {{workspace_redirect_target}} |
-| New chat `/workspace/chats/new` | {{new_chat_status}} | {{new_chat_details}} |
-| Chats list `/workspace/chats` | {{chats_list_status}} | {{chats_list_details}} |
-| Agents gallery `/workspace/agents` | {{agents_gallery_status}} | {{agents_gallery_details}} |
-| Docs `{{docs_path}}` | {{docs_status}} | {{docs_details}} |
-
-**Summary**: {{frontend_routes_summary}}
-
----
-
-### Phase 6: Test Report Generation
-
-- [x] Result summary - {{status_summary}}
-- [x] Issue log - {{status_issues}}
-- [x] Report generation - {{status_report}}
-
-**Phase Status**: {{stage6_status}}
-
----
-
-## Issue Log
-
-### Issue 1
-**Description**: {{issue1_description}}  
-**Severity**: {{issue1_severity}}  
-**Solution**: {{issue1_solution}}
-
----
-
-## Environment Information
-
-### Docker Version
-```text
-{{docker_version_output}}
-```
-
-### Git Information
-```text
-Repository: {{git_repo}}
-Branch: {{git_branch}}
-Commit: {{git_commit}}
-Commit Message: {{git_commit_message}}
-```
-
-### Configuration Summary
-- config.yaml exists: {{config_exists}}
-- .env file exists: {{env_exists}}
-- Number of configured models: {{model_count}}
-
----
-
-## Container Status
-
-| Container Name | Status | Uptime |
-|----------|------|----------|
-| deer-flow-nginx | {{nginx_status}} | {{nginx_uptime}} |
-| deer-flow-frontend | {{frontend_status}} | {{frontend_uptime}} |
-| deer-flow-gateway | {{gateway_status}} | {{gateway_uptime}} |
-| deer-flow-langgraph | {{langgraph_status}} | {{langgraph_uptime}} |
-
----
-
-## Recommendations and Next Steps
-
-### If the Test Passes
-1. [ ] Visit http://localhost:2026 to start using DeerFlow
-2. [ ] Configure your preferred model if it is not configured yet
-3. [ ] Explore available skills
-4. [ ] Refer to the documentation to learn more features
-
-### If the Test Fails
-1. [ ] Review references/troubleshooting.md for common solutions
-2. [ ] Check Docker logs: `make docker-logs`
-3. [ ] Verify configuration file format and content
-4. [ ] If needed, fully reset the environment: `make clean && make config && make docker-init && make docker-start`
-
----
-
-## Appendix
-
-### Full Logs
-{{full_logs}}
-
-### Tester
-{{tester_name}}
-
----
-
-*Report generated at: {{report_time}}*

.agent/skills/smoke-test/templates/report.local.template.md

@@ -1,185 +0,0 @@
-# DeerFlow Smoke Test Report
-
-**Test Date**: {{test_date}}  
-**Test Environment**: {{test_environment}}  
-**Deployment Mode**: Local  
-**Test Version**: {{git_commit}}
-
----
-
-## Execution Summary
-
-| Metric | Status |
-|------|------|
-| Total Test Phases | 6 |
-| Passed Phases | {{passed_stages}} |
-| Failed Phases | {{failed_stages}} |
-| Overall Conclusion | **{{overall_status}}** |
-
-### Key Test Cases
-
-| Case | Result | Details |
-|------|--------|---------|
-| Code update check | {{case_code_update}} | {{case_code_update_details}} |
-| Environment check | {{case_env_check}} | {{case_env_check_details}} |
-| Configuration preparation | {{case_config_prep}} | {{case_config_prep_details}} |
-| Deployment | {{case_deploy}} | {{case_deploy_details}} |
-| Health check | {{case_health_check}} | {{case_health_check_details}} |
-| Frontend routes | {{case_frontend_routes_overall}} | {{case_frontend_routes_details}} |
-
----
-
-## Detailed Test Results
-
-### Phase 1: Code Update Check
-
-- [x] Confirm current directory - {{status_dir_check}}
-- [x] Check Git status - {{status_git_status}}
-- [x] Pull latest code - {{status_git_pull}}
-- [x] Confirm code update - {{status_git_verify}}
-
-**Phase Status**: {{stage1_status}}
-
----
-
-### Phase 2: Local Environment Check
-
-- [x] Node.js version - {{status_node_version}}
-- [x] pnpm - {{status_pnpm}}
-- [x] uv - {{status_uv}}
-- [x] nginx - {{status_nginx}}
-- [x] Port check - {{status_port_check}}
-
-**Phase Status**: {{stage2_status}}
-
----
-
-### Phase 3: Configuration Preparation
-
-- [x] config.yaml - {{status_config_yaml}}
-- [x] .env file - {{status_env_file}}
-- [x] Model configuration - {{status_model_config}}
-
-**Phase Status**: {{stage3_status}}
-
----
-
-### Phase 4: Local Deployment
-
-- [x] make check - {{status_make_check}}
-- [x] make install - {{status_make_install}}
-- [x] make dev-daemon / make dev - {{status_local_start}}
-- [x] Service startup wait - {{status_wait_startup}}
-
-**Phase Status**: {{stage4_status}}
-
----
-
-### Phase 5: Service Health Check
-
-- [x] Process status - {{status_processes}}
-- [x] Frontend service - {{status_frontend}}
-- [x] API Gateway - {{status_api_gateway}}
-- [x] LangGraph service - {{status_langgraph}}
-
-**Phase Status**: {{stage5_status}}
-
----
-
-### Frontend Routes Smoke Results
-
-| Route | Status | Details |
-|-------|--------|---------|
-| Landing `/` | {{landing_status}} | {{landing_details}} |
-| Workspace redirect `/workspace` | {{workspace_redirect_status}} | target {{workspace_redirect_target}} |
-| New chat `/workspace/chats/new` | {{new_chat_status}} | {{new_chat_details}} |
-| Chats list `/workspace/chats` | {{chats_list_status}} | {{chats_list_details}} |
-| Agents gallery `/workspace/agents` | {{agents_gallery_status}} | {{agents_gallery_details}} |
-| Docs `{{docs_path}}` | {{docs_status}} | {{docs_details}} |
-
-**Summary**: {{frontend_routes_summary}}
-
----
-
-### Phase 6: Test Report Generation
-
-- [x] Result summary - {{status_summary}}
-- [x] Issue log - {{status_issues}}
-- [x] Report generation - {{status_report}}
-
-**Phase Status**: {{stage6_status}}
-
----
-
-## Issue Log
-
-### Issue 1
-**Description**: {{issue1_description}}  
-**Severity**: {{issue1_severity}}  
-**Solution**: {{issue1_solution}}
-
----
-
-## Environment Information
-
-### Local Dependency Versions
-```text
-Node.js: {{node_version_output}}
-pnpm: {{pnpm_version_output}}
-uv: {{uv_version_output}}
-nginx: {{nginx_version_output}}
-```
-
-### Git Information
-```text
-Repository: {{git_repo}}
-Branch: {{git_branch}}
-Commit: {{git_commit}}
-Commit Message: {{git_commit_message}}
-```
-
-### Configuration Summary
-- config.yaml exists: {{config_exists}}
-- .env file exists: {{env_exists}}
-- Number of configured models: {{model_count}}
-
----
-
-## Local Service Status
-
-| Service | Status | Endpoint |
-|---------|--------|----------|
-| Nginx | {{nginx_status}} | {{nginx_endpoint}} |
-| Frontend | {{frontend_status}} | {{frontend_endpoint}} |
-| Gateway | {{gateway_status}} | {{gateway_endpoint}} |
-| LangGraph | {{langgraph_status}} | {{langgraph_endpoint}} |
-
----
-
-## Recommendations and Next Steps
-
-### If the Test Passes
-1. [ ] Visit http://localhost:2026 to start using DeerFlow
-2. [ ] Configure your preferred model if it is not configured yet
-3. [ ] Explore available skills
-4. [ ] Refer to the documentation to learn more features
-
-### If the Test Fails
-1. [ ] Review references/troubleshooting.md for common solutions
-2. [ ] Check local logs: `logs/{langgraph,gateway,frontend,nginx}.log`
-3. [ ] Verify configuration file format and content
-4. [ ] If needed, fully reset the environment: `make stop && make clean && make install && make dev-daemon`
-
----
-
-## Appendix
-
-### Full Logs
-{{full_logs}}
-
-### Tester
-{{tester_name}}
-
----
-
-*Report generated at: {{report_time}}*

.env.example

@@ -24,7 +24,6 @@ INFOQUEST_API_KEY=your-infoquest-api-key
 # SLACK_BOT_TOKEN=your-slack-bot-token
 # SLACK_APP_TOKEN=your-slack-app-token
 # TELEGRAM_BOT_TOKEN=your-telegram-bot-token
-# DISCORD_BOT_TOKEN=your-discord-bot-token
 
 # Enable LangSmith to monitor and debug your LLM calls, agent runs, and tool executions.
 # LANGSMITH_TRACING=true

.github/workflows/e2e-tests.yml

@@ -1,63 +0,0 @@
-name: E2E Tests
-
-on:
-  push:
-    branches: [ 'main' ]
-    paths:
-      - 'frontend/**'
-      - '.github/workflows/e2e-tests.yml'
-  pull_request:
-    types: [opened, synchronize, reopened, ready_for_review]
-    paths:
-      - 'frontend/**'
-      - '.github/workflows/e2e-tests.yml'
-
-concurrency:
-  group: e2e-tests-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  e2e-tests:
-    if: ${{ github.event_name != 'pull_request' || github.event.pull_request.draft == false }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-
-      - name: Enable Corepack
-        run: corepack enable
-
-      - name: Use pinned pnpm version
-        run: corepack prepare pnpm@10.26.2 --activate
-
-      - name: Install frontend dependencies
-        working-directory: frontend
-        run: pnpm install --frozen-lockfile
-
-      - name: Install Playwright Chromium
-        working-directory: frontend
-        run: npx playwright install chromium --with-deps
-
-      - name: Run E2E tests
-        working-directory: frontend
-        run: pnpm exec playwright test
-        env:
-          SKIP_ENV_VALIDATION: '1'
-
-      - name: Upload Playwright report
-        uses: actions/upload-artifact@v4
-        if: ${{ !cancelled() }}
-        with:
-          name: playwright-report
-          path: frontend/playwright-report/
-          retention-days: 7

.github/workflows/frontend-unit-tests.yml

@@ -1,43 +0,0 @@
-name: Frontend Unit Tests
-
-on:
-  push:
-    branches: [ 'main' ]
-  pull_request:
-    types: [opened, synchronize, reopened, ready_for_review]
-
-concurrency:
-  group: frontend-unit-tests-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
-jobs:
-  frontend-unit-tests:
-    if: github.event.pull_request.draft == false
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v6
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '22'
-
-      - name: Enable Corepack
-        run: corepack enable
-
-      - name: Use pinned pnpm version
-        run: corepack prepare pnpm@10.26.2 --activate
-
-      - name: Install frontend dependencies
-        working-directory: frontend
-        run: pnpm install --frozen-lockfile
-
-      - name: Run unit tests of frontend
-        working-directory: frontend
-        run: make test

.gitignore

@@ -40,7 +40,6 @@ coverage/
 skills/custom/*
 logs/
 log/
-debug.log
 
 # Local git hooks (keep only on this machine, do not push)
 .githooks/
@@ -56,7 +55,5 @@ web/
 backend/Dockerfile.langgraph
 config.yaml.bak
 .playwright-mcp
-/frontend/test-results/
-/frontend/playwright-report/
 .gstack/
 .worktrees

.pre-commit-config.yaml

@@ -1,33 +0,0 @@
-repos:
-  # Backend: ruff lint + format via uv (uses the same ruff version as backend deps)
-  - repo: local
-    hooks:
-      - id: ruff
-        name: ruff lint
-        entry: bash -c 'cd backend && uv run ruff check --fix "${@/#backend\//}"' --
-        language: system
-        types_or: [python]
-        files: ^backend/
-      - id: ruff-format
-        name: ruff format
-        entry: bash -c 'cd backend && uv run ruff format "${@/#backend\//}"' --
-        language: system
-        types_or: [python]
-        files: ^backend/
-
-  # Frontend: eslint + prettier (must run from frontend/ for node_modules resolution)
-  - repo: local
-    hooks:
-      - id: frontend-eslint
-        name: eslint (frontend)
-        entry: bash -c 'cd frontend && npx eslint --fix "${@/#frontend\//}"' --
-        language: system
-        types_or: [javascript, tsx, ts]
-        files: ^frontend/
-
-      - id: frontend-prettier
-        name: prettier (frontend)
-        entry: bash -c 'cd frontend && npx prettier --write "${@/#frontend\//}"' --
-        language: system
-        files: ^frontend/
-        types_or: [javascript, tsx, ts, json, css]

CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-willem.jiang@gmail.com.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -77,18 +77,6 @@ export UV_INDEX_URL=https://pypi.org/simple
 export NPM_REGISTRY=https://registry.npmjs.org
 ```
 
-#### Recommended host resources
-
-Use these as practical starting points for development and review environments:
-
-| Scenario | Starting point | Recommended | Notes |
-|---------|-----------|------------|-------|
-| `make dev` on one machine | 4 vCPU, 8 GB RAM | 8 vCPU, 16 GB RAM | Best when DeerFlow uses hosted model APIs. |
-| `make docker-start` review environment | 4 vCPU, 8 GB RAM | 8 vCPU, 16 GB RAM | Docker image builds and sandbox containers need extra headroom. |
-| Shared Linux test server | 8 vCPU, 16 GB RAM | 16 vCPU, 32 GB RAM | Prefer this for heavier multi-agent runs or multiple reviewers. |
-
-`2 vCPU / 4 GB` environments often fail to start reliably or become unresponsive under normal DeerFlow workloads.
-
 #### Linux: Docker daemon permission denied
 
 If `make docker-init`, `make docker-start`, or `make docker-stop` fails on Linux with an error like below, your current user likely does not have permission to access the Docker daemon socket:
@@ -166,7 +154,7 @@ Required tools:
 
 1. **Configure the application** (same as Docker setup above)
 
-2. **Install dependencies** (this also sets up pre-commit hooks):
+2. **Install dependencies**:
    ```bash
    make install
    ```
@@ -298,24 +286,19 @@ Nginx (port 2026) ← Unified entry point
 ```bash
 # Backend tests
 cd backend
-make test
+uv run pytest
 
-# Frontend unit tests
+# Frontend checks
 cd frontend
-make test
-
-# Frontend E2E tests (requires Chromium; builds and auto-starts the Next.js production server)
-cd frontend
-make test-e2e
+pnpm check
 ```
 
 ### PR Regression Checks
 
-Every pull request triggers the following CI workflows:
+Every pull request runs the backend regression workflow at [.github/workflows/backend-unit-tests.yml](.github/workflows/backend-unit-tests.yml), including:
 
-- **Backend unit tests** — [.github/workflows/backend-unit-tests.yml](.github/workflows/backend-unit-tests.yml)
-- **Frontend unit tests** — [.github/workflows/frontend-unit-tests.yml](.github/workflows/frontend-unit-tests.yml)
-- **Frontend E2E tests** — [.github/workflows/e2e-tests.yml](.github/workflows/e2e-tests.yml) (triggered only when `frontend/` files change)
+- `tests/test_provisioner_kubeconfig.py`
+- `tests/test_docker_sandbox_mode_detection.py`
 
 ## Code Style
 

Makefile

@@ -1,29 +1,23 @@
 # DeerFlow - Unified Development Environment
 
-.PHONY: help config config-upgrade check install setup doctor dev dev-pro dev-daemon dev-daemon-pro start start-pro start-daemon start-daemon-pro stop up up-pro down clean docker-init docker-start docker-start-pro docker-stop docker-logs docker-logs-frontend docker-logs-gateway
+.PHONY: help config config-upgrade check install dev dev-pro dev-daemon dev-daemon-pro start start-pro start-daemon start-daemon-pro stop up up-pro down clean docker-init docker-start docker-start-pro docker-stop docker-logs docker-logs-frontend docker-logs-gateway
 
 BASH ?= bash
-BACKEND_UV_RUN = cd backend && uv run
 
 # Detect OS for Windows compatibility
 ifeq ($(OS),Windows_NT)
     SHELL := cmd.exe
     PYTHON ?= python
-    # Run repo shell scripts through Git Bash when Make is launched from cmd.exe / PowerShell.
-    RUN_WITH_GIT_BASH = call scripts\run-with-git-bash.cmd
 else
     PYTHON ?= python3
-    RUN_WITH_GIT_BASH =
 endif
 
 help:
 	@echo "DeerFlow Development Commands:"
-	@echo "  make setup           - Interactive setup wizard (recommended for new users)"
-	@echo "  make doctor          - Check configuration and system requirements"
 	@echo "  make config          - Generate local config files (aborts if config already exists)"
 	@echo "  make config-upgrade  - Merge new fields from config.example.yaml into config.yaml"
 	@echo "  make check           - Check if all required tools are installed"
-	@echo "  make install         - Install all dependencies (frontend + backend + pre-commit hooks)"
+	@echo "  make install         - Install all dependencies (frontend + backend)"
 	@echo "  make setup-sandbox   - Pre-pull sandbox container image (recommended)"
 	@echo "  make dev             - Start all services in development mode (with hot-reloading)"
 	@echo "  make dev-pro         - Start in dev + Gateway mode (experimental, no LangGraph server)"
@@ -50,18 +44,11 @@ help:
 	@echo "  make docker-logs-frontend - View Docker frontend logs"
 	@echo "  make docker-logs-gateway - View Docker gateway logs"
 
-## Setup & Diagnosis
-setup:
-	@$(BACKEND_UV_RUN) python ../scripts/setup_wizard.py
-
-doctor:
-	@$(BACKEND_UV_RUN) python ../scripts/doctor.py
-
 config:
 	@$(PYTHON) ./scripts/configure.py
 
 config-upgrade:
-	@$(RUN_WITH_GIT_BASH) ./scripts/config-upgrade.sh
+	@./scripts/config-upgrade.sh
 
 # Check required tools
 check:
@@ -73,8 +60,6 @@ install:
 	@cd backend && uv sync
 	@echo "Installing frontend dependencies..."
 	@cd frontend && pnpm install
-	@echo "Installing pre-commit hooks..."
-	@$(BACKEND_UV_RUN) --with pre-commit pre-commit install
 	@echo "✓ All dependencies installed"
 	@echo ""
 	@echo "=========================================="
@@ -101,7 +86,7 @@ setup-sandbox:
 	echo ""; \
 	if command -v container >/dev/null 2>&1 && [ "$$(uname)" = "Darwin" ]; then \
 		echo "Detected Apple Container on macOS, pulling image..."; \
-		container image pull "$$IMAGE" || echo "⚠ Apple Container pull failed, will try Docker"; \
+		container pull "$$IMAGE" || echo "⚠ Apple Container pull failed, will try Docker"; \
 	fi; \
 	if command -v docker >/dev/null 2>&1; then \
 		echo "Pulling image using Docker..."; \
@@ -121,46 +106,78 @@ setup-sandbox:
 # Start all services in development mode (with hot-reloading)
 dev:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --dev
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev
+else
+	@./scripts/serve.sh --dev
+endif
 
 # Start all services in dev + Gateway mode (experimental: agent runtime embedded in Gateway)
 dev-pro:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --dev --gateway
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev --gateway
+else
+	@./scripts/serve.sh --dev --gateway
+endif
 
 # Start all services in production mode (with optimizations)
 start:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --prod
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod
+else
+	@./scripts/serve.sh --prod
+endif
 
 # Start all services in prod + Gateway mode (experimental)
 start-pro:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --prod --gateway
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod --gateway
+else
+	@./scripts/serve.sh --prod --gateway
+endif
 
 # Start all services in daemon mode (background)
 dev-daemon:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --dev --daemon
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev --daemon
+else
+	@./scripts/serve.sh --dev --daemon
+endif
 
 # Start daemon + Gateway mode (experimental)
 dev-daemon-pro:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --dev --gateway --daemon
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --dev --gateway --daemon
+else
+	@./scripts/serve.sh --dev --gateway --daemon
+endif
 
 # Start prod services in daemon mode (background)
 start-daemon:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --prod --daemon
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod --daemon
+else
+	@./scripts/serve.sh --prod --daemon
+endif
 
 # Start prod daemon + Gateway mode (experimental)
 start-daemon-pro:
 	@$(PYTHON) ./scripts/check.py
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --prod --gateway --daemon
+ifeq ($(OS),Windows_NT)
+	@call scripts\run-with-git-bash.cmd ./scripts/serve.sh --prod --gateway --daemon
+else
+	@./scripts/serve.sh --prod --gateway --daemon
+endif
 
 # Stop all services
 stop:
-	@$(RUN_WITH_GIT_BASH) ./scripts/serve.sh --stop
+	@./scripts/serve.sh --stop
 
 # Clean up
 clean: stop
@@ -176,29 +193,29 @@ clean: stop
 
 # Initialize Docker containers and install dependencies
 docker-init:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh init
+	@./scripts/docker.sh init
 
 # Start Docker development environment
 docker-start:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh start
+	@./scripts/docker.sh start
 
 # Start Docker in Gateway mode (experimental)
 docker-start-pro:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh start --gateway
+	@./scripts/docker.sh start --gateway
 
 # Stop Docker development environment
 docker-stop:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh stop
+	@./scripts/docker.sh stop
 
 # View Docker development logs
 docker-logs:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh logs
+	@./scripts/docker.sh logs
 
 # View Docker development logs
 docker-logs-frontend:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh logs --frontend
+	@./scripts/docker.sh logs --frontend
 docker-logs-gateway:
-	@$(RUN_WITH_GIT_BASH) ./scripts/docker.sh logs --gateway
+	@./scripts/docker.sh logs --gateway
 
 # ==========================================
 # Production Docker Commands
@@ -206,12 +223,12 @@ docker-logs-gateway:
 
 # Build and start production services
 up:
-	@$(RUN_WITH_GIT_BASH) ./scripts/deploy.sh
+	@./scripts/deploy.sh
 
 # Build and start production services in Gateway mode
 up-pro:
-	@$(RUN_WITH_GIT_BASH) ./scripts/deploy.sh --gateway
+	@./scripts/deploy.sh --gateway
 
 # Stop and remove production containers
 down:
-	@$(RUN_WITH_GIT_BASH) ./scripts/deploy.sh down
+	@./scripts/deploy.sh down

README.md

@@ -53,7 +53,6 @@ DeerFlow has newly integrated the intelligent search and crawling toolset indepe
   - [Quick Start](#quick-start)
     - [Configuration](#configuration)
     - [Running the Application](#running-the-application)
-      - [Deployment Sizing](#deployment-sizing)
       - [Option 1: Docker (Recommended)](#option-1-docker-recommended)
       - [Option 2: Local Development](#option-2-local-development)
     - [Advanced](#advanced)
@@ -104,38 +103,35 @@ That prompt is intended for coding agents. It tells the agent to clone the repo
    cd deer-flow
    ```
 
-2. **Run the setup wizard**
+2. **Generate local configuration files**
 
    From the project root directory (`deer-flow/`), run:
 
    ```bash
-   make setup
+   make config
    ```
 
-   This launches an interactive wizard that guides you through choosing an LLM provider, optional web search, and execution/safety preferences such as sandbox mode, bash access, and file-write tools. It generates a minimal `config.yaml` and writes your keys to `.env`. Takes about 2 minutes.
+   This command creates local configuration files based on the provided example templates.
 
-   The wizard also lets you configure an optional web search provider, or skip it for now.
+3. **Configure your preferred model(s)**
 
-   Run `make doctor` at any time to verify your setup and get actionable fix hints.
-
-   > **Advanced / manual configuration**: If you prefer to edit `config.yaml` directly, run `make config` instead to copy the full template. See `config.example.yaml` for the complete reference including CLI-backed providers (Codex CLI, Claude Code OAuth), OpenRouter, Responses API, and more.
-
-   <details>
-   <summary>Manual model configuration examples</summary>
+   Edit `config.yaml` and define at least one model:
 
    ```yaml
    models:
-     - name: gpt-4o
-       display_name: GPT-4o
-       use: langchain_openai:ChatOpenAI
-       model: gpt-4o
-       api_key: $OPENAI_API_KEY
+     - name: gpt-4                       # Internal identifier
+       display_name: GPT-4               # Human-readable name
+       use: langchain_openai:ChatOpenAI  # LangChain class path
+       model: gpt-4                      # Model identifier for API
+       api_key: $OPENAI_API_KEY          # API key (recommended: use env var)
+       max_tokens: 4096                  # Maximum tokens per request
+       temperature: 0.7                  # Sampling temperature
 
      - name: openrouter-gemini-2.5-flash
        display_name: Gemini 2.5 Flash (OpenRouter)
        use: langchain_openai:ChatOpenAI
        model: google/gemini-2.5-flash-preview
-       api_key: $OPENROUTER_API_KEY
+       api_key: $OPENAI_API_KEY          # OpenRouter still uses the OpenAI-compatible field name here
        base_url: https://openrouter.ai/api/v1
 
      - name: gpt-5-responses
@@ -185,39 +181,50 @@ That prompt is intended for coding agents. It tells the agent to clone the repo
    ```
 
    - Codex CLI reads `~/.codex/auth.json`
-   - Claude Code accepts `CLAUDE_CODE_OAUTH_TOKEN`, `ANTHROPIC_AUTH_TOKEN`, `CLAUDE_CODE_CREDENTIALS_PATH`, or `~/.claude/.credentials.json`
-   - ACP agent entries are separate from model providers — if you configure `acp_agents.codex`, point it at a Codex ACP adapter such as `npx -y @zed-industries/codex-acp`
-   - On macOS, export Claude Code auth explicitly if needed:
+   - The Codex Responses endpoint currently rejects `max_tokens` and `max_output_tokens`, so `CodexChatModel` does not expose a request-level token cap
+   - Claude Code accepts `CLAUDE_CODE_OAUTH_TOKEN`, `ANTHROPIC_AUTH_TOKEN`, `CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR`, `CLAUDE_CODE_CREDENTIALS_PATH`, or plaintext `~/.claude/.credentials.json`
+   - ACP agent entries are separate from model providers. If you configure `acp_agents.codex`, point it at a Codex ACP adapter such as `npx -y @zed-industries/codex-acp`; the standard `codex` CLI binary is not ACP-compatible by itself
+   - On macOS, DeerFlow does not probe Keychain automatically. Export Claude Code auth explicitly if needed:
 
    ```bash
    eval "$(python3 scripts/export_claude_code_oauth.py --print-export)"
    ```
+   
+4. **Set API keys for your configured model(s)**
+
+   Choose one of the following methods:
+
+- Option A: Edit the `.env` file in the project root (Recommended)
 
-   API keys can also be set manually in `.env` (recommended) or exported in your shell:
 
    ```bash
-   OPENAI_API_KEY=your-openai-api-key
    TAVILY_API_KEY=your-tavily-api-key
+   OPENAI_API_KEY=your-openai-api-key
+   # OpenRouter also uses OPENAI_API_KEY when your config uses langchain_openai:ChatOpenAI + base_url.
+   # Add other provider keys as needed
+   INFOQUEST_API_KEY=your-infoquest-api-key
    ```
 
-   </details>
+- Option B: Export environment variables in your shell
+
+   ```bash
+   export OPENAI_API_KEY=your-openai-api-key
+   ```
+
+   For CLI-backed providers:
+   - Codex CLI: `~/.codex/auth.json`
+   - Claude Code OAuth: explicit env/file handoff or `~/.claude/.credentials.json`
+
+- Option C: Edit `config.yaml` directly (Not recommended for production)
+
+   ```yaml
+   models:
+     - name: gpt-4
+       api_key: your-actual-api-key-here  # Replace placeholder
+   ```
 
 ### Running the Application
 
-#### Deployment Sizing
-
-Use the table below as a practical starting point when choosing how to run DeerFlow:
-
-| Deployment target | Starting point | Recommended | Notes |
-|---------|-----------|------------|-------|
-| Local evaluation / `make dev` | 4 vCPU, 8 GB RAM, 20 GB free SSD | 8 vCPU, 16 GB RAM | Good for one developer or one light session with hosted model APIs. `2 vCPU / 4 GB` is usually not enough. |
-| Docker development / `make docker-start` | 4 vCPU, 8 GB RAM, 25 GB free SSD | 8 vCPU, 16 GB RAM | Image builds, bind mounts, and sandbox containers need more headroom than pure local dev. |
-| Long-running server / `make up` | 8 vCPU, 16 GB RAM, 40 GB free SSD | 16 vCPU, 32 GB RAM | Preferred for shared use, multi-agent runs, report generation, or heavier sandbox workloads. |
-
-- These numbers cover DeerFlow itself. If you also host a local LLM, size that service separately.
-- Linux plus Docker is the recommended deployment target for a persistent server. macOS and Windows are best treated as development or evaluation environments.
-- If CPU or memory usage stays pinned, reduce concurrent runs first, then move to the next sizing tier.
-
 #### Option 1: Docker (Recommended)
 
 **Development** (hot-reload, source mounts):
@@ -254,7 +261,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed Docker development guide.
 
 If you prefer running services locally:
 
-Prerequisite: complete the "Configuration" steps above first (`make setup`). `make dev` requires a valid `config.yaml` in the project root (can be overridden via `DEER_FLOW_CONFIG_PATH`). Run `make doctor` to verify your setup before starting.
+Prerequisite: complete the "Configuration" steps above first (`make config` and model API keys). `make dev` requires a valid configuration file (defaults to `config.yaml` in the project root; can be overridden via `DEER_FLOW_CONFIG_PATH`).
 On Windows, run the local development flow from Git Bash. Native `cmd.exe` and PowerShell shells are not supported for the bash-based service scripts, and WSL is not guaranteed because some scripts rely on Git for Windows utilities such as `cygpath`.
 
 1. **Check prerequisites**:
@@ -264,7 +271,7 @@ On Windows, run the local development flow from Git Bash. Native `cmd.exe` and P
 
 2. **Install dependencies**:
    ```bash
-   make install  # Install backend + frontend dependencies + pre-commit hooks
+   make install  # Install backend + frontend dependencies
    ```
 
 3. **(Optional) Pre-pull sandbox image**:
@@ -368,7 +375,6 @@ DeerFlow supports receiving tasks from messaging apps. Channels auto-start when
 | Telegram | Bot API (long-polling) | Easy |
 | Slack | Socket Mode | Moderate |
 | Feishu / Lark | WebSocket | Moderate |
-| WeChat | Tencent iLink (long-polling) | Moderate |
 | WeCom | WebSocket | Moderate |
 
 **Configuration in `config.yaml`:**
@@ -413,19 +419,6 @@ channels:
     bot_token: $TELEGRAM_BOT_TOKEN
     allowed_users: []               # empty = allow all
 
-  wechat:
-    enabled: false
-    bot_token: $WECHAT_BOT_TOKEN
-    ilink_bot_id: $WECHAT_ILINK_BOT_ID
-    qrcode_login_enabled: true      # optional: allow first-time QR bootstrap when bot_token is absent
-    allowed_users: []               # empty = allow all
-    polling_timeout: 35
-    state_dir: ./.deer-flow/wechat/state
-    max_inbound_image_bytes: 20971520
-    max_outbound_image_bytes: 20971520
-    max_inbound_file_bytes: 52428800
-    max_outbound_file_bytes: 52428800
-
     # Optional: per-channel / per-user session settings
     session:
       assistant_id: mobile-agent  # custom agent names are also supported here
@@ -459,10 +452,6 @@ SLACK_APP_TOKEN=xapp-...
 FEISHU_APP_ID=cli_xxxx
 FEISHU_APP_SECRET=your_app_secret
 
-# WeChat iLink
-WECHAT_BOT_TOKEN=your_ilink_bot_token
-WECHAT_ILINK_BOT_ID=your_ilink_bot_id
-
 # WeCom
 WECOM_BOT_ID=your_bot_id
 WECOM_BOT_SECRET=your_bot_secret
@@ -488,14 +477,6 @@ WECOM_BOT_SECRET=your_bot_secret
 3. Under **Events**, subscribe to `im.message.receive_v1` and select **Long Connection** mode.
 4. Copy the App ID and App Secret. Set `FEISHU_APP_ID` and `FEISHU_APP_SECRET` in `.env` and enable the channel in `config.yaml`.
 
-**WeChat Setup**
-
-1. Enable the `wechat` channel in `config.yaml`.
-2. Either set `WECHAT_BOT_TOKEN` in `.env`, or set `qrcode_login_enabled: true` for first-time QR bootstrap.
-3. When `bot_token` is absent and QR bootstrap is enabled, watch backend logs for the QR content returned by iLink and complete the binding flow.
-4. After the QR flow succeeds, DeerFlow persists the acquired token under `state_dir` for later restarts.
-5. For Docker Compose deployments, keep `state_dir` on a persistent volume so the `get_updates_buf` cursor and saved auth state survive restarts.
-
 **WeCom Setup**
 
 1. Create a bot on the WeCom AI Bot platform and obtain the `bot_id` and `bot_secret`.
@@ -658,8 +639,6 @@ This is the difference between a chatbot with tool access and an agent with an a
 
 **Summarization**: Within a session, DeerFlow manages context aggressively — summarizing completed sub-tasks, offloading intermediate results to the filesystem, compressing what's no longer immediately relevant. This lets it stay sharp across long, multi-step tasks without blowing the context window.
 
-**Strict Tool-Call Recovery**: When a provider or middleware interrupts a tool-call loop, DeerFlow now strips provider-level raw tool-call metadata on forced-stop assistant messages and injects placeholder tool results for dangling calls before the next model invocation. This keeps OpenAI-compatible reasoning models that strictly validate `tool_call_id` sequences from failing with malformed history errors.
-
 ### Long-Term Memory
 
 Most agents forget everything the moment a conversation ends. DeerFlow remembers.

README_zh.md

@@ -40,7 +40,6 @@ https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18
   - [快速开始](#快速开始)
     - [配置](#配置)
     - [运行应用](#运行应用)
-      - [部署建议与资源规划](#部署建议与资源规划)
       - [方式一：Docker（推荐）](#方式一docker推荐)
       - [方式二：本地开发](#方式二本地开发)
     - [进阶配置](#进阶配置)
@@ -151,20 +150,6 @@ https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18
 
 ### 运行应用
 
-#### 部署建议与资源规划
-
-可以先按下面的资源档位来选择 DeerFlow 的运行方式：
-
-| 部署场景 | 起步配置 | 推荐配置 | 说明 |
-|---------|-----------|------------|-------|
-| 本地体验 / `make dev` | 4 vCPU、8 GB 内存、20 GB SSD 可用空间 | 8 vCPU、16 GB 内存 | 适合单个开发者或单个轻量会话，且模型走外部 API。`2 核 / 4 GB` 通常跑不稳。 |
-| Docker 开发 / `make docker-start` | 4 vCPU、8 GB 内存、25 GB SSD 可用空间 | 8 vCPU、16 GB 内存 | 镜像构建、源码挂载和 sandbox 容器都会比纯本地模式更吃资源。 |
-| 长期运行服务 / `make up` | 8 vCPU、16 GB 内存、40 GB SSD 可用空间 | 16 vCPU、32 GB 内存 | 更适合共享环境、多 agent 任务、报告生成或更重的 sandbox 负载。 |
-
-- 上面的配置只覆盖 DeerFlow 本身；如果你还要本机部署本地大模型，请单独为模型服务预留资源。
-- 持续运行的服务更推荐使用 Linux + Docker。macOS 和 Windows 更适合作为开发机或体验环境。
-- 如果 CPU 或内存长期打满，先降低并发会话或重任务数量，再考虑升级到更高一档配置。
-
 #### 方式一：Docker（推荐）
 
 **开发模式**（支持热更新，挂载源码）：

backend/CLAUDE.md

@@ -130,7 +130,7 @@ from app.gateway.app import app
 from app.channels.service import start_channel_service
 
 # App → Harness (allowed)
-from deerflow.config.app_config import AppConfig
+from deerflow.config import get_app_config
 
 # Harness → App (FORBIDDEN — enforced by test_harness_boundary.py)
 # from app.gateway.routers.uploads import ...  # ← will fail CI
@@ -156,26 +156,20 @@ from deerflow.config.app_config import AppConfig
 
 ### Middleware Chain
 
-Lead-agent middlewares are assembled in strict append order across `packages/harness/deerflow/agents/middlewares/tool_error_handling_middleware.py` (`build_lead_runtime_middlewares`) and `packages/harness/deerflow/agents/lead_agent/agent.py` (`_build_middlewares`):
+Middlewares execute in strict order in `packages/harness/deerflow/agents/lead_agent/agent.py`:
 
-1. **ThreadDataMiddleware** - Creates per-thread directories under the user's isolation scope (`backend/.deer-flow/users/{user_id}/threads/{thread_id}/user-data/{workspace,uploads,outputs}`); resolves `user_id` via `get_effective_user_id()` (falls back to `"default"` in no-auth mode); Web UI thread deletion now follows LangGraph thread removal with Gateway cleanup of the local thread directory
+1. **ThreadDataMiddleware** - Creates per-thread directories (`backend/.deer-flow/threads/{thread_id}/user-data/{workspace,uploads,outputs}`); Web UI thread deletion now follows LangGraph thread removal with Gateway cleanup of the local `.deer-flow/threads/{thread_id}` directory
 2. **UploadsMiddleware** - Tracks and injects newly uploaded files into conversation
 3. **SandboxMiddleware** - Acquires sandbox, stores `sandbox_id` in state
-4. **DanglingToolCallMiddleware** - Injects placeholder ToolMessages for AIMessage tool_calls that lack responses (e.g., due to user interruption), including raw provider tool-call payloads preserved only in `additional_kwargs["tool_calls"]`
-5. **LLMErrorHandlingMiddleware** - Normalizes provider/model invocation failures into recoverable assistant-facing errors before later middleware/tool stages run
-6. **GuardrailMiddleware** - Pre-tool-call authorization via pluggable `GuardrailProvider` protocol (optional, if `guardrails.enabled` in config). Evaluates each tool call and returns error ToolMessage on deny. Three provider options: built-in `AllowlistProvider` (zero deps), OAP policy providers (e.g. `aport-agent-guardrails`), or custom providers. See [docs/GUARDRAILS.md](docs/GUARDRAILS.md) for setup, usage, and how to implement a provider.
-7. **SandboxAuditMiddleware** - Audits sandboxed shell/file operations for security logging before tool execution continues
-8. **ToolErrorHandlingMiddleware** - Converts tool exceptions into error `ToolMessage`s so the run can continue instead of aborting
-9. **SummarizationMiddleware** - Context reduction when approaching token limits (optional, if enabled)
-10. **TodoListMiddleware** - Task tracking with `write_todos` tool (optional, if plan_mode)
-11. **TokenUsageMiddleware** - Records token usage metrics when token tracking is enabled (optional)
-12. **TitleMiddleware** - Auto-generates thread title after first complete exchange and normalizes structured message content before prompting the title model
-13. **MemoryMiddleware** - Queues conversations for async memory update (filters to user + final AI responses)
-14. **ViewImageMiddleware** - Injects base64 image data before LLM call (conditional on vision support)
-15. **DeferredToolFilterMiddleware** - Hides deferred tool schemas from the bound model until tool search is enabled (optional)
-16. **SubagentLimitMiddleware** - Truncates excess `task` tool calls from model response to enforce `MAX_CONCURRENT_SUBAGENTS` limit (optional, if `subagent_enabled`)
-17. **LoopDetectionMiddleware** - Detects repeated tool-call loops; hard-stop responses clear both structured `tool_calls` and raw provider tool-call metadata before forcing a final text answer
-18. **ClarificationMiddleware** - Intercepts `ask_clarification` tool calls, interrupts via `Command(goto=END)` (must be last)
+4. **DanglingToolCallMiddleware** - Injects placeholder ToolMessages for AIMessage tool_calls that lack responses (e.g., due to user interruption)
+5. **GuardrailMiddleware** - Pre-tool-call authorization via pluggable `GuardrailProvider` protocol (optional, if `guardrails.enabled` in config). Evaluates each tool call and returns error ToolMessage on deny. Three provider options: built-in `AllowlistProvider` (zero deps), OAP policy providers (e.g. `aport-agent-guardrails`), or custom providers. See [docs/GUARDRAILS.md](docs/GUARDRAILS.md) for setup, usage, and how to implement a provider.
+6. **SummarizationMiddleware** - Context reduction when approaching token limits (optional, if enabled)
+7. **TodoListMiddleware** - Task tracking with `write_todos` tool (optional, if plan_mode)
+8. **TitleMiddleware** - Auto-generates thread title after first complete exchange and normalizes structured message content before prompting the title model
+9. **MemoryMiddleware** - Queues conversations for async memory update (filters to user + final AI responses)
+10. **ViewImageMiddleware** - Injects base64 image data before LLM call (conditional on vision support)
+11. **SubagentLimitMiddleware** - Truncates excess `task` tool calls from model response to enforce `MAX_CONCURRENT_SUBAGENTS` limit (optional, if subagent_enabled)
+12. **ClarificationMiddleware** - Intercepts `ask_clarification` tool calls, interrupts via `Command(goto=END)` (must be last)
 
 ### Configuration System
 
@@ -185,16 +179,7 @@ Setup: Copy `config.example.yaml` to `config.yaml` in the **project root** direc
 
 **Config Versioning**: `config.example.yaml` has a `config_version` field. On startup, `AppConfig.from_file()` compares user version vs example version and emits a warning if outdated. Missing `config_version` = version 0. Run `make config-upgrade` to auto-merge missing fields. When changing the config schema, bump `config_version` in `config.example.yaml`.
 
-**Config Lifecycle**: All config models are `frozen=True` (immutable after construction). `AppConfig.from_file()` is a pure function — no side effects, no process-global state. The resolved `AppConfig` is passed as an explicit parameter down every consumer lane:
-
-- **Gateway**: `app.state.config` populated in lifespan; routers receive it via `Depends(get_config)` from `app/gateway/deps.py`.
-- **Client**: `DeerFlowClient._app_config` captured in the constructor; every method reads `self._app_config`.
-- **Agent run**: wrapped in `DeerFlowContext(app_config=…)` and injected via LangGraph `Runtime[DeerFlowContext].context`. Middleware and tools read `runtime.context.app_config` directly or via `resolve_context(runtime)`.
-- **LangGraph Server bootstrap**: `make_lead_agent` (registered in `langgraph.json`) calls `AppConfig.from_file()` itself — the only place in production that loads from disk at agent-build time.
-
-To update config at runtime (Gateway API mutations for MCP/Skills), write the new file and call `AppConfig.from_file()` to build a fresh snapshot, then swap `app.state.config`. No mtime detection, no auto-reload, no ambient ContextVar lookup (`AppConfig.current()` has been removed).
-
-**DeerFlowContext**: Per-invocation typed context for the agent execution path, injected via LangGraph `Runtime[DeerFlowContext]`. Holds `app_config: AppConfig`, `thread_id: str`, `agent_name: str | None`. Gateway runtime and `DeerFlowClient` construct full `DeerFlowContext` at invoke time; the LangGraph Server boundary builds one inside `make_lead_agent`. Middleware and tools access context through `resolve_context(runtime)` which returns the typed `DeerFlowContext` — legacy dict/None shapes are rejected. Mutable runtime state (`sandbox_id`) flows through `ThreadState.sandbox`, not context.
+**Config Caching**: `get_app_config()` caches the parsed config, but automatically reloads it when the resolved config path changes or the file's mtime increases. This keeps Gateway and LangGraph reads aligned with `config.yaml` edits without requiring a manual process restart.
 
 Configuration priority:
 1. Explicit `config_path` argument
@@ -231,9 +216,6 @@ FastAPI application on port 8001 with health check at `GET /health`.
 | **Threads** (`/api/threads/{id}`) | `DELETE /` - remove DeerFlow-managed local thread data after LangGraph thread deletion; unexpected failures are logged server-side and return a generic 500 detail |
 | **Artifacts** (`/api/threads/{id}/artifacts`) | `GET /{path}` - serve artifacts; active content types (`text/html`, `application/xhtml+xml`, `image/svg+xml`) are always forced as download attachments to reduce XSS risk; `?download=true` still forces download for other file types |
 | **Suggestions** (`/api/threads/{id}/suggestions`) | `POST /` - generate follow-up questions; rich list/block model content is normalized before JSON parsing |
-| **Thread Runs** (`/api/threads/{id}/runs`) | `POST /` - create background run; `POST /stream` - create + SSE stream; `POST /wait` - create + block; `GET /` - list runs; `GET /{rid}` - run details; `POST /{rid}/cancel` - cancel; `GET /{rid}/join` - join SSE; `GET /{rid}/messages` - paginated messages `{data, has_more}`; `GET /{rid}/events` - full event stream; `GET /../messages` - thread messages with feedback; `GET /../token-usage` - aggregate tokens |
-| **Feedback** (`/api/threads/{id}/runs/{rid}/feedback`) | `PUT /` - upsert feedback; `DELETE /` - delete user feedback; `POST /` - create feedback; `GET /` - list feedback; `GET /stats` - aggregate stats; `DELETE /{fid}` - delete specific |
-| **Runs** (`/api/runs`) | `POST /stream` - stateless run + SSE; `POST /wait` - stateless run + block; `GET /{rid}/messages` - paginated messages by run_id `{data, has_more}` (cursor: `after_seq`/`before_seq`); `GET /{rid}/feedback` - list feedback by run_id |
 
 Proxied through nginx: `/api/langgraph/*` → LangGraph, all other `/api/*` → Gateway.
 
@@ -247,7 +229,7 @@ Proxied through nginx: `/api/langgraph/*` → LangGraph, all other `/api/*` →
 
 **Virtual Path System**:
 - Agent sees: `/mnt/user-data/{workspace,uploads,outputs}`, `/mnt/skills`
-- Physical: `backend/.deer-flow/users/{user_id}/threads/{thread_id}/user-data/...`, `deer-flow/skills/`
+- Physical: `backend/.deer-flow/threads/{thread_id}/user-data/...`, `deer-flow/skills/`
 - Translation: `replace_virtual_path()` / `replace_virtual_paths_in_command()`
 - Detection: `is_local_sandbox()` checks `sandbox_id == "local"`
 
@@ -287,7 +269,7 @@ Proxied through nginx: `/api/langgraph/*` → LangGraph, all other `/api/*` →
 - `invoke_acp_agent` - Invokes external ACP-compatible agents from `config.yaml`
 - ACP launchers must be real ACP adapters. The standard `codex` CLI is not ACP-compatible by itself; configure a wrapper such as `npx -y @zed-industries/codex-acp` or an installed `codex-acp` binary
 - Missing ACP executables now return an actionable error message instead of a raw `[Errno 2]`
-- Each ACP agent uses a per-thread workspace at `{base_dir}/users/{user_id}/threads/{thread_id}/acp-workspace/`. The workspace is accessible to the lead agent via the virtual path `/mnt/acp-workspace/` (read-only). In docker sandbox mode, the directory is volume-mounted into the container at `/mnt/acp-workspace` (read-only); in local sandbox mode, path translation is handled by `tools.py`
+- Each ACP agent uses a per-thread workspace at `{base_dir}/threads/{thread_id}/acp-workspace/`. The workspace is accessible to the lead agent via the virtual path `/mnt/acp-workspace/` (read-only). In docker sandbox mode, the directory is volume-mounted into the container at `/mnt/acp-workspace` (read-only); in local sandbox mode, path translation is handled by `tools.py`
 - `image_search/` - Image search via DuckDuckGo
 
 ### MCP System (`packages/harness/deerflow/mcp/`)
@@ -356,27 +338,18 @@ Bridges external messaging platforms (Feishu, Slack, Telegram) to the DeerFlow a
 
 **Components**:
 - `updater.py` - LLM-based memory updates with fact extraction, whitespace-normalized fact deduplication (trims leading/trailing whitespace before comparing), and atomic file I/O
-- `queue.py` - Debounced update queue (per-thread deduplication, configurable wait time); captures `user_id` at enqueue time so it survives the `threading.Timer` boundary
+- `queue.py` - Debounced update queue (per-thread deduplication, configurable wait time)
 - `prompt.py` - Prompt templates for memory updates
-- `storage.py` - File-based storage with per-user isolation; cache keyed by `(user_id, agent_name)` tuple
 
-**Per-User Isolation**:
-- Memory is stored per-user at `{base_dir}/users/{user_id}/memory.json`
-- Per-agent per-user memory at `{base_dir}/users/{user_id}/agents/{agent_name}/memory.json`
-- `user_id` is resolved via `get_effective_user_id()` from `deerflow.runtime.user_context`
-- In no-auth mode, `user_id` defaults to `"default"` (constant `DEFAULT_USER_ID`)
-- Absolute `storage_path` in config opts out of per-user isolation
-- **Migration**: Run `PYTHONPATH=. python scripts/migrate_user_isolation.py` to move legacy `memory.json` and `threads/` into per-user layout; supports `--dry-run`
-
-**Data Structure** (stored in `{base_dir}/users/{user_id}/memory.json`):
+**Data Structure** (stored in `backend/.deer-flow/memory.json`):
 - **User Context**: `workContext`, `personalContext`, `topOfMind` (1-3 sentence summaries)
 - **History**: `recentMonths`, `earlierContext`, `longTermBackground`
 - **Facts**: Discrete facts with `id`, `content`, `category` (preference/knowledge/context/behavior/goal), `confidence` (0-1), `createdAt`, `source`
 
 **Workflow**:
-1. `MemoryMiddleware` filters messages (user inputs + final AI responses), captures `user_id` via `get_effective_user_id()`, and queues conversation with the captured `user_id`
+1. `MemoryMiddleware` filters messages (user inputs + final AI responses) and queues conversation
 2. Queue debounces (30s default), batches updates, deduplicates per-thread
-3. Background thread invokes LLM to extract context updates and facts, using the stored `user_id` (not the contextvar, which is unavailable on timer threads)
+3. Background thread invokes LLM to extract context updates and facts
 4. Applies updates atomically (temp file + rename) with cache invalidation, skipping duplicate fact content before append
 5. Next interaction injects top 15 facts + context into `<memory>` tags in system prompt
 
@@ -384,7 +357,7 @@ Focused regression coverage for the updater lives in `backend/tests/test_memory_
 
 **Configuration** (`config.yaml` → `memory`):
 - `enabled` / `injection_enabled` - Master switches
-- `storage_path` - Path to memory.json (absolute path opts out of per-user isolation)
+- `storage_path` - Path to memory.json
 - `debounce_seconds` - Wait time before processing (default: 30)
 - `model_name` - LLM for updates (null = default model)
 - `max_facts` / `fact_confidence_threshold` - Fact storage limits (100 / 0.7)
@@ -422,16 +395,14 @@ Both can be modified at runtime via Gateway API endpoints or `DeerFlowClient` me
 **Architecture**: Imports the same `deerflow` modules that LangGraph Server and Gateway API use. Shares the same config files and data directories. No FastAPI dependency.
 
 **Agent Conversation** (replaces LangGraph Server):
-- `chat(message, thread_id)` — synchronous, accumulates streaming deltas per message-id and returns the final AI text
-- `stream(message, thread_id)` — subscribes to LangGraph `stream_mode=["values", "messages", "custom"]` and yields `StreamEvent`:
-  - `"values"` — full state snapshot (title, messages, artifacts); AI text already delivered via `messages` mode is **not** re-synthesized here to avoid duplicate deliveries
-  - `"messages-tuple"` — per-chunk update: for AI text this is a **delta** (concat per `id` to rebuild the full message); tool calls and tool results are emitted once each
-  - `"custom"` — forwarded from `StreamWriter`
-  - `"end"` — stream finished (carries cumulative `usage` counted once per message id)
+- `chat(message, thread_id)` — synchronous, returns final text
+- `stream(message, thread_id)` — yields `StreamEvent` aligned with LangGraph SSE protocol:
+  - `"values"` — full state snapshot (title, messages, artifacts)
+  - `"messages-tuple"` — per-message update (AI text, tool calls, tool results)
+  - `"end"` — stream finished
 - Agent created lazily via `create_agent()` + `_build_middlewares()`, same as `make_lead_agent`
 - Supports `checkpointer` parameter for state persistence across turns
 - `reset_agent()` forces agent recreation (e.g. after memory or skill changes)
-- See [docs/STREAMING.md](docs/STREAMING.md) for the full design: why Gateway and DeerFlowClient are parallel paths, LangGraph's `stream_mode` semantics, the per-id dedup invariants, and regression testing strategy
 
 **Gateway Equivalent Methods** (replaces Gateway API):
 

backend/Dockerfile

@@ -88,4 +88,4 @@ COPY --from=builder /app/backend ./backend
 EXPOSE 8001 2024
 
 # Default command (can be overridden in docker-compose)
-CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run --no-sync uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]
+CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]

backend/app/channels/discord.py

@@ -1,273 +0,0 @@
-"""Discord channel integration using discord.py."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import threading
-from typing import Any
-
-from app.channels.base import Channel
-from app.channels.message_bus import InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
-
-logger = logging.getLogger(__name__)
-
-_DISCORD_MAX_MESSAGE_LEN = 2000
-
-
-class DiscordChannel(Channel):
-    """Discord bot channel.
-
-    Configuration keys (in ``config.yaml`` under ``channels.discord``):
-        - ``bot_token``: Discord Bot token.
-        - ``allowed_guilds``: (optional) List of allowed Discord guild IDs. Empty = allow all.
-    """
-
-    def __init__(self, bus: MessageBus, config: dict[str, Any]) -> None:
-        super().__init__(name="discord", bus=bus, config=config)
-        self._bot_token = str(config.get("bot_token", "")).strip()
-        self._allowed_guilds: set[int] = set()
-        for guild_id in config.get("allowed_guilds", []):
-            try:
-                self._allowed_guilds.add(int(guild_id))
-            except (TypeError, ValueError):
-                continue
-
-        self._client = None
-        self._thread: threading.Thread | None = None
-        self._discord_loop: asyncio.AbstractEventLoop | None = None
-        self._main_loop: asyncio.AbstractEventLoop | None = None
-        self._discord_module = None
-
-    async def start(self) -> None:
-        if self._running:
-            return
-
-        try:
-            import discord
-        except ImportError:
-            logger.error("discord.py is not installed. Install it with: uv add discord.py")
-            return
-
-        if not self._bot_token:
-            logger.error("Discord channel requires bot_token")
-            return
-
-        intents = discord.Intents.default()
-        intents.messages = True
-        intents.guilds = True
-        intents.message_content = True
-
-        client = discord.Client(
-            intents=intents,
-            allowed_mentions=discord.AllowedMentions.none(),
-        )
-        self._client = client
-        self._discord_module = discord
-        self._main_loop = asyncio.get_event_loop()
-
-        @client.event
-        async def on_message(message) -> None:
-            await self._on_message(message)
-
-        self._running = True
-        self.bus.subscribe_outbound(self._on_outbound)
-
-        self._thread = threading.Thread(target=self._run_client, daemon=True)
-        self._thread.start()
-        logger.info("Discord channel started")
-
-    async def stop(self) -> None:
-        self._running = False
-        self.bus.unsubscribe_outbound(self._on_outbound)
-
-        if self._client and self._discord_loop and self._discord_loop.is_running():
-            close_future = asyncio.run_coroutine_threadsafe(self._client.close(), self._discord_loop)
-            try:
-                await asyncio.wait_for(asyncio.wrap_future(close_future), timeout=10)
-            except TimeoutError:
-                logger.warning("[Discord] client close timed out after 10s")
-            except Exception:
-                logger.exception("[Discord] error while closing client")
-
-        if self._thread:
-            self._thread.join(timeout=10)
-            self._thread = None
-
-        self._client = None
-        self._discord_loop = None
-        self._discord_module = None
-        logger.info("Discord channel stopped")
-
-    async def send(self, msg: OutboundMessage) -> None:
-        target = await self._resolve_target(msg)
-        if target is None:
-            logger.error("[Discord] target not found for chat_id=%s thread_ts=%s", msg.chat_id, msg.thread_ts)
-            return
-
-        text = msg.text or ""
-        for chunk in self._split_text(text):
-            send_future = asyncio.run_coroutine_threadsafe(target.send(chunk), self._discord_loop)
-            await asyncio.wrap_future(send_future)
-
-    async def send_file(self, msg: OutboundMessage, attachment: ResolvedAttachment) -> bool:
-        target = await self._resolve_target(msg)
-        if target is None:
-            logger.error("[Discord] target not found for file upload chat_id=%s thread_ts=%s", msg.chat_id, msg.thread_ts)
-            return False
-
-        if self._discord_module is None:
-            return False
-
-        try:
-            fp = open(str(attachment.actual_path), "rb")  # noqa: SIM115
-            file = self._discord_module.File(fp, filename=attachment.filename)
-            send_future = asyncio.run_coroutine_threadsafe(target.send(file=file), self._discord_loop)
-            await asyncio.wrap_future(send_future)
-            logger.info("[Discord] file uploaded: %s", attachment.filename)
-            return True
-        except Exception:
-            logger.exception("[Discord] failed to upload file: %s", attachment.filename)
-            return False
-
-    async def _on_message(self, message) -> None:
-        if not self._running or not self._client:
-            return
-
-        if message.author.bot:
-            return
-
-        if self._client.user and message.author.id == self._client.user.id:
-            return
-
-        guild = message.guild
-        if self._allowed_guilds:
-            if guild is None or guild.id not in self._allowed_guilds:
-                return
-
-        text = (message.content or "").strip()
-        if not text:
-            return
-
-        if self._discord_module is None:
-            return
-
-        if isinstance(message.channel, self._discord_module.Thread):
-            chat_id = str(message.channel.parent_id or message.channel.id)
-            thread_id = str(message.channel.id)
-        else:
-            thread = await self._create_thread(message)
-            if thread is None:
-                return
-            chat_id = str(message.channel.id)
-            thread_id = str(thread.id)
-
-        msg_type = InboundMessageType.COMMAND if text.startswith("/") else InboundMessageType.CHAT
-        inbound = self._make_inbound(
-            chat_id=chat_id,
-            user_id=str(message.author.id),
-            text=text,
-            msg_type=msg_type,
-            thread_ts=thread_id,
-            metadata={
-                "guild_id": str(guild.id) if guild else None,
-                "channel_id": str(message.channel.id),
-                "message_id": str(message.id),
-            },
-        )
-        inbound.topic_id = thread_id
-
-        if self._main_loop and self._main_loop.is_running():
-            future = asyncio.run_coroutine_threadsafe(self.bus.publish_inbound(inbound), self._main_loop)
-            future.add_done_callback(lambda f: logger.exception("[Discord] publish_inbound failed", exc_info=f.exception()) if f.exception() else None)
-
-    def _run_client(self) -> None:
-        self._discord_loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self._discord_loop)
-        try:
-            self._discord_loop.run_until_complete(self._client.start(self._bot_token))
-        except Exception:
-            if self._running:
-                logger.exception("Discord client error")
-        finally:
-            try:
-                if self._client and not self._client.is_closed():
-                    self._discord_loop.run_until_complete(self._client.close())
-            except Exception:
-                logger.exception("Error during Discord shutdown")
-
-    async def _create_thread(self, message):
-        try:
-            thread_name = f"deerflow-{message.author.display_name}-{message.id}"[:100]
-            return await message.create_thread(name=thread_name)
-        except Exception:
-            logger.exception("[Discord] failed to create thread for message=%s (threads may be disabled or missing permissions)", message.id)
-            try:
-                await message.channel.send("Could not create a thread for your message. Please check that threads are enabled in this channel.")
-            except Exception:
-                pass
-            return None
-
-    async def _resolve_target(self, msg: OutboundMessage):
-        if not self._client or not self._discord_loop:
-            return None
-
-        target_ids: list[str] = []
-        if msg.thread_ts:
-            target_ids.append(msg.thread_ts)
-        if msg.chat_id and msg.chat_id not in target_ids:
-            target_ids.append(msg.chat_id)
-
-        for raw_id in target_ids:
-            target = await self._get_channel_or_thread(raw_id)
-            if target is not None:
-                return target
-        return None
-
-    async def _get_channel_or_thread(self, raw_id: str):
-        if not self._client or not self._discord_loop:
-            return None
-
-        try:
-            target_id = int(raw_id)
-        except (TypeError, ValueError):
-            return None
-
-        get_future = asyncio.run_coroutine_threadsafe(self._fetch_channel(target_id), self._discord_loop)
-        try:
-            return await asyncio.wrap_future(get_future)
-        except Exception:
-            logger.exception("[Discord] failed to resolve target id=%s", raw_id)
-            return None
-
-    async def _fetch_channel(self, target_id: int):
-        if not self._client:
-            return None
-
-        channel = self._client.get_channel(target_id)
-        if channel is not None:
-            return channel
-
-        try:
-            return await self._client.fetch_channel(target_id)
-        except Exception:
-            return None
-
-    @staticmethod
-    def _split_text(text: str) -> list[str]:
-        if not text:
-            return [""]
-
-        chunks: list[str] = []
-        remaining = text
-        while len(remaining) > _DISCORD_MAX_MESSAGE_LEN:
-            split_at = remaining.rfind("\n", 0, _DISCORD_MAX_MESSAGE_LEN)
-            if split_at <= 0:
-                split_at = _DISCORD_MAX_MESSAGE_LEN
-            chunks.append(remaining[:split_at])
-            remaining = remaining[split_at:].lstrip("\n")
-
-        if remaining:
-            chunks.append(remaining)
-
-        return chunks

backend/app/channels/feishu.py

@@ -13,7 +13,6 @@ from app.channels.base import Channel
 from app.channels.commands import KNOWN_CHANNEL_COMMANDS
 from app.channels.message_bus import InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
 from deerflow.config.paths import VIRTUAL_PATH_PREFIX, get_paths
-from deerflow.runtime.user_context import get_effective_user_id
 from deerflow.sandbox.sandbox_provider import get_sandbox_provider
 
 logger = logging.getLogger(__name__)
@@ -345,9 +344,8 @@ class FeishuChannel(Channel):
             return f"Failed to obtain the [{type}]"
 
         paths = get_paths()
-        user_id = get_effective_user_id()
-        paths.ensure_thread_dirs(thread_id, user_id=user_id)
-        uploads_dir = paths.sandbox_uploads_dir(thread_id, user_id=user_id).resolve()
+        paths.ensure_thread_dirs(thread_id)
+        uploads_dir = paths.sandbox_uploads_dir(thread_id).resolve()
 
         ext = "png" if type == "image" else "bin"
         raw_filename = getattr(response, "file_name", "") or f"feishu_{file_key[-12:]}.{ext}"
@@ -375,9 +373,7 @@ class FeishuChannel(Channel):
         virtual_path = f"{VIRTUAL_PATH_PREFIX}/uploads/{resolved_target.name}"
 
         try:
-            from deerflow.config.app_config import AppConfig
-
-            sandbox_provider = get_sandbox_provider(AppConfig.from_file())
+            sandbox_provider = get_sandbox_provider()
             sandbox_id = sandbox_provider.acquire(thread_id)
             if sandbox_id != "local":
                 sandbox = sandbox_provider.get(sandbox_id)

backend/app/channels/manager.py

@@ -8,7 +8,6 @@ import mimetypes
 import re
 import time
 from collections.abc import Awaitable, Callable, Mapping
-from pathlib import Path
 from typing import Any
 
 import httpx
@@ -17,7 +16,6 @@ from langgraph_sdk.errors import ConflictError
 from app.channels.commands import KNOWN_CHANNEL_COMMANDS
 from app.channels.message_bus import InboundMessage, InboundMessageType, MessageBus, OutboundMessage, ResolvedAttachment
 from app.channels.store import ChannelStore
-from deerflow.runtime.user_context import get_effective_user_id
 
 logger = logging.getLogger(__name__)
 
@@ -36,11 +34,9 @@ STREAM_UPDATE_MIN_INTERVAL_SECONDS = 0.35
 THREAD_BUSY_MESSAGE = "This conversation is already processing another request. Please wait for it to finish and try again."
 
 CHANNEL_CAPABILITIES = {
-    "discord": {"supports_streaming": False},
     "feishu": {"supports_streaming": True},
     "slack": {"supports_streaming": False},
     "telegram": {"supports_streaming": False},
-    "wechat": {"supports_streaming": False},
     "wecom": {"supports_streaming": True},
 }
 
@@ -82,24 +78,7 @@ async def _read_wecom_inbound_file(file_info: dict[str, Any], client: httpx.Asyn
     return decrypt_file(data, aeskey)
 
 
-async def _read_wechat_inbound_file(file_info: dict[str, Any], client: httpx.AsyncClient) -> bytes | None:
-    raw_path = file_info.get("path")
-    if isinstance(raw_path, str) and raw_path.strip():
-        try:
-            return await asyncio.to_thread(Path(raw_path).read_bytes)
-        except OSError:
-            logger.exception("[Manager] failed to read WeChat inbound file from local path: %s", raw_path)
-            return None
-
-    full_url = file_info.get("full_url")
-    if isinstance(full_url, str) and full_url.strip():
-        return await _read_http_inbound_file({"url": full_url}, client)
-
-    return None
-
-
 register_inbound_file_reader("wecom", _read_wecom_inbound_file)
-register_inbound_file_reader("wechat", _read_wechat_inbound_file)
 
 
 class InvalidChannelSessionConfigError(ValueError):
@@ -343,15 +322,14 @@ def _resolve_attachments(thread_id: str, artifacts: list[str]) -> list[ResolvedA
 
     attachments: list[ResolvedAttachment] = []
     paths = get_paths()
-    user_id = get_effective_user_id()
-    outputs_dir = paths.sandbox_outputs_dir(thread_id, user_id=user_id).resolve()
+    outputs_dir = paths.sandbox_outputs_dir(thread_id).resolve()
     for virtual_path in artifacts:
         # Security: only allow files from the agent outputs directory
         if not virtual_path.startswith(_OUTPUTS_VIRTUAL_PREFIX):
             logger.warning("[Manager] rejected non-outputs artifact path: %s", virtual_path)
             continue
         try:
-            actual = paths.resolve_virtual_path(thread_id, virtual_path, user_id=user_id)
+            actual = paths.resolve_virtual_path(thread_id, virtual_path)
             # Verify the resolved path is actually under the outputs directory
             # (guards against path-traversal even after prefix check)
             try:

backend/app/channels/service.py

@@ -4,38 +4,23 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from app.channels.base import Channel
 from app.channels.manager import DEFAULT_GATEWAY_URL, DEFAULT_LANGGRAPH_URL, ChannelManager
 from app.channels.message_bus import MessageBus
 from app.channels.store import ChannelStore
 
-if TYPE_CHECKING:
-    from deerflow.config.app_config import AppConfig
-
 logger = logging.getLogger(__name__)
 
 # Channel name → import path for lazy loading
 _CHANNEL_REGISTRY: dict[str, str] = {
-    "discord": "app.channels.discord:DiscordChannel",
     "feishu": "app.channels.feishu:FeishuChannel",
     "slack": "app.channels.slack:SlackChannel",
     "telegram": "app.channels.telegram:TelegramChannel",
-    "wechat": "app.channels.wechat:WechatChannel",
     "wecom": "app.channels.wecom:WeComChannel",
 }
 
-# Keys that indicate a user has configured credentials for a channel.
-_CHANNEL_CREDENTIAL_KEYS: dict[str, list[str]] = {
-    "discord": ["bot_token"],
-    "feishu": ["app_id", "app_secret"],
-    "slack": ["bot_token", "app_token"],
-    "telegram": ["bot_token"],
-    "wecom": ["bot_id", "bot_secret"],
-    "wechat": ["bot_token"],
-}
-
 _CHANNELS_LANGGRAPH_URL_ENV = "DEER_FLOW_CHANNELS_LANGGRAPH_URL"
 _CHANNELS_GATEWAY_URL_ENV = "DEER_FLOW_CHANNELS_GATEWAY_URL"
 
@@ -78,11 +63,14 @@ class ChannelService:
         self._running = False
 
     @classmethod
-    def from_app_config(cls, app_config: AppConfig) -> ChannelService:
-        """Create a ChannelService from an explicit application config."""
+    def from_app_config(cls) -> ChannelService:
+        """Create a ChannelService from the application config."""
+        from deerflow.config.app_config import get_app_config
+
+        config = get_app_config()
         channels_config = {}
         # extra fields are allowed by AppConfig (extra="allow")
-        extra = app_config.model_extra or {}
+        extra = config.model_extra or {}
         if "channels" in extra:
             channels_config = extra["channels"]
         return cls(channels_config=channels_config)
@@ -98,16 +86,7 @@ class ChannelService:
             if not isinstance(channel_config, dict):
                 continue
             if not channel_config.get("enabled", False):
-                cred_keys = _CHANNEL_CREDENTIAL_KEYS.get(name, [])
-                has_creds = any(not isinstance(channel_config.get(k), bool) and channel_config.get(k) is not None and str(channel_config[k]).strip() for k in cred_keys)
-                if has_creds:
-                    logger.warning(
-                        "Channel '%s' has credentials configured but is disabled. Set enabled: true under channels.%s in config.yaml to activate it.",
-                        name,
-                        name,
-                    )
-                else:
-                    logger.info("Channel %s is disabled, skipping", name)
+                logger.info("Channel %s is disabled, skipping", name)
                 continue
 
             await self._start_channel(name, channel_config)
@@ -201,12 +180,12 @@ def get_channel_service() -> ChannelService | None:
     return _channel_service
 
 
-async def start_channel_service(app_config: AppConfig) -> ChannelService:
+async def start_channel_service() -> ChannelService:
     """Create and start the global ChannelService from app config."""
     global _channel_service
     if _channel_service is not None:
         return _channel_service
-    _channel_service = ChannelService.from_app_config(app_config)
+    _channel_service = ChannelService.from_app_config()
     await _channel_service.start()
     return _channel_service
 

backend/app/channels/slack.py

@@ -16,31 +16,13 @@ logger = logging.getLogger(__name__)
 _slack_md_converter = SlackMarkdownConverter()
 
 
-def _normalize_allowed_users(allowed_users: Any) -> set[str]:
-    if allowed_users is None:
-        return set()
-    if isinstance(allowed_users, str):
-        values = [allowed_users]
-    elif isinstance(allowed_users, list | tuple | set):
-        values = allowed_users
-    else:
-        logger.warning(
-            "Slack allowed_users should be a list of Slack user IDs or a single Slack user ID string; treating %s as one string value",
-            type(allowed_users).__name__,
-        )
-        values = [allowed_users]
-    return {str(user_id) for user_id in values if str(user_id)}
-
-
 class SlackChannel(Channel):
     """Slack IM channel using Socket Mode (WebSocket, no public IP).
 
     Configuration keys (in ``config.yaml`` under ``channels.slack``):
         - ``bot_token``: Slack Bot User OAuth Token (xoxb-...).
         - ``app_token``: Slack App-Level Token (xapp-...) for Socket Mode.
-        - ``allowed_users``: (optional) List of allowed Slack user IDs, or a
-          single Slack user ID string as shorthand. Empty = allow all. Other
-          scalar values are treated as a single string with a warning.
+        - ``allowed_users``: (optional) List of allowed Slack user IDs. Empty = allow all.
     """
 
     def __init__(self, bus: MessageBus, config: dict[str, Any]) -> None:
@@ -48,7 +30,7 @@ class SlackChannel(Channel):
         self._socket_client = None
         self._web_client = None
         self._loop: asyncio.AbstractEventLoop | None = None
-        self._allowed_users = _normalize_allowed_users(config.get("allowed_users", []))
+        self._allowed_users: set[str] = {str(user_id) for user_id in config.get("allowed_users", [])}
 
     async def start(self) -> None:
         if self._running:

backend/app/gateway/app.py

@@ -1,8 +1,8 @@
-import asyncio
 import logging
 import os
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
+from datetime import UTC
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -28,7 +28,7 @@ from app.gateway.routers import (
     threads,
     uploads,
 )
-from deerflow.config.app_config import AppConfig
+from deerflow.config.app_config import get_app_config
 
 # Configure logging
 logging.basicConfig(
@@ -39,67 +39,77 @@ logging.basicConfig(
 
 logger = logging.getLogger(__name__)
 
-# Upper bound (seconds) each lifespan shutdown hook is allowed to run.
-# Bounds worker exit time so uvicorn's reload supervisor does not keep
-# firing signals into a worker that is stuck waiting for shutdown cleanup.
-_SHUTDOWN_HOOK_TIMEOUT_SECONDS = 5.0
-
 
 async def _ensure_admin_user(app: FastAPI) -> None:
-    """Startup hook: handle first boot and migrate orphan threads otherwise.
+    """Auto-create the admin user on first boot if no users exist.
 
     After admin creation, migrate orphan threads from the LangGraph
-    store (metadata.user_id unset) to the admin account. This is the
+    store (metadata.owner_id unset) to the admin account. This is the
     "no-auth → with-auth" upgrade path: users who ran DeerFlow without
     authentication have existing LangGraph thread data that needs an
     owner assigned.
-        First boot (no admin exists):
-            - Does NOT create any user accounts automatically.
-            - The operator must visit ``/setup`` to create the first admin.
 
-    Subsequent boots (admin already exists):
-      - Runs the one-time "no-auth → with-auth" orphan thread migration for
-        existing LangGraph thread metadata that has no owner_id.
-
-    No SQL persistence migration is needed: the four user_id columns
+    No SQL persistence migration is needed: the four owner_id columns
     (threads_meta, runs, run_events, feedback) only come into existence
     alongside the auth module via create_all, so freshly created tables
-    never contain NULL-owner rows.
+    never contain NULL-owner rows. "Existing persistence DB + new auth"
+    is not a supported upgrade path — fresh install or wipe-and-retry.
+
+    Multi-worker safe: relies on SQLite UNIQUE constraint to resolve
+    races during admin creation. Only the worker that successfully
+    creates/updates the admin prints the password; losers silently skip.
     """
-    from sqlalchemy import select
+    import secrets
 
     from app.gateway.deps import get_local_provider
-    from deerflow.persistence.engine import get_session_factory
-    from deerflow.persistence.user.model import UserRow
 
     provider = get_local_provider()
-    admin_count = await provider.count_admin_users()
+    user_count = await provider.count_users()
 
-    if admin_count == 0:
-        logger.info("=" * 60)
-        logger.info("  First boot detected — no admin account exists.")
-        logger.info("  Visit /setup to complete admin account creation.")
-        logger.info("=" * 60)
-        return
+    admin = None
+    fresh_admin_created = False
 
-    # Admin already exists — run orphan thread migration for any
-    # LangGraph thread metadata that pre-dates the auth module.
-    sf = get_session_factory()
-    if sf is None:
-        return
+    if user_count == 0:
+        password = secrets.token_urlsafe(16)
+        try:
+            admin = await provider.create_user(email="admin@deerflow.dev", password=password, system_role="admin", needs_setup=True)
+            fresh_admin_created = True
+        except ValueError:
+            return  # Another worker already created the admin.
+    else:
+        # Admin exists but setup never completed — reset password so operator
+        # can always find it in the console without needing the CLI.
+        # Multi-worker guard: if admin was created less than 30s ago, another
+        # worker just created it and will print the password — skip reset.
+        admin = await provider.get_user_by_email("admin@deerflow.dev")
+        if admin and admin.needs_setup:
+            import time
 
-    async with sf() as session:
-        stmt = select(UserRow).where(UserRow.system_role == "admin").limit(1)
-        row = (await session.execute(stmt)).scalar_one_or_none()
+            age = time.time() - admin.created_at.replace(tzinfo=UTC).timestamp()
+            if age >= 30:
+                from app.gateway.auth.credential_file import write_initial_credentials
+                from app.gateway.auth.password import hash_password_async
 
-    if row is None:
-        return  # Should not happen (admin_count > 0 above), but be safe.
+                password = secrets.token_urlsafe(16)
+                admin.password_hash = await hash_password_async(password)
+                admin.token_version += 1
+                await provider.update_user(admin)
 
-    admin_id = str(row.id)
+                cred_path = write_initial_credentials(admin.email, password, label="reset")
+                logger.info("=" * 60)
+                logger.info("  Admin account setup incomplete — password reset")
+                logger.info("  Credentials written to: %s (mode 0600)", cred_path)
+                logger.info("  Change it after login: Settings -> Account")
+                logger.info("=" * 60)
+
+    if admin is None:
+        return  # Nothing to bind orphans to.
+
+    admin_id = str(admin.id)
 
     # LangGraph store orphan migration — non-fatal.
     # This covers the "no-auth → with-auth" upgrade path for users
-    # whose existing LangGraph thread metadata has no user_id set.
+    # whose existing LangGraph thread metadata has no owner_id set.
     store = getattr(app.state, "store", None)
     if store is not None:
         try:
@@ -109,6 +119,16 @@ async def _ensure_admin_user(app: FastAPI) -> None:
         except Exception:
             logger.exception("LangGraph thread migration failed (non-fatal)")
 
+    if fresh_admin_created:
+        from app.gateway.auth.credential_file import write_initial_credentials
+
+        cred_path = write_initial_credentials(admin.email, password, label="initial")  # noqa: F821 — defined in the fresh_admin branch
+        logger.info("=" * 60)
+        logger.info("  Admin account created on first boot")
+        logger.info("  Credentials written to: %s (mode 0600)", cred_path)
+        logger.info("  Change it after login: Settings -> Account")
+        logger.info("=" * 60)
+
 
 async def _iter_store_items(store, namespace, *, page_size: int = 500):
     """Paginated async iterator over a LangGraph store namespace.
@@ -131,7 +151,7 @@ async def _iter_store_items(store, namespace, *, page_size: int = 500):
 
 
 async def _migrate_orphaned_threads(store, admin_user_id: str) -> int:
-    """Migrate LangGraph store threads with no user_id to the given admin.
+    """Migrate LangGraph store threads with no owner_id to the given admin.
 
     Uses cursor pagination so all orphans are migrated regardless of
     count. Returns the number of rows migrated.
@@ -139,8 +159,8 @@ async def _migrate_orphaned_threads(store, admin_user_id: str) -> int:
     migrated = 0
     async for item in _iter_store_items(store, ("threads",)):
         metadata = item.value.get("metadata", {})
-        if not metadata.get("user_id"):
-            metadata["user_id"] = admin_user_id
+        if not metadata.get("owner_id"):
+            metadata["owner_id"] = admin_user_id
             item.value["metadata"] = metadata
             await store.aput(("threads",), item.key, item.value)
             migrated += 1
@@ -151,11 +171,9 @@ async def _migrate_orphaned_threads(store, admin_user_id: str) -> int:
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """Application lifespan handler."""
 
+    # Load config and check necessary environment variables at startup
     try:
-        # ``app.state.config`` is the sole source of truth for
-        # ``Depends(get_config)``. Consumers that want AppConfig must receive
-        # it as an explicit parameter; there is no ambient singleton.
-        app.state.config = AppConfig.from_file()
+        get_app_config()
         logger.info("Configuration loaded successfully")
     except Exception as e:
         error_msg = f"Failed to load configuration during gateway startup: {e}"
@@ -176,26 +194,18 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
         try:
             from app.channels.service import start_channel_service
 
-            channel_service = await start_channel_service(app.state.config)
+            channel_service = await start_channel_service()
             logger.info("Channel service started: %s", channel_service.get_status())
         except Exception:
             logger.exception("No IM channels configured or channel service failed to start")
 
         yield
 
-        # Stop channel service on shutdown (bounded to prevent worker hang)
+        # Stop channel service on shutdown
         try:
             from app.channels.service import stop_channel_service
 
-            await asyncio.wait_for(
-                stop_channel_service(),
-                timeout=_SHUTDOWN_HOOK_TIMEOUT_SECONDS,
-            )
-        except TimeoutError:
-            logger.warning(
-                "Channel service shutdown exceeded %.1fs; proceeding with worker exit.",
-                _SHUTDOWN_HOOK_TIMEOUT_SECONDS,
-            )
+            await stop_channel_service()
         except Exception:
             logger.exception("Failed to stop channel service")
 

backend/app/gateway/auth/credential_file.py

@@ -13,36 +13,26 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-from deerflow.config.paths import get_paths
-
-_CREDENTIAL_FILENAME = "admin_initial_credentials.txt"
+_CREDENTIAL_FILE = Path(".deer-flow") / "admin_initial_credentials.txt"
 
 
 def write_initial_credentials(email: str, password: str, *, label: str = "initial") -> Path:
-    """Write the admin email + password to ``{base_dir}/admin_initial_credentials.txt``.
+    """Write the admin email + password to ``.deer-flow/admin_initial_credentials.txt``.
 
-    The file is created **atomically** with mode 0600 via ``os.open``
-    so the password is never world-readable, even for the single syscall
-    window between ``write_text`` and ``chmod``.
+    Creates the parent directory if it does not exist. Sets the file
+    mode to 0600 so only the owning process user can read it.
 
     ``label`` distinguishes "initial" (fresh creation) from "reset"
-    (password reset) in the file header so an operator picking up the
-    file after a restart can tell which event produced it.
+    (password reset) in the file header, so an operator picking up
+    the file after a restart can tell which event produced it.
 
     Returns the absolute :class:`Path` to the file.
     """
-    target = get_paths().base_dir / _CREDENTIAL_FILENAME
-    target.parent.mkdir(parents=True, exist_ok=True)
+    _CREDENTIAL_FILE.parent.mkdir(parents=True, exist_ok=True)
 
     content = (
         f"# DeerFlow admin {label} credentials\n# This file is generated on first boot or password reset.\n# Change the password after login via Settings -> Account,\n# then delete this file.\n#\nemail: {email}\npassword: {password}\n"
     )
-
-    # Atomic 0600 create-or-truncate. O_TRUNC (not O_EXCL) so the
-    # reset-password path can rewrite an existing file without a
-    # separate unlink-then-create dance.
-    fd = os.open(target, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-    with os.fdopen(fd, "w", encoding="utf-8") as fh:
-        fh.write(content)
-
-    return target.resolve()
+    _CREDENTIAL_FILE.write_text(content)
+    os.chmod(_CREDENTIAL_FILE, 0o600)
+    return _CREDENTIAL_FILE.resolve()

backend/app/gateway/auth/errors.py

@@ -20,7 +20,6 @@ class AuthErrorCode(StrEnum):
     EMAIL_ALREADY_EXISTS = "email_already_exists"
     PROVIDER_NOT_FOUND = "provider_not_found"
     NOT_AUTHENTICATED = "not_authenticated"
-    SYSTEM_ALREADY_INITIALIZED = "system_already_initialized"
 
 
 class TokenError(StrEnum):

backend/app/gateway/auth/local_provider.py

@@ -78,10 +78,6 @@ class LocalAuthProvider(AuthProvider):
         """Return total number of registered users."""
         return await self._repo.count_users()
 
-    async def count_admin_users(self) -> int:
-        """Return number of admin users."""
-        return await self._repo.count_admin_users()
-
     async def update_user(self, user: User) -> User:
         """Update an existing user."""
         return await self._repo.update_user(user)

backend/app/gateway/auth/repositories/base.py

@@ -5,16 +5,6 @@ from abc import ABC, abstractmethod
 from app.gateway.auth.models import User
 
 
-class UserNotFoundError(LookupError):
-    """Raised when a user repository operation targets a non-existent row.
-
-    Subclass of :class:`LookupError` so callers that already catch
-    ``LookupError`` for "missing entity" can keep working unchanged,
-    while specific call sites can pin to this class to distinguish
-    "concurrent delete during update" from other lookups.
-    """
-
-
 class UserRepository(ABC):
     """Abstract interface for user data storage.
 
@@ -70,11 +60,6 @@ class UserRepository(ABC):
 
         Returns:
             Updated User
-
-        Raises:
-            UserNotFoundError: If no row exists for ``user.id``. This is
-                a hard failure (not a no-op) so callers cannot mistake a
-                concurrent-delete race for a successful update.
         """
         ...
 
@@ -83,11 +68,6 @@ class UserRepository(ABC):
         """Return total number of registered users."""
         ...
 
-    @abstractmethod
-    async def count_admin_users(self) -> int:
-        """Return number of users with system_role == 'admin'."""
-        ...
-
     @abstractmethod
     async def get_user_by_oauth(self, provider: str, oauth_id: str) -> User | None:
         """Get user by OAuth provider and ID.

backend/app/gateway/auth/repositories/sqlite.py

@@ -20,7 +20,7 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
 from app.gateway.auth.models import User
-from app.gateway.auth.repositories.base import UserNotFoundError, UserRepository
+from app.gateway.auth.repositories.base import UserRepository
 from deerflow.persistence.user.model import UserRow
 
 
@@ -92,13 +92,7 @@ class SQLiteUserRepository(UserRepository):
         async with self._sf() as session:
             row = await session.get(UserRow, str(user.id))
             if row is None:
-                # Hard fail on concurrent delete: callers (reset_admin,
-                # password change handlers, _ensure_admin_user) all
-                # fetched the user just before this call, so a missing
-                # row here means the row vanished underneath us. Silent
-                # success would let the caller log "password reset" for
-                # a row that no longer exists.
-                raise UserNotFoundError(f"User {user.id} no longer exists")
+                return user
             row.email = user.email
             row.password_hash = user.password_hash
             row.system_role = user.system_role
@@ -114,11 +108,6 @@ class SQLiteUserRepository(UserRepository):
         async with self._sf() as session:
             return await session.scalar(stmt) or 0
 
-    async def count_admin_users(self) -> int:
-        stmt = select(func.count()).select_from(UserRow).where(UserRow.system_role == "admin")
-        async with self._sf() as session:
-            return await session.scalar(stmt) or 0
-
     async def get_user_by_oauth(self, provider: str, oauth_id: str) -> User | None:
         stmt = select(UserRow).where(UserRow.oauth_provider == provider, UserRow.oauth_id == oauth_id)
         async with self._sf() as session:

backend/app/gateway/auth/reset_admin.py

@@ -25,15 +25,14 @@ from deerflow.persistence.user.model import UserRow
 
 
 async def _run(email: str | None) -> int:
-    from deerflow.config import AppConfig
+    from deerflow.config import get_app_config
     from deerflow.persistence.engine import (
         close_engine,
         get_session_factory,
         init_engine_from_config,
     )
 
-    # CLI entry: load config explicitly at the top, pass down through the closure.
-    config = AppConfig.from_file()
+    config = get_app_config()
     await init_engine_from_config(config.database)
     try:
         sf = get_session_factory()

backend/app/gateway/auth_middleware.py

@@ -11,13 +11,12 @@ Fine-grained permission checks remain in authz.py decorators.
 
 from collections.abc import Callable
 
-from fastapi import HTTPException, Request, Response
+from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import JSONResponse
 from starlette.types import ASGIApp
 
-from app.gateway.auth.errors import AuthErrorCode, AuthErrorResponse
-from app.gateway.authz import _ALL_PERMISSIONS, AuthContext
+from app.gateway.auth.errors import AuthErrorCode
 from deerflow.runtime.user_context import reset_current_user, set_current_user
 
 # Paths that never require authentication.
@@ -36,7 +35,6 @@ _PUBLIC_EXACT_PATHS: frozenset[str] = frozenset(
         "/api/v1/auth/register",
         "/api/v1/auth/logout",
         "/api/v1/auth/setup-status",
-        "/api/v1/auth/initialize",
     }
 )
 
@@ -80,10 +78,10 @@ class AuthMiddleware(BaseHTTPMiddleware):
             return JSONResponse(
                 status_code=401,
                 content={
-                    "detail": AuthErrorResponse(
-                        code=AuthErrorCode.NOT_AUTHENTICATED,
-                        message="Authentication required",
-                    ).model_dump()
+                    "detail": {
+                        "code": AuthErrorCode.NOT_AUTHENTICATED,
+                        "message": "Authentication required",
+                    }
                 },
             )
 
@@ -98,6 +96,12 @@ class AuthMiddleware(BaseHTTPMiddleware):
         # propagate from AuthErrorCode, not get flattened into one
         # generic code. BaseHTTPMiddleware doesn't let HTTPException
         # bubble up, so we catch and render it as JSONResponse here.
+        #
+        # On success we stamp request.state.user and the contextvar
+        # so repository-layer owner filters work downstream without
+        # every route needing a decorator.
+        from fastapi import HTTPException
+
         from app.gateway.deps import get_current_user_from_request
 
         try:
@@ -105,12 +109,7 @@ class AuthMiddleware(BaseHTTPMiddleware):
         except HTTPException as exc:
             return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
 
-        # Stamp both request.state.user (for the contextvar pattern)
-        # and request.state.auth (so @require_permission's "auth is
-        # None" branch short-circuits instead of running the entire
-        # JWT-decode + DB-lookup pipeline a second time per request).
         request.state.user = user
-        request.state.auth = AuthContext(user=user, permissions=_ALL_PERMISSIONS)
         token = set_current_user(user)
         try:
             return await call_next(request)

backend/app/gateway/authz.py

@@ -169,7 +169,8 @@ def require_permission(
     resource: str,
     action: str,
     owner_check: bool = False,
-    require_existing: bool = False,
+    owner_filter_key: str = "owner_id",
+    inject_record: bool = False,
 ) -> Callable[[Callable[P, T]], Callable[P, T]]:
     """Decorator that checks permission for resource:action.
 
@@ -180,24 +181,27 @@ def require_permission(
         action: Action name (e.g., "read", "write", "delete")
         owner_check: If True, validates that the current user owns the resource.
                      Requires 'thread_id' path parameter and performs ownership check.
-        require_existing: Only meaningful with ``owner_check=True``. If True, a
-                          missing ``threads_meta`` row counts as a denial (404)
-                          instead of "untracked legacy thread, allow". Use on
-                          **destructive / mutating** routes (DELETE, PATCH,
-                          state-update) so a deleted thread can't be re-targeted
-                          by another user via the missing-row code path.
+        owner_filter_key: Field name for ownership filter (default: "owner_id")
+        inject_record: If True and owner_check is True, injects the thread record
+                      into kwargs['thread_record'] for use in the handler.
 
     Usage:
-        # Read-style: legacy untracked threads are allowed
-        @require_permission("threads", "read", owner_check=True)
+        # Simple permission check
+        @require_permission("threads", "read")
         async def get_thread(thread_id: str, request: Request):
             ...
 
-        # Destructive: thread row MUST exist and be owned by caller
-        @require_permission("threads", "delete", owner_check=True, require_existing=True)
+        # With ownership check (for /threads/{thread_id} endpoints)
+        @require_permission("threads", "delete", owner_check=True)
         async def delete_thread(thread_id: str, request: Request):
             ...
 
+        # With ownership check and record injection
+        @require_permission("threads", "delete", owner_check=True, inject_record=True)
+        async def delete_thread(thread_id: str, request: Request, thread_record: dict = None):
+            # thread_record is injected if found
+            ...
+
     Raises:
         HTTPException 401: If authentication required but user is anonymous
         HTTPException 403: If user lacks permission
@@ -231,24 +235,27 @@ def require_permission(
             #
             # 2.0-rc moved thread metadata into the SQL persistence layer
             # (``threads_meta`` table). We verify ownership via
-            # ``ThreadMetaStore.check_access``: it returns True for
-            # missing rows (untracked legacy thread) and for rows whose
-            # ``user_id`` is NULL (shared / pre-auth data), so this is
-            # strict-deny rather than strict-allow — only an *existing*
-            # row with a *different* user_id triggers 404.
+            # ``ThreadMetaStore.check_access`` instead of the LangGraph
+            # store path that the original PR #1728 used. ``check_access``
+            # returns True for missing rows (untracked legacy thread) and
+            # for rows whose ``owner_id`` is NULL (shared / pre-auth data),
+            # so this is a strict-deny check rather than strict-allow:
+            # only an *existing* row with a *different* owner_id triggers
+            # 404.
+            #
+            # ``inject_record`` is no longer supported — it was a
+            # convenience for handlers that wanted the LangGraph store
+            # blob; the SQL repo would need a different shape and no
+            # caller in 2.0 needs it.
             if owner_check:
                 thread_id = kwargs.get("thread_id")
                 if thread_id is None:
                     raise ValueError("require_permission with owner_check=True requires 'thread_id' parameter")
 
-                from app.gateway.deps import get_thread_store
+                from app.gateway.deps import get_thread_meta_repo
 
-                thread_store = get_thread_store(request)
-                allowed = await thread_store.check_access(
-                    thread_id,
-                    str(auth.user.id),
-                    require_existing=require_existing,
-                )
+                thread_meta_repo = get_thread_meta_repo(request)
+                allowed = await thread_meta_repo.check_access(thread_id, str(auth.user.id))
                 if not allowed:
                     raise HTTPException(
                         status_code=404,

backend/app/gateway/csrf_middleware.py

@@ -48,7 +48,6 @@ _AUTH_EXEMPT_PATHS: frozenset[str] = frozenset(
         "/api/v1/auth/login/local",
         "/api/v1/auth/logout",
         "/api/v1/auth/register",
-        "/api/v1/auth/initialize",
     }
 )
 

backend/app/gateway/deps.py

@@ -1,7 +1,8 @@
 """Centralized accessors for singleton objects stored on ``app.state``.
 
 **Getters** (used by routers): raise 503 when a required dependency is
-missing, except ``get_store`` which returns ``None``.
+missing, except ``get_store`` and ``get_thread_meta_repo`` which return
+``None``.
 
 Initialization is handled directly in ``app.py`` via :class:`AsyncExitStack`.
 """
@@ -14,26 +15,11 @@ from typing import TYPE_CHECKING
 
 from fastapi import FastAPI, HTTPException, Request
 
-from deerflow.config.app_config import AppConfig
 from deerflow.runtime import RunContext, RunManager
 
 if TYPE_CHECKING:
     from app.gateway.auth.local_provider import LocalAuthProvider
     from app.gateway.auth.repositories.sqlite import SQLiteUserRepository
-    from deerflow.persistence.thread_meta.base import ThreadMetaStore
-
-
-def get_config(request: Request) -> AppConfig:
-    """FastAPI dependency returning the app-scoped ``AppConfig``.
-
-    Reads from ``request.app.state.config`` which is set at startup
-    (``app.py`` lifespan) and swapped on config reload (``routers/mcp.py``,
-    ``routers/skills.py``).
-    """
-    cfg = getattr(request.app.state, "config", None)
-    if cfg is None:
-        raise HTTPException(status_code=503, detail="Configuration not available")
-    return cfg
 
 
 @asynccontextmanager
@@ -45,42 +31,40 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
         async with langgraph_runtime(app):
             yield
     """
+    from deerflow.agents.checkpointer.async_provider import make_checkpointer
+    from deerflow.config import get_app_config
     from deerflow.persistence.engine import close_engine, get_session_factory, init_engine_from_config
     from deerflow.runtime import make_store, make_stream_bridge
-    from deerflow.runtime.checkpointer.async_provider import make_checkpointer
     from deerflow.runtime.events.store import make_run_event_store
 
     async with AsyncExitStack() as stack:
-        # app.state.config is populated earlier in lifespan(); thread it
-        # explicitly into every provider below.
-        config = app.state.config
-
-        app.state.stream_bridge = await stack.enter_async_context(make_stream_bridge(config))
+        app.state.stream_bridge = await stack.enter_async_context(make_stream_bridge())
 
         # Initialize persistence engine BEFORE checkpointer so that
         # auto-create-database logic runs first (postgres backend).
+        config = get_app_config()
         await init_engine_from_config(config.database)
 
-        app.state.checkpointer = await stack.enter_async_context(make_checkpointer(config))
-        app.state.store = await stack.enter_async_context(make_store(config))
+        app.state.checkpointer = await stack.enter_async_context(make_checkpointer())
+        app.state.store = await stack.enter_async_context(make_store())
 
         # Initialize repositories — one get_session_factory() call for all.
         sf = get_session_factory()
         if sf is not None:
             from deerflow.persistence.feedback import FeedbackRepository
             from deerflow.persistence.run import RunRepository
+            from deerflow.persistence.thread_meta import ThreadMetaRepository
 
             app.state.run_store = RunRepository(sf)
             app.state.feedback_repo = FeedbackRepository(sf)
+            app.state.thread_meta_repo = ThreadMetaRepository(sf)
         else:
+            from deerflow.persistence.thread_meta import MemoryThreadMetaStore
             from deerflow.runtime.runs.store.memory import MemoryRunStore
 
             app.state.run_store = MemoryRunStore()
             app.state.feedback_repo = None
-
-        from deerflow.persistence.thread_meta import make_thread_store
-
-        app.state.thread_store = make_thread_store(sf, app.state.store)
+            app.state.thread_meta_repo = MemoryThreadMetaStore(app.state.store)
 
         # Run event store (has its own factory with config-driven backend selection)
         run_events_config = getattr(config, "run_events", None)
@@ -96,7 +80,7 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
 
 
 # ---------------------------------------------------------------------------
-# Getters – called by routers per-request
+# Getters -- called by routers per-request
 # ---------------------------------------------------------------------------
 
 
@@ -126,12 +110,7 @@ def get_store(request: Request):
     return getattr(request.app.state, "store", None)
 
 
-def get_thread_store(request: Request) -> ThreadMetaStore:
-    """Return the thread metadata store (SQL or memory-backed)."""
-    val = getattr(request.app.state, "thread_store", None)
-    if val is None:
-        raise HTTPException(status_code=503, detail="Thread metadata store not available")
-    return val
+get_thread_meta_repo = _require("thread_meta_repo", "Thread metadata store")
 
 
 def get_run_context(request: Request) -> RunContext:
@@ -142,18 +121,17 @@ def get_run_context(request: Request) -> RunContext:
     ``dataclasses.replace(ctx, follow_up_to_run_id=...)`` before passing it
     to :func:`run_agent`.
     """
-    config = get_config(request)
+    from deerflow.config import get_app_config
+
     return RunContext(
         checkpointer=get_checkpointer(request),
         store=get_store(request),
         event_store=get_run_event_store(request),
-        run_events_config=getattr(config, "run_events", None),
-        thread_store=get_thread_store(request),
-        app_config=config,
+        run_events_config=getattr(get_app_config(), "run_events", None),
+        thread_meta_repo=get_thread_meta_repo(request),
     )
 
 
-
 # ---------------------------------------------------------------------------
 # Auth helpers (used by authz.py and auth middleware)
 # ---------------------------------------------------------------------------

backend/app/gateway/langgraph_auth.py

@@ -93,14 +93,14 @@ async def authenticate(request):
 
 @auth.on
 async def add_owner_filter(ctx: Auth.types.AuthContext, value: dict):
-    """Inject user_id metadata on writes; filter by user_id on reads.
+    """Inject owner_id metadata on writes; filter by owner_id on reads.
 
-    Gateway stores thread ownership as ``metadata.user_id``.
+    Gateway stores thread ownership as ``metadata.owner_id``.
     This handler ensures LangGraph Server enforces the same isolation.
     """
-    # On create/update: stamp user_id into metadata
+    # On create/update: stamp owner_id into metadata
     metadata = value.setdefault("metadata", {})
-    metadata["user_id"] = ctx.user.identity
+    metadata["owner_id"] = ctx.user.identity
 
     # Return filter dict — LangGraph applies it to search/read/delete
-    return {"user_id": ctx.user.identity}
+    return {"owner_id": ctx.user.identity}

backend/app/gateway/path_utils.py

@@ -5,7 +5,6 @@ from pathlib import Path
 from fastapi import HTTPException
 
 from deerflow.config.paths import get_paths
-from deerflow.runtime.user_context import get_effective_user_id
 
 
 def resolve_thread_virtual_path(thread_id: str, virtual_path: str) -> Path:
@@ -23,7 +22,7 @@ def resolve_thread_virtual_path(thread_id: str, virtual_path: str) -> Path:
         HTTPException: If the path is invalid or outside allowed directories.
     """
     try:
-        return get_paths().resolve_virtual_path(thread_id, virtual_path, user_id=get_effective_user_id())
+        return get_paths().resolve_virtual_path(thread_id, virtual_path)
     except ValueError as e:
         status = 403 if "traversal" in str(e) else 400
         raise HTTPException(status_code=status, detail=str(e))

backend/app/gateway/routers/agents.py

@@ -5,12 +5,10 @@ import re
 import shutil
 
 import yaml
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from app.gateway.deps import get_config
 from deerflow.config.agents_config import AgentConfig, list_custom_agents, load_agent_config, load_agent_soul
-from deerflow.config.app_config import AppConfig
 from deerflow.config.paths import get_paths
 
 logger = logging.getLogger(__name__)
@@ -26,7 +24,6 @@ class AgentResponse(BaseModel):
     description: str = Field(default="", description="Agent description")
     model: str | None = Field(default=None, description="Optional model override")
     tool_groups: list[str] | None = Field(default=None, description="Optional tool group whitelist")
-    skills: list[str] | None = Field(default=None, description="Optional skill whitelist (None=all, []=none)")
     soul: str | None = Field(default=None, description="SOUL.md content")
 
 
@@ -43,7 +40,6 @@ class AgentCreateRequest(BaseModel):
     description: str = Field(default="", description="Agent description")
     model: str | None = Field(default=None, description="Optional model override")
     tool_groups: list[str] | None = Field(default=None, description="Optional tool group whitelist")
-    skills: list[str] | None = Field(default=None, description="Optional skill whitelist (None=all enabled, []=none)")
     soul: str = Field(default="", description="SOUL.md content — agent personality and behavioral guardrails")
 
 
@@ -53,7 +49,6 @@ class AgentUpdateRequest(BaseModel):
     description: str | None = Field(default=None, description="Updated description")
     model: str | None = Field(default=None, description="Updated model override")
     tool_groups: list[str] | None = Field(default=None, description="Updated tool group whitelist")
-    skills: list[str] | None = Field(default=None, description="Updated skill whitelist (None=all, []=none)")
     soul: str | None = Field(default=None, description="Updated SOUL.md content")
 
 
@@ -78,15 +73,6 @@ def _normalize_agent_name(name: str) -> str:
     return name.lower()
 
 
-def _require_agents_api_enabled(app_config: AppConfig) -> None:
-    """Reject access unless the custom-agent management API is explicitly enabled."""
-    if not app_config.agents_api.enabled:
-        raise HTTPException(
-            status_code=403,
-            detail=("Custom-agent management API is disabled. Set agents_api.enabled=true to expose agent and user-profile routes over HTTP."),
-        )
-
-
 def _agent_config_to_response(agent_cfg: AgentConfig, include_soul: bool = False) -> AgentResponse:
     """Convert AgentConfig to AgentResponse."""
     soul: str | None = None
@@ -98,7 +84,6 @@ def _agent_config_to_response(agent_cfg: AgentConfig, include_soul: bool = False
         description=agent_cfg.description,
         model=agent_cfg.model,
         tool_groups=agent_cfg.tool_groups,
-        skills=agent_cfg.skills,
         soul=soul,
     )
 
@@ -109,14 +94,12 @@ def _agent_config_to_response(agent_cfg: AgentConfig, include_soul: bool = False
     summary="List Custom Agents",
     description="List all custom agents available in the agents directory, including their soul content.",
 )
-async def list_agents(app_config: AppConfig = Depends(get_config)) -> AgentsListResponse:
+async def list_agents() -> AgentsListResponse:
     """List all custom agents.
 
     Returns:
         List of all custom agents with their metadata and soul content.
     """
-    _require_agents_api_enabled(app_config)
-
     try:
         agents = list_custom_agents()
         return AgentsListResponse(agents=[_agent_config_to_response(a, include_soul=True) for a in agents])
@@ -142,7 +125,6 @@ async def check_agent_name(name: str) -> dict:
     Raises:
         HTTPException: 422 if the name is invalid.
     """
-    _require_agents_api_enabled(app_config)
     _validate_agent_name(name)
     normalized = _normalize_agent_name(name)
     available = not get_paths().agent_dir(normalized).exists()
@@ -155,7 +137,7 @@ async def check_agent_name(name: str) -> dict:
     summary="Get Custom Agent",
     description="Retrieve details and SOUL.md content for a specific custom agent.",
 )
-async def get_agent(name: str, app_config: AppConfig = Depends(get_config)) -> AgentResponse:
+async def get_agent(name: str) -> AgentResponse:
     """Get a specific custom agent by name.
 
     Args:
@@ -167,7 +149,6 @@ async def get_agent(name: str, app_config: AppConfig = Depends(get_config)) -> A
     Raises:
         HTTPException: 404 if agent not found.
     """
-    _require_agents_api_enabled(app_config)
     _validate_agent_name(name)
     name = _normalize_agent_name(name)
 
@@ -188,7 +169,7 @@ async def get_agent(name: str, app_config: AppConfig = Depends(get_config)) -> A
     summary="Create Custom Agent",
     description="Create a new custom agent with its config and SOUL.md.",
 )
-async def create_agent_endpoint(request: AgentCreateRequest, app_config: AppConfig = Depends(get_config)) -> AgentResponse:
+async def create_agent_endpoint(request: AgentCreateRequest) -> AgentResponse:
     """Create a new custom agent.
 
     Args:
@@ -200,7 +181,6 @@ async def create_agent_endpoint(request: AgentCreateRequest, app_config: AppConf
     Raises:
         HTTPException: 409 if agent already exists, 422 if name is invalid.
     """
-    _require_agents_api_enabled(app_config)
     _validate_agent_name(request.name)
     normalized_name = _normalize_agent_name(request.name)
 
@@ -220,8 +200,6 @@ async def create_agent_endpoint(request: AgentCreateRequest, app_config: AppConf
             config_data["model"] = request.model
         if request.tool_groups is not None:
             config_data["tool_groups"] = request.tool_groups
-        if request.skills is not None:
-            config_data["skills"] = request.skills
 
         config_file = agent_dir / "config.yaml"
         with open(config_file, "w", encoding="utf-8") as f:
@@ -252,7 +230,7 @@ async def create_agent_endpoint(request: AgentCreateRequest, app_config: AppConf
     summary="Update Custom Agent",
     description="Update an existing custom agent's config and/or SOUL.md.",
 )
-async def update_agent(name: str, request: AgentUpdateRequest, app_config: AppConfig = Depends(get_config)) -> AgentResponse:
+async def update_agent(name: str, request: AgentUpdateRequest) -> AgentResponse:
     """Update an existing custom agent.
 
     Args:
@@ -265,7 +243,6 @@ async def update_agent(name: str, request: AgentUpdateRequest, app_config: AppCo
     Raises:
         HTTPException: 404 if agent not found.
     """
-    _require_agents_api_enabled(app_config)
     _validate_agent_name(name)
     name = _normalize_agent_name(name)
 
@@ -278,32 +255,21 @@ async def update_agent(name: str, request: AgentUpdateRequest, app_config: AppCo
 
     try:
         # Update config if any config fields changed
-        # Use model_fields_set to distinguish "field omitted" from "explicitly set to null".
-        # This is critical for skills where None means "inherit all" (not "don't change").
-        fields_set = request.model_fields_set
-        config_changed = bool(fields_set & {"description", "model", "tool_groups", "skills"})
+        config_changed = any(v is not None for v in [request.description, request.model, request.tool_groups])
 
         if config_changed:
             updated: dict = {
                 "name": agent_cfg.name,
-                "description": request.description if "description" in fields_set else agent_cfg.description,
+                "description": request.description if request.description is not None else agent_cfg.description,
             }
-            new_model = request.model if "model" in fields_set else agent_cfg.model
+            new_model = request.model if request.model is not None else agent_cfg.model
             if new_model is not None:
                 updated["model"] = new_model
 
-            new_tool_groups = request.tool_groups if "tool_groups" in fields_set else agent_cfg.tool_groups
+            new_tool_groups = request.tool_groups if request.tool_groups is not None else agent_cfg.tool_groups
             if new_tool_groups is not None:
                 updated["tool_groups"] = new_tool_groups
 
-            # skills: None = inherit all, [] = no skills, ["a","b"] = whitelist
-            if "skills" in fields_set:
-                new_skills = request.skills
-            else:
-                new_skills = agent_cfg.skills
-            if new_skills is not None:
-                updated["skills"] = new_skills
-
             config_file = agent_dir / "config.yaml"
             with open(config_file, "w", encoding="utf-8") as f:
                 yaml.dump(updated, f, default_flow_style=False, allow_unicode=True)
@@ -343,14 +309,12 @@ class UserProfileUpdateRequest(BaseModel):
     summary="Get User Profile",
     description="Read the global USER.md file that is injected into all custom agents.",
 )
-async def get_user_profile(app_config: AppConfig = Depends(get_config)) -> UserProfileResponse:
+async def get_user_profile() -> UserProfileResponse:
     """Return the current USER.md content.
 
     Returns:
         UserProfileResponse with content=None if USER.md does not exist yet.
     """
-    _require_agents_api_enabled(app_config)
-
     try:
         user_md_path = get_paths().user_md_file
         if not user_md_path.exists():
@@ -368,7 +332,7 @@ async def get_user_profile(app_config: AppConfig = Depends(get_config)) -> UserP
     summary="Update User Profile",
     description="Write the global USER.md file that is injected into all custom agents.",
 )
-async def update_user_profile(request: UserProfileUpdateRequest, app_config: AppConfig = Depends(get_config)) -> UserProfileResponse:
+async def update_user_profile(request: UserProfileUpdateRequest) -> UserProfileResponse:
     """Create or overwrite the global USER.md.
 
     Args:
@@ -377,8 +341,6 @@ async def update_user_profile(request: UserProfileUpdateRequest, app_config: App
     Returns:
         UserProfileResponse with the saved content.
     """
-    _require_agents_api_enabled(app_config)
-
     try:
         paths = get_paths()
         paths.base_dir.mkdir(parents=True, exist_ok=True)
@@ -396,7 +358,7 @@ async def update_user_profile(request: UserProfileUpdateRequest, app_config: App
     summary="Delete Custom Agent",
     description="Delete a custom agent and all its files (config, SOUL.md, memory).",
 )
-async def delete_agent(name: str, app_config: AppConfig = Depends(get_config)) -> None:
+async def delete_agent(name: str) -> None:
     """Delete a custom agent.
 
     Args:
@@ -405,7 +367,6 @@ async def delete_agent(name: str, app_config: AppConfig = Depends(get_config)) -
     Raises:
         HTTPException: 404 if agent not found.
     """
-    _require_agents_api_enabled(app_config)
     _validate_agent_name(name)
     name = _normalize_agent_name(name)
 

backend/app/gateway/routers/auth.py

@@ -1,13 +1,11 @@
 """Authentication endpoints."""
 
 import logging
-import os
 import time
-from ipaddress import ip_address, ip_network
 
 from fastapi import APIRouter, Depends, HTTPException, Request, Response, status
 from fastapi.security import OAuth2PasswordRequestForm
-from pydantic import BaseModel, EmailStr, Field, field_validator
+from pydantic import BaseModel, EmailStr, Field
 
 from app.gateway.auth import (
     UserResponse,
@@ -33,84 +31,12 @@ class LoginResponse(BaseModel):
     needs_setup: bool = False
 
 
-# Top common-password blocklist. Drawn from the public SecLists "10k worst
-# passwords" set, lowercased + length>=8 only (shorter ones already fail
-# the min_length check). Kept tight on purpose: this is the **lower bound**
-# defense, not a full HIBP / passlib check, and runs in-process per request.
-_COMMON_PASSWORDS: frozenset[str] = frozenset(
-    {
-        "password",
-        "password1",
-        "password12",
-        "password123",
-        "password1234",
-        "12345678",
-        "123456789",
-        "1234567890",
-        "qwerty12",
-        "qwertyui",
-        "qwerty123",
-        "abc12345",
-        "abcd1234",
-        "iloveyou",
-        "letmein1",
-        "welcome1",
-        "welcome123",
-        "admin123",
-        "administrator",
-        "passw0rd",
-        "p@ssw0rd",
-        "monkey12",
-        "trustno1",
-        "sunshine",
-        "princess",
-        "football",
-        "baseball",
-        "superman",
-        "batman123",
-        "starwars",
-        "dragon123",
-        "master123",
-        "shadow12",
-        "michael1",
-        "jennifer",
-        "computer",
-    }
-)
-
-
-def _password_is_common(password: str) -> bool:
-    """Case-insensitive blocklist check.
-
-    Lowercases the input so trivial mutations like ``Password`` /
-    ``PASSWORD`` are also rejected. Does not normalize digit substitutions
-    (``p@ssw0rd`` is included as a literal entry instead) — keeping the
-    rule cheap and predictable.
-    """
-    return password.lower() in _COMMON_PASSWORDS
-
-
-def _validate_strong_password(value: str) -> str:
-    """Pydantic field-validator body shared by Register + ChangePassword.
-
-    Constraint = function, not type-level mixin. The two request models
-    have no "is-a" relationship; they only share the password-strength
-    rule. Lifting it into a free function lets each model bind it via
-    ``@field_validator(field_name)`` without inheritance gymnastics.
-    """
-    if _password_is_common(value):
-        raise ValueError("Password is too common; choose a stronger password.")
-    return value
-
-
 class RegisterRequest(BaseModel):
     """Request model for user registration."""
 
     email: EmailStr
     password: str = Field(..., min_length=8)
 
-    _strong_password = field_validator("password")(classmethod(lambda cls, v: _validate_strong_password(v)))
-
 
 class ChangePasswordRequest(BaseModel):
     """Request model for password change (also handles setup flow)."""
@@ -119,8 +45,6 @@ class ChangePasswordRequest(BaseModel):
     new_password: str = Field(..., min_length=8)
     new_email: EmailStr | None = None
 
-    _strong_password = field_validator("new_password")(classmethod(lambda cls, v: _validate_strong_password(v)))
-
 
 class MessageResponse(BaseModel):
     """Generic message response."""
@@ -155,65 +79,26 @@ _LOCKOUT_SECONDS = 300  # 5 minutes
 _login_attempts: dict[str, tuple[int, float]] = {}
 
 
-def _trusted_proxies() -> list:
-    """Parse ``AUTH_TRUSTED_PROXIES`` env var into a list of ip_network objects.
-
-    Comma-separated CIDR or single-IP entries. Empty / unset = no proxy is
-    trusted (direct mode). Invalid entries are skipped with a logger warning.
-    Read live so env-var overrides take effect immediately and tests can
-    ``monkeypatch.setenv`` without poking a module-level cache.
-    """
-    raw = os.getenv("AUTH_TRUSTED_PROXIES", "").strip()
-    if not raw:
-        return []
-    nets = []
-    for entry in raw.split(","):
-        entry = entry.strip()
-        if not entry:
-            continue
-        try:
-            nets.append(ip_network(entry, strict=False))
-        except ValueError:
-            logger.warning("AUTH_TRUSTED_PROXIES: ignoring invalid entry %r", entry)
-    return nets
-
-
 def _get_client_ip(request: Request) -> str:
     """Extract the real client IP for rate limiting.
 
-    Trust model:
+    Uses ``X-Real-IP`` header set by nginx (``proxy_set_header X-Real-IP
+    $remote_addr``).  Nginx unconditionally overwrites any client-supplied
+    ``X-Real-IP``, so the value seen by Gateway is always the TCP peer IP
+    that nginx observed — it cannot be spoofed by the client.
 
-    - The TCP peer (``request.client.host``) is always the baseline. It is
-      whatever the kernel reports as the connecting socket — unforgeable
-      by the client itself.
-    - ``X-Real-IP`` is **only** honored if the TCP peer is in the
-      ``AUTH_TRUSTED_PROXIES`` allowlist (set via env var, comma-separated
-      CIDR or single IPs). When set, the gateway is assumed to be behind a
-      reverse proxy (nginx, Cloudflare, ALB, …) that overwrites
-      ``X-Real-IP`` with the original client address.
-    - With no ``AUTH_TRUSTED_PROXIES`` set, ``X-Real-IP`` is silently
-      ignored — closing the bypass where any client could rotate the
-      header to dodge per-IP rate limits in dev / direct-gateway mode.
+    ``request.client.host`` is NOT reliable because uvicorn's default
+    ``proxy_headers=True`` replaces it with the *first* entry from
+    ``X-Forwarded-For``, which IS client-spoofable.
 
-    ``X-Forwarded-For`` is intentionally NOT used because it is naturally
-    client-controlled at the *first* hop and the trust chain is harder to
-    audit per-request.
+    ``X-Forwarded-For`` is intentionally NOT used for the same reason.
     """
-    peer_host = request.client.host if request.client else None
+    real_ip = request.headers.get("x-real-ip", "").strip()
+    if real_ip:
+        return real_ip
 
-    trusted = _trusted_proxies()
-    if trusted and peer_host:
-        try:
-            peer_ip = ip_address(peer_host)
-            if any(peer_ip in net for net in trusted):
-                real_ip = request.headers.get("x-real-ip", "").strip()
-                if real_ip:
-                    return real_ip
-        except ValueError:
-            # peer_host wasn't a parseable IP (e.g. "unknown") — fall through
-            pass
-
-    return peer_host or "unknown"
+    # Fallback: direct connection without nginx (e.g. unit tests, dev).
+    return request.client.host if request.client else "unknown"
 
 
 def _check_rate_limit(ip: str) -> None:
@@ -378,50 +263,9 @@ async def get_me(request: Request):
 
 @router.get("/setup-status")
 async def setup_status():
-    """Check if an admin account exists. Returns needs_setup=True when no admin exists."""
-    admin_count = await get_local_provider().count_admin_users()
-    return {"needs_setup": admin_count == 0}
-
-
-class InitializeAdminRequest(BaseModel):
-    """Request model for first-boot admin account creation."""
-
-    email: EmailStr
-    password: str = Field(..., min_length=8)
-
-    _strong_password = field_validator("password")(classmethod(lambda cls, v: _validate_strong_password(v)))
-
-
-@router.post("/initialize", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
-async def initialize_admin(request: Request, response: Response, body: InitializeAdminRequest):
-    """Create the first admin account on initial system setup.
-
-    Only callable when no admin exists. Returns 409 Conflict if an admin
-    already exists.
-
-    On success, the admin account is created with ``needs_setup=False`` and
-    the session cookie is set.
-    """
-    admin_count = await get_local_provider().count_admin_users()
-    if admin_count > 0:
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail=AuthErrorResponse(code=AuthErrorCode.SYSTEM_ALREADY_INITIALIZED, message="System already initialized").model_dump(),
-        )
-
-    try:
-        user = await get_local_provider().create_user(email=body.email, password=body.password, system_role="admin", needs_setup=False)
-    except ValueError:
-        # DB unique-constraint race: another concurrent request beat us.
-        raise HTTPException(
-            status_code=status.HTTP_409_CONFLICT,
-            detail=AuthErrorResponse(code=AuthErrorCode.SYSTEM_ALREADY_INITIALIZED, message="System already initialized").model_dump(),
-        )
-
-    token = create_access_token(str(user.id), token_version=user.token_version)
-    _set_session_cookie(response, token, request)
-
-    return UserResponse(id=str(user.id), email=user.email, system_role=user.system_role)
+    """Check if admin account exists. Always False after first boot."""
+    user_count = await get_local_provider().count_users()
+    return {"needs_setup": user_count == 0}
 
 
 # ── OAuth Endpoints (Future/Placeholder) ─────────────────────────────────

backend/app/gateway/routers/feedback.py

@@ -30,16 +30,11 @@ class FeedbackCreateRequest(BaseModel):
     message_id: str | None = Field(default=None, description="Optional: scope feedback to a specific message")
 
 
-class FeedbackUpsertRequest(BaseModel):
-    rating: int = Field(..., description="Feedback rating: +1 (positive) or -1 (negative)")
-    comment: str | None = Field(default=None, description="Optional text feedback")
-
-
 class FeedbackResponse(BaseModel):
     feedback_id: str
     run_id: str
     thread_id: str
-    user_id: str | None = None
+    owner_id: str | None = None
     message_id: str | None = None
     rating: int
     comment: str | None = None
@@ -58,59 +53,8 @@ class FeedbackStatsResponse(BaseModel):
 # ---------------------------------------------------------------------------
 
 
-@router.put("/{thread_id}/runs/{run_id}/feedback", response_model=FeedbackResponse)
-@require_permission("threads", "write", owner_check=True, require_existing=True)
-async def upsert_feedback(
-    thread_id: str,
-    run_id: str,
-    body: FeedbackUpsertRequest,
-    request: Request,
-) -> dict[str, Any]:
-    """Create or update feedback for a run (idempotent)."""
-    if body.rating not in (1, -1):
-        raise HTTPException(status_code=400, detail="rating must be +1 or -1")
-
-    user_id = await get_current_user(request)
-
-    run_store = get_run_store(request)
-    run = await run_store.get(run_id)
-    if run is None:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-    if run.get("thread_id") != thread_id:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found in thread {thread_id}")
-
-    feedback_repo = get_feedback_repo(request)
-    return await feedback_repo.upsert(
-        run_id=run_id,
-        thread_id=thread_id,
-        rating=body.rating,
-        user_id=user_id,
-        comment=body.comment,
-    )
-
-
-@router.delete("/{thread_id}/runs/{run_id}/feedback")
-@require_permission("threads", "delete", owner_check=True, require_existing=True)
-async def delete_run_feedback(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-) -> dict[str, bool]:
-    """Delete the current user's feedback for a run."""
-    user_id = await get_current_user(request)
-    feedback_repo = get_feedback_repo(request)
-    deleted = await feedback_repo.delete_by_run(
-        thread_id=thread_id,
-        run_id=run_id,
-        user_id=user_id,
-    )
-    if not deleted:
-        raise HTTPException(status_code=404, detail="No feedback found for this run")
-    return {"success": True}
-
-
 @router.post("/{thread_id}/runs/{run_id}/feedback", response_model=FeedbackResponse)
-@require_permission("threads", "write", owner_check=True, require_existing=True)
+@require_permission("threads", "write", owner_check=True)
 async def create_feedback(
     thread_id: str,
     run_id: str,
@@ -136,7 +80,7 @@ async def create_feedback(
         run_id=run_id,
         thread_id=thread_id,
         rating=body.rating,
-        user_id=user_id,
+        owner_id=user_id,
         message_id=body.message_id,
         comment=body.comment,
     )
@@ -167,7 +111,7 @@ async def feedback_stats(
 
 
 @router.delete("/{thread_id}/runs/{run_id}/feedback/{feedback_id}")
-@require_permission("threads", "delete", owner_check=True, require_existing=True)
+@require_permission("threads", "delete", owner_check=True)
 async def delete_feedback(
     thread_id: str,
     run_id: str,

backend/app/gateway/routers/mcp.py

@@ -3,12 +3,10 @@ import logging
 from pathlib import Path
 from typing import Literal
 
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from app.gateway.deps import get_config
-from deerflow.config.app_config import AppConfig
-from deerflow.config.extensions_config import ExtensionsConfig
+from deerflow.config.extensions_config import ExtensionsConfig, get_extensions_config, reload_extensions_config
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api", tags=["mcp"])
@@ -71,7 +69,7 @@ class McpConfigUpdateRequest(BaseModel):
     summary="Get MCP Configuration",
     description="Retrieve the current Model Context Protocol (MCP) server configurations.",
 )
-async def get_mcp_configuration(config: AppConfig = Depends(get_config)) -> McpConfigResponse:
+async def get_mcp_configuration() -> McpConfigResponse:
     """Get the current MCP configuration.
 
     Returns:
@@ -92,9 +90,9 @@ async def get_mcp_configuration(config: AppConfig = Depends(get_config)) -> McpC
         }
         ```
     """
-    ext = config.extensions
+    config = get_extensions_config()
 
-    return McpConfigResponse(mcp_servers={name: McpServerConfigResponse(**server.model_dump()) for name, server in ext.mcp_servers.items()})
+    return McpConfigResponse(mcp_servers={name: McpServerConfigResponse(**server.model_dump()) for name, server in config.mcp_servers.items()})
 
 
 @router.put(
@@ -103,11 +101,7 @@ async def get_mcp_configuration(config: AppConfig = Depends(get_config)) -> McpC
     summary="Update MCP Configuration",
     description="Update Model Context Protocol (MCP) server configurations and save to file.",
 )
-async def update_mcp_configuration(
-    request: McpConfigUpdateRequest,
-    http_request: Request,
-    config: AppConfig = Depends(get_config),
-) -> McpConfigResponse:
+async def update_mcp_configuration(request: McpConfigUpdateRequest) -> McpConfigResponse:
     """Update the MCP configuration.
 
     This will:
@@ -148,13 +142,13 @@ async def update_mcp_configuration(
             config_path = Path.cwd().parent / "extensions_config.json"
             logger.info(f"No existing extensions config found. Creating new config at: {config_path}")
 
-        # Use injected config to preserve skills configuration
-        current_ext = config.extensions
+        # Load current config to preserve skills configuration
+        current_config = get_extensions_config()
 
         # Convert request to dict format for JSON serialization
         config_data = {
             "mcpServers": {name: server.model_dump() for name, server in request.mcp_servers.items()},
-            "skills": {name: {"enabled": skill.enabled} for name, skill in current_ext.skills.items()},
+            "skills": {name: {"enabled": skill.enabled} for name, skill in current_config.skills.items()},
         }
 
         # Write the configuration to file
@@ -166,11 +160,9 @@ async def update_mcp_configuration(
         # NOTE: No need to reload/reset cache here - LangGraph Server (separate process)
         # will detect config file changes via mtime and reinitialize MCP tools automatically
 
-        # Reload the configuration and swap ``app.state.config`` so subsequent
-        # ``Depends(get_config)`` calls see the refreshed value.
-        reloaded = AppConfig.from_file()
-        http_request.app.state.config = reloaded
-        return McpConfigResponse(mcp_servers={name: McpServerConfigResponse(**server.model_dump()) for name, server in reloaded.extensions.mcp_servers.items()})
+        # Reload the configuration and update the global cache
+        reloaded_config = reload_extensions_config()
+        return McpConfigResponse(mcp_servers={name: McpServerConfigResponse(**server.model_dump()) for name, server in reloaded_config.mcp_servers.items()})
 
     except Exception as e:
         logger.error(f"Failed to update MCP configuration: {e}", exc_info=True)

backend/app/gateway/routers/memory.py

@@ -1,9 +1,8 @@
 """Memory API router for retrieving and managing global memory data."""
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from app.gateway.deps import get_config
 from deerflow.agents.memory.updater import (
     clear_memory_data,
     create_memory_fact,
@@ -13,8 +12,7 @@ from deerflow.agents.memory.updater import (
     reload_memory_data,
     update_memory_fact,
 )
-from deerflow.config.app_config import AppConfig
-from deerflow.runtime.user_context import get_effective_user_id
+from deerflow.config.memory_config import get_memory_config
 
 router = APIRouter(prefix="/api", tags=["memory"])
 
@@ -115,7 +113,7 @@ class MemoryStatusResponse(BaseModel):
     summary="Get Memory Data",
     description="Retrieve the current global memory data including user context, history, and facts.",
 )
-async def get_memory(app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def get_memory() -> MemoryResponse:
     """Get the current global memory data.
 
     Returns:
@@ -149,7 +147,7 @@ async def get_memory(app_config: AppConfig = Depends(get_config)) -> MemoryRespo
         }
         ```
     """
-    memory_data = get_memory_data(app_config.memory, user_id=get_effective_user_id())
+    memory_data = get_memory_data()
     return MemoryResponse(**memory_data)
 
 
@@ -160,7 +158,7 @@ async def get_memory(app_config: AppConfig = Depends(get_config)) -> MemoryRespo
     summary="Reload Memory Data",
     description="Reload memory data from the storage file, refreshing the in-memory cache.",
 )
-async def reload_memory(app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def reload_memory() -> MemoryResponse:
     """Reload memory data from file.
 
     This forces a reload of the memory data from the storage file,
@@ -169,7 +167,7 @@ async def reload_memory(app_config: AppConfig = Depends(get_config)) -> MemoryRe
     Returns:
         The reloaded memory data.
     """
-    memory_data = reload_memory_data(app_config.memory, user_id=get_effective_user_id())
+    memory_data = reload_memory_data()
     return MemoryResponse(**memory_data)
 
 
@@ -180,10 +178,10 @@ async def reload_memory(app_config: AppConfig = Depends(get_config)) -> MemoryRe
     summary="Clear All Memory Data",
     description="Delete all saved memory data and reset the memory structure to an empty state.",
 )
-async def clear_memory(app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def clear_memory() -> MemoryResponse:
     """Clear all persisted memory data."""
     try:
-        memory_data = clear_memory_data(app_config.memory, user_id=get_effective_user_id())
+        memory_data = clear_memory_data()
     except OSError as exc:
         raise HTTPException(status_code=500, detail="Failed to clear memory data.") from exc
 
@@ -197,15 +195,13 @@ async def clear_memory(app_config: AppConfig = Depends(get_config)) -> MemoryRes
     summary="Create Memory Fact",
     description="Create a single saved memory fact manually.",
 )
-async def create_memory_fact_endpoint(request: FactCreateRequest, app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def create_memory_fact_endpoint(request: FactCreateRequest) -> MemoryResponse:
     """Create a single fact manually."""
     try:
         memory_data = create_memory_fact(
-            app_config.memory,
             content=request.content,
             category=request.category,
             confidence=request.confidence,
-            user_id=get_effective_user_id(),
         )
     except ValueError as exc:
         raise _map_memory_fact_value_error(exc) from exc
@@ -222,10 +218,10 @@ async def create_memory_fact_endpoint(request: FactCreateRequest, app_config: Ap
     summary="Delete Memory Fact",
     description="Delete a single saved memory fact by its fact id.",
 )
-async def delete_memory_fact_endpoint(fact_id: str, app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def delete_memory_fact_endpoint(fact_id: str) -> MemoryResponse:
     """Delete a single fact from memory by fact id."""
     try:
-        memory_data = delete_memory_fact(app_config.memory, fact_id, user_id=get_effective_user_id())
+        memory_data = delete_memory_fact(fact_id)
     except KeyError as exc:
         raise HTTPException(status_code=404, detail=f"Memory fact '{fact_id}' not found.") from exc
     except OSError as exc:
@@ -241,16 +237,14 @@ async def delete_memory_fact_endpoint(fact_id: str, app_config: AppConfig = Depe
     summary="Patch Memory Fact",
     description="Partially update a single saved memory fact by its fact id while preserving omitted fields.",
 )
-async def update_memory_fact_endpoint(fact_id: str, request: FactPatchRequest, app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def update_memory_fact_endpoint(fact_id: str, request: FactPatchRequest) -> MemoryResponse:
     """Partially update a single fact manually."""
     try:
         memory_data = update_memory_fact(
-            app_config.memory,
             fact_id=fact_id,
             content=request.content,
             category=request.category,
             confidence=request.confidence,
-            user_id=get_effective_user_id(),
         )
     except ValueError as exc:
         raise _map_memory_fact_value_error(exc) from exc
@@ -269,9 +263,9 @@ async def update_memory_fact_endpoint(fact_id: str, request: FactPatchRequest, a
     summary="Export Memory Data",
     description="Export the current global memory data as JSON for backup or transfer.",
 )
-async def export_memory(app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def export_memory() -> MemoryResponse:
     """Export the current memory data."""
-    memory_data = get_memory_data(app_config.memory, user_id=get_effective_user_id())
+    memory_data = get_memory_data()
     return MemoryResponse(**memory_data)
 
 
@@ -282,10 +276,10 @@ async def export_memory(app_config: AppConfig = Depends(get_config)) -> MemoryRe
     summary="Import Memory Data",
     description="Import and overwrite the current global memory data from a JSON payload.",
 )
-async def import_memory(request: MemoryResponse, app_config: AppConfig = Depends(get_config)) -> MemoryResponse:
+async def import_memory(request: MemoryResponse) -> MemoryResponse:
     """Import and persist memory data."""
     try:
-        memory_data = import_memory_data(app_config.memory, request.model_dump(), user_id=get_effective_user_id())
+        memory_data = import_memory_data(request.model_dump())
     except OSError as exc:
         raise HTTPException(status_code=500, detail="Failed to import memory data.") from exc
 
@@ -298,9 +292,7 @@ async def import_memory(request: MemoryResponse, app_config: AppConfig = Depends
     summary="Get Memory Configuration",
     description="Retrieve the current memory system configuration.",
 )
-async def get_memory_config_endpoint(
-    app_config: AppConfig = Depends(get_config),
-) -> MemoryConfigResponse:
+async def get_memory_config_endpoint() -> MemoryConfigResponse:
     """Get the memory system configuration.
 
     Returns:
@@ -319,7 +311,7 @@ async def get_memory_config_endpoint(
         }
         ```
     """
-    config = app_config.memory
+    config = get_memory_config()
     return MemoryConfigResponse(
         enabled=config.enabled,
         storage_path=config.storage_path,
@@ -338,16 +330,14 @@ async def get_memory_config_endpoint(
     summary="Get Memory Status",
     description="Retrieve both memory configuration and current data in a single request.",
 )
-async def get_memory_status(
-    app_config: AppConfig = Depends(get_config),
-) -> MemoryStatusResponse:
+async def get_memory_status() -> MemoryStatusResponse:
     """Get the memory system status including configuration and data.
 
     Returns:
         Combined memory configuration and current data.
     """
-    config = app_config.memory
-    memory_data = get_memory_data(config, user_id=get_effective_user_id())
+    config = get_memory_config()
+    memory_data = get_memory_data()
 
     return MemoryStatusResponse(
         config=MemoryConfigResponse(

backend/app/gateway/routers/models.py

@@ -1,8 +1,7 @@
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from app.gateway.deps import get_config
-from deerflow.config.app_config import AppConfig
+from deerflow.config import get_app_config
 
 router = APIRouter(prefix="/api", tags=["models"])
 
@@ -18,17 +17,10 @@ class ModelResponse(BaseModel):
     supports_reasoning_effort: bool = Field(default=False, description="Whether model supports reasoning effort")
 
 
-class TokenUsageResponse(BaseModel):
-    """Token usage display configuration."""
-
-    enabled: bool = Field(default=False, description="Whether token usage display is enabled")
-
-
 class ModelsListResponse(BaseModel):
     """Response model for listing all models."""
 
     models: list[ModelResponse]
-    token_usage: TokenUsageResponse
 
 
 @router.get(
@@ -37,14 +29,14 @@ class ModelsListResponse(BaseModel):
     summary="List All Models",
     description="Retrieve a list of all available AI models configured in the system.",
 )
-async def list_models(config: AppConfig = Depends(get_config)) -> ModelsListResponse:
+async def list_models() -> ModelsListResponse:
     """List all available models from configuration.
 
     Returns model information suitable for frontend display,
     excluding sensitive fields like API keys and internal configuration.
 
     Returns:
-        A list of all configured models with their metadata and token usage display settings.
+        A list of all configured models with their metadata.
 
     Example Response:
         ```json
@@ -52,27 +44,21 @@ async def list_models(config: AppConfig = Depends(get_config)) -> ModelsListResp
             "models": [
                 {
                     "name": "gpt-4",
-                    "model": "gpt-4",
                     "display_name": "GPT-4",
                     "description": "OpenAI GPT-4 model",
-                    "supports_thinking": false,
-                    "supports_reasoning_effort": false
+                    "supports_thinking": false
                 },
                 {
                     "name": "claude-3-opus",
-                    "model": "claude-3-opus",
                     "display_name": "Claude 3 Opus",
                     "description": "Anthropic Claude 3 Opus model",
-                    "supports_thinking": true,
-                    "supports_reasoning_effort": false
+                    "supports_thinking": true
                 }
-            ],
-            "token_usage": {
-                "enabled": true
-            }
+            ]
         }
         ```
     """
+    config = get_app_config()
     models = [
         ModelResponse(
             name=model.name,
@@ -84,10 +70,7 @@ async def list_models(config: AppConfig = Depends(get_config)) -> ModelsListResp
         )
         for model in config.models
     ]
-    return ModelsListResponse(
-        models=models,
-        token_usage=TokenUsageResponse(enabled=config.token_usage.enabled),
-    )
+    return ModelsListResponse(models=models)
 
 
 @router.get(
@@ -96,7 +79,7 @@ async def list_models(config: AppConfig = Depends(get_config)) -> ModelsListResp
     summary="Get Model Details",
     description="Retrieve detailed information about a specific AI model by its name.",
 )
-async def get_model(model_name: str, config: AppConfig = Depends(get_config)) -> ModelResponse:
+async def get_model(model_name: str) -> ModelResponse:
     """Get a specific model by name.
 
     Args:
@@ -118,6 +101,7 @@ async def get_model(model_name: str, config: AppConfig = Depends(get_config)) ->
         }
         ```
     """
+    config = get_app_config()
     model = config.get_model_config(model_name)
     if model is None:
         raise HTTPException(status_code=404, detail=f"Model '{model_name}' not found")

backend/app/gateway/routers/runs.py

@@ -11,11 +11,10 @@ import asyncio
 import logging
 import uuid
 
-from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi import APIRouter, Request
 from fastapi.responses import StreamingResponse
 
-from app.gateway.authz import require_permission
-from app.gateway.deps import get_checkpointer, get_feedback_repo, get_run_event_store, get_run_manager, get_run_store, get_stream_bridge
+from app.gateway.deps import get_checkpointer, get_run_manager, get_stream_bridge
 from app.gateway.routers.thread_runs import RunCreateRequest
 from app.gateway.services import sse_consumer, start_run
 from deerflow.runtime import serialize_channel_values
@@ -86,57 +85,3 @@ async def stateless_wait(body: RunCreateRequest, request: Request) -> dict:
         logger.exception("Failed to fetch final state for run %s", record.run_id)
 
     return {"status": record.status.value, "error": record.error}
-
-
-# ---------------------------------------------------------------------------
-# Run-scoped read endpoints
-# ---------------------------------------------------------------------------
-
-
-async def _resolve_run(run_id: str, request: Request) -> dict:
-    """Fetch run by run_id with user ownership check. Raises 404 if not found."""
-    run_store = get_run_store(request)
-    record = await run_store.get(run_id)  # user_id=AUTO filters by contextvar
-    if record is None:
-        raise HTTPException(status_code=404, detail=f"Run {run_id} not found")
-    return record
-
-
-@router.get("/{run_id}/messages")
-@require_permission("runs", "read")
-async def run_messages(
-    run_id: str,
-    request: Request,
-    limit: int = Query(default=50, le=200, ge=1),
-    before_seq: int | None = Query(default=None),
-    after_seq: int | None = Query(default=None),
-) -> dict:
-    """Return paginated messages for a run (cursor-based).
-
-    Pagination:
-    - after_seq: messages with seq > after_seq (forward)
-    - before_seq: messages with seq < before_seq (backward)
-    - neither: latest messages
-
-    Response: { data: [...], has_more: bool }
-    """
-    run = await _resolve_run(run_id, request)
-    event_store = get_run_event_store(request)
-    rows = await event_store.list_messages_by_run(
-        run["thread_id"], run_id,
-        limit=limit + 1,
-        before_seq=before_seq,
-        after_seq=after_seq,
-    )
-    has_more = len(rows) > limit
-    data = rows[:limit] if has_more else rows
-    return {"data": data, "has_more": has_more}
-
-
-@router.get("/{run_id}/feedback")
-@require_permission("runs", "read")
-async def run_feedback(run_id: str, request: Request) -> list[dict]:
-    """Return all feedback for a run."""
-    run = await _resolve_run(run_id, request)
-    feedback_repo = get_feedback_repo(request)
-    return await feedback_repo.list_by_run(run["thread_id"], run_id)

backend/app/gateway/routers/skills.py

@@ -1,17 +1,14 @@
-import errno
 import json
 import logging
 import shutil
 from pathlib import Path
 
-from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
-from app.gateway.deps import get_config
 from app.gateway.path_utils import resolve_thread_virtual_path
-from deerflow.agents.lead_agent.prompt import refresh_skills_system_prompt_cache_async
-from deerflow.config.app_config import AppConfig
-from deerflow.config.extensions_config import ExtensionsConfig
+from deerflow.agents.lead_agent.prompt import clear_skills_system_prompt_cache
+from deerflow.config.extensions_config import ExtensionsConfig, SkillStateConfig, get_extensions_config, reload_extensions_config
 from deerflow.skills import Skill, load_skills
 from deerflow.skills.installer import SkillAlreadyExistsError, install_skill_from_archive
 from deerflow.skills.manager import (
@@ -103,9 +100,9 @@ def _skill_to_response(skill: Skill) -> SkillResponse:
     summary="List All Skills",
     description="Retrieve a list of all available skills from both public and custom directories.",
 )
-async def list_skills(app_config: AppConfig = Depends(get_config)) -> SkillsListResponse:
+async def list_skills() -> SkillsListResponse:
     try:
-        skills = load_skills(app_config, enabled_only=False)
+        skills = load_skills(enabled_only=False)
         return SkillsListResponse(skills=[_skill_to_response(skill) for skill in skills])
     except Exception as e:
         logger.error(f"Failed to load skills: {e}", exc_info=True)
@@ -118,11 +115,10 @@ async def list_skills(app_config: AppConfig = Depends(get_config)) -> SkillsList
     summary="Install Skill",
     description="Install a skill from a .skill file (ZIP archive) located in the thread's user-data directory.",
 )
-async def install_skill(request: SkillInstallRequest, app_config: AppConfig = Depends(get_config)) -> SkillInstallResponse:
+async def install_skill(request: SkillInstallRequest) -> SkillInstallResponse:
     try:
         skill_file_path = resolve_thread_virtual_path(request.thread_id, request.path)
         result = install_skill_from_archive(skill_file_path)
-        await refresh_skills_system_prompt_cache_async(app_config)
         return SkillInstallResponse(**result)
     except FileNotFoundError as e:
         raise HTTPException(status_code=404, detail=str(e))
@@ -138,9 +134,9 @@ async def install_skill(request: SkillInstallRequest, app_config: AppConfig = De
 
 
 @router.get("/skills/custom", response_model=SkillsListResponse, summary="List Custom Skills")
-async def list_custom_skills(app_config: AppConfig = Depends(get_config)) -> SkillsListResponse:
+async def list_custom_skills() -> SkillsListResponse:
     try:
-        skills = [skill for skill in load_skills(app_config, enabled_only=False) if skill.category == "custom"]
+        skills = [skill for skill in load_skills(enabled_only=False) if skill.category == "custom"]
         return SkillsListResponse(skills=[_skill_to_response(skill) for skill in skills])
     except Exception as e:
         logger.error("Failed to list custom skills: %s", e, exc_info=True)
@@ -148,13 +144,13 @@ async def list_custom_skills(app_config: AppConfig = Depends(get_config)) -> Ski
 
 
 @router.get("/skills/custom/{skill_name}", response_model=CustomSkillContentResponse, summary="Get Custom Skill Content")
-async def get_custom_skill(skill_name: str, app_config: AppConfig = Depends(get_config)) -> CustomSkillContentResponse:
+async def get_custom_skill(skill_name: str) -> CustomSkillContentResponse:
     try:
-        skills = load_skills(app_config, enabled_only=False)
+        skills = load_skills(enabled_only=False)
         skill = next((s for s in skills if s.name == skill_name and s.category == "custom"), None)
         if skill is None:
             raise HTTPException(status_code=404, detail=f"Custom skill '{skill_name}' not found")
-        return CustomSkillContentResponse(**_skill_to_response(skill).model_dump(), content=read_custom_skill_content(skill_name, app_config))
+        return CustomSkillContentResponse(**_skill_to_response(skill).model_dump(), content=read_custom_skill_content(skill_name))
     except HTTPException:
         raise
     except Exception as e:
@@ -163,18 +159,14 @@ async def get_custom_skill(skill_name: str, app_config: AppConfig = Depends(get_
 
 
 @router.put("/skills/custom/{skill_name}", response_model=CustomSkillContentResponse, summary="Edit Custom Skill")
-async def update_custom_skill(
-    skill_name: str,
-    request: CustomSkillUpdateRequest,
-    app_config: AppConfig = Depends(get_config),
-) -> CustomSkillContentResponse:
+async def update_custom_skill(skill_name: str, request: CustomSkillUpdateRequest) -> CustomSkillContentResponse:
     try:
-        ensure_custom_skill_is_editable(skill_name, app_config)
+        ensure_custom_skill_is_editable(skill_name)
         validate_skill_markdown_content(skill_name, request.content)
-        scan = await scan_skill_content(app_config, request.content, executable=False, location=f"{skill_name}/SKILL.md")
+        scan = await scan_skill_content(request.content, executable=False, location=f"{skill_name}/SKILL.md")
         if scan.decision == "block":
             raise HTTPException(status_code=400, detail=f"Security scan blocked the edit: {scan.reason}")
-        skill_file = get_custom_skill_dir(skill_name, app_config) / "SKILL.md"
+        skill_file = get_custom_skill_dir(skill_name) / "SKILL.md"
         prev_content = skill_file.read_text(encoding="utf-8")
         atomic_write(skill_file, request.content)
         append_history(
@@ -188,10 +180,9 @@ async def update_custom_skill(
                 "new_content": request.content,
                 "scanner": {"decision": scan.decision, "reason": scan.reason},
             },
-            app_config,
         )
-        await refresh_skills_system_prompt_cache_async(app_config)
-        return await get_custom_skill(skill_name, app_config)
+        clear_skills_system_prompt_cache()
+        return await get_custom_skill(skill_name)
     except HTTPException:
         raise
     except FileNotFoundError as e:
@@ -204,31 +195,25 @@ async def update_custom_skill(
 
 
 @router.delete("/skills/custom/{skill_name}", summary="Delete Custom Skill")
-async def delete_custom_skill(skill_name: str, app_config: AppConfig = Depends(get_config)) -> dict[str, bool]:
+async def delete_custom_skill(skill_name: str) -> dict[str, bool]:
     try:
-        ensure_custom_skill_is_editable(skill_name, app_config)
-        skill_dir = get_custom_skill_dir(skill_name, app_config)
-        prev_content = read_custom_skill_content(skill_name, app_config)
-        try:
-            append_history(
-                skill_name,
-                {
-                    "action": "human_delete",
-                    "author": "human",
-                    "thread_id": None,
-                    "file_path": "SKILL.md",
-                    "prev_content": prev_content,
-                    "new_content": None,
-                    "scanner": {"decision": "allow", "reason": "Deletion requested."},
-                },
-                app_config,
-            )
-        except OSError as e:
-            if not isinstance(e, PermissionError) and e.errno not in {errno.EACCES, errno.EPERM, errno.EROFS}:
-                raise
-            logger.warning("Skipping delete history write for custom skill %s due to readonly/permission failure; continuing with skill directory removal: %s", skill_name, e)
+        ensure_custom_skill_is_editable(skill_name)
+        skill_dir = get_custom_skill_dir(skill_name)
+        prev_content = read_custom_skill_content(skill_name)
+        append_history(
+            skill_name,
+            {
+                "action": "human_delete",
+                "author": "human",
+                "thread_id": None,
+                "file_path": "SKILL.md",
+                "prev_content": prev_content,
+                "new_content": None,
+                "scanner": {"decision": "allow", "reason": "Deletion requested."},
+            },
+        )
         shutil.rmtree(skill_dir)
-        await refresh_skills_system_prompt_cache_async(app_config)
+        clear_skills_system_prompt_cache()
         return {"success": True}
     except FileNotFoundError as e:
         raise HTTPException(status_code=404, detail=str(e))
@@ -240,11 +225,11 @@ async def delete_custom_skill(skill_name: str, app_config: AppConfig = Depends(g
 
 
 @router.get("/skills/custom/{skill_name}/history", response_model=CustomSkillHistoryResponse, summary="Get Custom Skill History")
-async def get_custom_skill_history(skill_name: str, app_config: AppConfig = Depends(get_config)) -> CustomSkillHistoryResponse:
+async def get_custom_skill_history(skill_name: str) -> CustomSkillHistoryResponse:
     try:
-        if not custom_skill_exists(skill_name, app_config) and not get_skill_history_file(skill_name, app_config).exists():
+        if not custom_skill_exists(skill_name) and not get_skill_history_file(skill_name).exists():
             raise HTTPException(status_code=404, detail=f"Custom skill '{skill_name}' not found")
-        return CustomSkillHistoryResponse(history=read_history(skill_name, app_config))
+        return CustomSkillHistoryResponse(history=read_history(skill_name))
     except HTTPException:
         raise
     except Exception as e:
@@ -253,15 +238,11 @@ async def get_custom_skill_history(skill_name: str, app_config: AppConfig = Depe
 
 
 @router.post("/skills/custom/{skill_name}/rollback", response_model=CustomSkillContentResponse, summary="Rollback Custom Skill")
-async def rollback_custom_skill(
-    skill_name: str,
-    request: SkillRollbackRequest,
-    app_config: AppConfig = Depends(get_config),
-) -> CustomSkillContentResponse:
+async def rollback_custom_skill(skill_name: str, request: SkillRollbackRequest) -> CustomSkillContentResponse:
     try:
-        if not custom_skill_exists(skill_name, app_config) and not get_skill_history_file(skill_name, app_config).exists():
+        if not custom_skill_exists(skill_name) and not get_skill_history_file(skill_name).exists():
             raise HTTPException(status_code=404, detail=f"Custom skill '{skill_name}' not found")
-        history = read_history(skill_name, app_config)
+        history = read_history(skill_name)
         if not history:
             raise HTTPException(status_code=400, detail=f"Custom skill '{skill_name}' has no history")
         record = history[request.history_index]
@@ -269,8 +250,8 @@ async def rollback_custom_skill(
         if target_content is None:
             raise HTTPException(status_code=400, detail="Selected history entry has no previous content to roll back to")
         validate_skill_markdown_content(skill_name, target_content)
-        scan = await scan_skill_content(app_config, target_content, executable=False, location=f"{skill_name}/SKILL.md")
-        skill_file = get_custom_skill_file(skill_name, app_config)
+        scan = await scan_skill_content(target_content, executable=False, location=f"{skill_name}/SKILL.md")
+        skill_file = get_custom_skill_file(skill_name)
         current_content = skill_file.read_text(encoding="utf-8") if skill_file.exists() else None
         history_entry = {
             "action": "rollback",
@@ -283,12 +264,12 @@ async def rollback_custom_skill(
             "scanner": {"decision": scan.decision, "reason": scan.reason},
         }
         if scan.decision == "block":
-            append_history(skill_name, history_entry, app_config)
+            append_history(skill_name, history_entry)
             raise HTTPException(status_code=400, detail=f"Rollback blocked by security scanner: {scan.reason}")
         atomic_write(skill_file, target_content)
-        append_history(skill_name, history_entry, app_config)
-        await refresh_skills_system_prompt_cache_async(app_config)
-        return await get_custom_skill(skill_name, app_config)
+        append_history(skill_name, history_entry)
+        clear_skills_system_prompt_cache()
+        return await get_custom_skill(skill_name)
     except HTTPException:
         raise
     except IndexError:
@@ -308,9 +289,9 @@ async def rollback_custom_skill(
     summary="Get Skill Details",
     description="Retrieve detailed information about a specific skill by its name.",
 )
-async def get_skill(skill_name: str, app_config: AppConfig = Depends(get_config)) -> SkillResponse:
+async def get_skill(skill_name: str) -> SkillResponse:
     try:
-        skills = load_skills(app_config, enabled_only=False)
+        skills = load_skills(enabled_only=False)
         skill = next((s for s in skills if s.name == skill_name), None)
 
         if skill is None:
@@ -330,14 +311,9 @@ async def get_skill(skill_name: str, app_config: AppConfig = Depends(get_config)
     summary="Update Skill",
     description="Update a skill's enabled status by modifying the extensions_config.json file.",
 )
-async def update_skill(
-    skill_name: str,
-    request: SkillUpdateRequest,
-    http_request: Request,
-    app_config: AppConfig = Depends(get_config),
-) -> SkillResponse:
+async def update_skill(skill_name: str, request: SkillUpdateRequest) -> SkillResponse:
     try:
-        skills = load_skills(app_config, enabled_only=False)
+        skills = load_skills(enabled_only=False)
         skill = next((s for s in skills if s.name == skill_name), None)
 
         if skill is None:
@@ -348,29 +324,21 @@ async def update_skill(
             config_path = Path.cwd().parent / "extensions_config.json"
             logger.info(f"No existing extensions config found. Creating new config at: {config_path}")
 
-        # Do not mutate the frozen AppConfig in place. Compose the new skills
-        # state in a fresh dict, write to disk, and reload AppConfig below so
-        # every subsequent Depends(get_config) sees the refreshed snapshot.
-        ext = app_config.extensions
-        updated_skills = {name: {"enabled": skill_config.enabled} for name, skill_config in ext.skills.items()}
-        updated_skills[skill_name] = {"enabled": request.enabled}
+        extensions_config = get_extensions_config()
+        extensions_config.skills[skill_name] = SkillStateConfig(enabled=request.enabled)
 
         config_data = {
-            "mcpServers": {name: server.model_dump() for name, server in ext.mcp_servers.items()},
-            "skills": updated_skills,
+            "mcpServers": {name: server.model_dump() for name, server in extensions_config.mcp_servers.items()},
+            "skills": {name: {"enabled": skill_config.enabled} for name, skill_config in extensions_config.skills.items()},
         }
 
         with open(config_path, "w", encoding="utf-8") as f:
             json.dump(config_data, f, indent=2)
 
         logger.info(f"Skills configuration updated and saved to: {config_path}")
-        # Reload AppConfig and swap ``app.state.config`` so subsequent
-        # ``Depends(get_config)`` sees the refreshed value.
-        reloaded = AppConfig.from_file()
-        http_request.app.state.config = reloaded
-        await refresh_skills_system_prompt_cache_async(reloaded)
+        reload_extensions_config()
 
-        skills = load_skills(reloaded, enabled_only=False)
+        skills = load_skills(enabled_only=False)
         updated_skill = next((s for s in skills if s.name == skill_name), None)
 
         if updated_skill is None:

backend/app/gateway/routers/suggestions.py

@@ -1,13 +1,11 @@
 import json
 import logging
 
-from fastapi import APIRouter, Depends, Request
+from fastapi import APIRouter, Request
 from langchain_core.messages import HumanMessage, SystemMessage
 from pydantic import BaseModel, Field
 
 from app.gateway.authz import require_permission
-from app.gateway.deps import get_config
-from deerflow.config.app_config import AppConfig
 from deerflow.models import create_chat_model
 
 logger = logging.getLogger(__name__)
@@ -102,7 +100,7 @@ def _format_conversation(messages: list[SuggestionMessage]) -> str:
     description="Generate short follow-up questions a user might ask next, based on recent conversation context.",
 )
 @require_permission("threads", "read", owner_check=True)
-async def generate_suggestions(thread_id: str, body: SuggestionsRequest, request: Request, app_config: AppConfig = Depends(get_config)) -> SuggestionsResponse:
+async def generate_suggestions(thread_id: str, body: SuggestionsRequest, request: Request) -> SuggestionsResponse:
     if not body.messages:
         return SuggestionsResponse(suggestions=[])
 
@@ -124,8 +122,8 @@ async def generate_suggestions(thread_id: str, body: SuggestionsRequest, request
     user_content = f"Conversation Context:\n{conversation}\n\nGenerate {n} follow-up questions"
 
     try:
-        model = create_chat_model(name=body.model_name, thinking_enabled=False, app_config=app_config)
-        response = await model.ainvoke([SystemMessage(content=system_instruction), HumanMessage(content=user_content)], config={"run_name": "suggest_agent"})
+        model = create_chat_model(name=body.model_name, thinking_enabled=False)
+        response = await model.ainvoke([SystemMessage(content=system_instruction), HumanMessage(content=user_content)])
         raw = _extract_response_text(response.content)
         suggestions = _parse_json_string_list(raw) or []
         cleaned = [s.replace("\n", " ").strip() for s in suggestions if s.strip()]

backend/app/gateway/routers/thread_runs.py

@@ -20,7 +20,7 @@ from fastapi.responses import Response, StreamingResponse
 from pydantic import BaseModel, Field
 
 from app.gateway.authz import require_permission
-from app.gateway.deps import get_checkpointer, get_current_user, get_feedback_repo, get_run_event_store, get_run_manager, get_run_store, get_stream_bridge
+from app.gateway.deps import get_checkpointer, get_run_event_store, get_run_manager, get_run_store, get_stream_bridge
 from app.gateway.services import sse_consumer, start_run
 from deerflow.runtime import RunRecord, serialize_channel_values
 
@@ -94,7 +94,7 @@ def _record_to_response(record: RunRecord) -> RunResponse:
 
 
 @router.post("/{thread_id}/runs", response_model=RunResponse)
-@require_permission("runs", "create", owner_check=True, require_existing=True)
+@require_permission("runs", "create", owner_check=True)
 async def create_run(thread_id: str, body: RunCreateRequest, request: Request) -> RunResponse:
     """Create a background run (returns immediately)."""
     record = await start_run(body, thread_id, request)
@@ -102,7 +102,7 @@ async def create_run(thread_id: str, body: RunCreateRequest, request: Request) -
 
 
 @router.post("/{thread_id}/runs/stream")
-@require_permission("runs", "create", owner_check=True, require_existing=True)
+@require_permission("runs", "create", owner_check=True)
 async def stream_run(thread_id: str, body: RunCreateRequest, request: Request) -> StreamingResponse:
     """Create a run and stream events via SSE.
 
@@ -130,7 +130,7 @@ async def stream_run(thread_id: str, body: RunCreateRequest, request: Request) -
 
 
 @router.post("/{thread_id}/runs/wait", response_model=dict)
-@require_permission("runs", "create", owner_check=True, require_existing=True)
+@require_permission("runs", "create", owner_check=True)
 async def wait_run(thread_id: str, body: RunCreateRequest, request: Request) -> dict:
     """Create a run and block until it completes, returning the final state."""
     record = await start_run(body, thread_id, request)
@@ -176,7 +176,7 @@ async def get_run(thread_id: str, run_id: str, request: Request) -> RunResponse:
 
 
 @router.post("/{thread_id}/runs/{run_id}/cancel")
-@require_permission("runs", "cancel", owner_check=True, require_existing=True)
+@require_permission("runs", "cancel", owner_check=True)
 async def cancel_run(
     thread_id: str,
     run_id: str,
@@ -291,62 +291,17 @@ async def list_thread_messages(
     before_seq: int | None = Query(default=None),
     after_seq: int | None = Query(default=None),
 ) -> list[dict]:
-    """Return displayable messages for a thread (across all runs), with feedback attached."""
+    """Return displayable messages for a thread (across all runs)."""
     event_store = get_run_event_store(request)
-    messages = await event_store.list_messages(thread_id, limit=limit, before_seq=before_seq, after_seq=after_seq)
-
-    # Attach feedback to the last AI message of each run
-    feedback_repo = get_feedback_repo(request)
-    user_id = await get_current_user(request)
-    feedback_map = await feedback_repo.list_by_thread_grouped(thread_id, user_id=user_id)
-
-    # Find the last ai_message per run_id
-    last_ai_per_run: dict[str, int] = {}  # run_id -> index in messages list
-    for i, msg in enumerate(messages):
-        if msg.get("event_type") == "ai_message":
-            last_ai_per_run[msg["run_id"]] = i
-
-    # Attach feedback field
-    last_ai_indices = set(last_ai_per_run.values())
-    for i, msg in enumerate(messages):
-        if i in last_ai_indices:
-            run_id = msg["run_id"]
-            fb = feedback_map.get(run_id)
-            msg["feedback"] = {
-                "feedback_id": fb["feedback_id"],
-                "rating": fb["rating"],
-                "comment": fb.get("comment"),
-            } if fb else None
-        else:
-            msg["feedback"] = None
-
-    return messages
+    return await event_store.list_messages(thread_id, limit=limit, before_seq=before_seq, after_seq=after_seq)
 
 
 @router.get("/{thread_id}/runs/{run_id}/messages")
 @require_permission("runs", "read", owner_check=True)
-async def list_run_messages(
-    thread_id: str,
-    run_id: str,
-    request: Request,
-    limit: int = Query(default=50, le=200, ge=1),
-    before_seq: int | None = Query(default=None),
-    after_seq: int | None = Query(default=None),
-) -> dict:
-    """Return paginated messages for a specific run.
-
-    Response: { data: [...], has_more: bool }
-    """
+async def list_run_messages(thread_id: str, run_id: str, request: Request) -> list[dict]:
+    """Return displayable messages for a specific run."""
     event_store = get_run_event_store(request)
-    rows = await event_store.list_messages_by_run(
-        thread_id, run_id,
-        limit=limit + 1,
-        before_seq=before_seq,
-        after_seq=after_seq,
-    )
-    has_more = len(rows) > limit
-    data = rows[:limit] if has_more else rows
-    return {"data": data, "has_more": has_more}
+    return await event_store.list_messages_by_run(thread_id, run_id)
 
 
 @router.get("/{thread_id}/runs/{run_id}/events")

backend/app/gateway/routers/threads.py

@@ -13,41 +13,23 @@ matching the LangGraph Platform wire format expected by the
 from __future__ import annotations
 
 import logging
-import re
 import time
 import uuid
 from typing import Any
 
 from fastapi import APIRouter, HTTPException, Request
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field
 
 from app.gateway.authz import require_permission
 from app.gateway.deps import get_checkpointer
 from app.gateway.utils import sanitize_log_param
 from deerflow.config.paths import Paths, get_paths
 from deerflow.runtime import serialize_channel_values
-from deerflow.runtime.user_context import get_effective_user_id
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/threads", tags=["threads"])
 
 
-# Metadata keys that the server controls; clients are not allowed to set
-# them. Pydantic ``@field_validator("metadata")`` strips them on every
-# inbound model below so a malicious client cannot reflect a forged
-# owner identity through the API surface. Defense-in-depth — the
-# row-level invariant is still ``threads_meta.user_id`` populated from
-# the auth contextvar; this list closes the metadata-blob echo gap.
-_SERVER_RESERVED_METADATA_KEYS: frozenset[str] = frozenset({"owner_id", "user_id"})
-
-
-def _strip_reserved_metadata(metadata: dict[str, Any] | None) -> dict[str, Any]:
-    """Return ``metadata`` with server-controlled keys removed."""
-    if not metadata:
-        return metadata or {}
-    return {k: v for k, v in metadata.items() if k not in _SERVER_RESERVED_METADATA_KEYS}
-
-
 # ---------------------------------------------------------------------------
 # Response / request models
 # ---------------------------------------------------------------------------
@@ -79,8 +61,6 @@ class ThreadCreateRequest(BaseModel):
     assistant_id: str | None = Field(default=None, description="Associate thread with an assistant")
     metadata: dict[str, Any] = Field(default_factory=dict, description="Initial metadata")
 
-    _strip_reserved = field_validator("metadata")(classmethod(lambda cls, v: _strip_reserved_metadata(v)))
-
 
 class ThreadSearchRequest(BaseModel):
     """Request body for searching threads."""
@@ -109,8 +89,6 @@ class ThreadPatchRequest(BaseModel):
 
     metadata: dict[str, Any] = Field(default_factory=dict, description="Metadata to merge")
 
-    _strip_reserved = field_validator("metadata")(classmethod(lambda cls, v: _strip_reserved_metadata(v)))
-
 
 class ThreadStateUpdateRequest(BaseModel):
     """Request body for updating thread state (human-in-the-loop resume)."""
@@ -144,11 +122,11 @@ class ThreadHistoryRequest(BaseModel):
 # ---------------------------------------------------------------------------
 
 
-def _delete_thread_data(thread_id: str, paths: Paths | None = None, *, user_id: str | None = None) -> ThreadDeleteResponse:
+def _delete_thread_data(thread_id: str, paths: Paths | None = None) -> ThreadDeleteResponse:
     """Delete local persisted filesystem data for a thread."""
     path_manager = paths or get_paths()
     try:
-        path_manager.delete_thread_dir(thread_id, user_id=user_id)
+        path_manager.delete_thread_dir(thread_id)
     except ValueError as exc:
         raise HTTPException(status_code=422, detail=str(exc)) from exc
     except FileNotFoundError:
@@ -188,7 +166,7 @@ def _derive_thread_status(checkpoint_tuple) -> str:
 
 
 @router.delete("/{thread_id}", response_model=ThreadDeleteResponse)
-@require_permission("threads", "delete", owner_check=True, require_existing=True)
+@require_permission("threads", "delete", owner_check=True)
 async def delete_thread_data(thread_id: str, request: Request) -> ThreadDeleteResponse:
     """Delete local persisted filesystem data for a thread.
 
@@ -196,10 +174,10 @@ async def delete_thread_data(thread_id: str, request: Request) -> ThreadDeleteRe
     and removes the thread_meta row from the configured ThreadMetaStore
     (sqlite or memory).
     """
-    from app.gateway.deps import get_thread_store
+    from app.gateway.deps import get_thread_meta_repo
 
     # Clean local filesystem
-    response = _delete_thread_data(thread_id, user_id=get_effective_user_id())
+    response = _delete_thread_data(thread_id)
 
     # Remove checkpoints (best-effort)
     checkpointer = getattr(request.app.state, "checkpointer", None)
@@ -213,8 +191,8 @@ async def delete_thread_data(thread_id: str, request: Request) -> ThreadDeleteRe
     # Remove thread_meta row (best-effort) — required for sqlite backend
     # so the deleted thread no longer appears in /threads/search.
     try:
-        thread_store = get_thread_store(request)
-        await thread_store.delete(thread_id)
+        thread_meta_repo = get_thread_meta_repo(request)
+        await thread_meta_repo.delete(thread_id)
     except Exception:
         logger.debug("Could not delete thread_meta for %s (not critical)", sanitize_log_param(thread_id))
 
@@ -229,17 +207,15 @@ async def create_thread(body: ThreadCreateRequest, request: Request) -> ThreadRe
     and an empty checkpoint (so state endpoints work immediately).
     Idempotent: returns the existing record when ``thread_id`` already exists.
     """
-    from app.gateway.deps import get_thread_store
+    from app.gateway.deps import get_thread_meta_repo
 
     checkpointer = get_checkpointer(request)
-    thread_store = get_thread_store(request)
+    thread_meta_repo = get_thread_meta_repo(request)
     thread_id = body.thread_id or str(uuid.uuid4())
     now = time.time()
-    # ``body.metadata`` is already stripped of server-reserved keys by
-    # ``ThreadCreateRequest._strip_reserved`` — see the model definition.
 
     # Idempotency: return existing record when already present
-    existing_record = await thread_store.get(thread_id)
+    existing_record = await thread_meta_repo.get(thread_id)
     if existing_record is not None:
         return ThreadResponse(
             thread_id=thread_id,
@@ -251,7 +227,7 @@ async def create_thread(body: ThreadCreateRequest, request: Request) -> ThreadRe
 
     # Write thread_meta so the thread appears in /threads/search immediately
     try:
-        await thread_store.create(
+        await thread_meta_repo.create(
             thread_id,
             assistant_id=getattr(body, "assistant_id", None),
             metadata=body.metadata,
@@ -295,9 +271,9 @@ async def search_threads(body: ThreadSearchRequest, request: Request) -> list[Th
     Delegates to the configured ThreadMetaStore implementation
     (SQL-backed for sqlite/postgres, Store-backed for memory mode).
     """
-    from app.gateway.deps import get_thread_store
+    from app.gateway.deps import get_thread_meta_repo
 
-    repo = get_thread_store(request)
+    repo = get_thread_meta_repo(request)
     rows = await repo.search(
         metadata=body.metadata or None,
         status=body.status,
@@ -319,25 +295,24 @@ async def search_threads(body: ThreadSearchRequest, request: Request) -> list[Th
 
 
 @router.patch("/{thread_id}", response_model=ThreadResponse)
-@require_permission("threads", "write", owner_check=True, require_existing=True)
+@require_permission("threads", "write", owner_check=True)
 async def patch_thread(thread_id: str, body: ThreadPatchRequest, request: Request) -> ThreadResponse:
     """Merge metadata into a thread record."""
-    from app.gateway.deps import get_thread_store
+    from app.gateway.deps import get_thread_meta_repo
 
-    thread_store = get_thread_store(request)
-    record = await thread_store.get(thread_id)
+    thread_meta_repo = get_thread_meta_repo(request)
+    record = await thread_meta_repo.get(thread_id)
     if record is None:
         raise HTTPException(status_code=404, detail=f"Thread {thread_id} not found")
 
-    # ``body.metadata`` already stripped by ``ThreadPatchRequest._strip_reserved``.
     try:
-        await thread_store.update_metadata(thread_id, body.metadata)
+        await thread_meta_repo.update_metadata(thread_id, body.metadata)
     except Exception:
         logger.exception("Failed to patch thread %s", sanitize_log_param(thread_id))
         raise HTTPException(status_code=500, detail="Failed to update thread")
 
     # Re-read to get the merged metadata + refreshed updated_at
-    record = await thread_store.get(thread_id) or record
+    record = await thread_meta_repo.get(thread_id) or record
     return ThreadResponse(
         thread_id=thread_id,
         status=record.get("status", "idle"),
@@ -356,12 +331,12 @@ async def get_thread(thread_id: str, request: Request) -> ThreadResponse:
     execution status from the checkpointer.  Falls back to the checkpointer
     alone for threads that pre-date ThreadMetaStore adoption (backward compat).
     """
-    from app.gateway.deps import get_thread_store
+    from app.gateway.deps import get_thread_meta_repo
 
-    thread_store = get_thread_store(request)
+    thread_meta_repo = get_thread_meta_repo(request)
     checkpointer = get_checkpointer(request)
 
-    record: dict | None = await thread_store.get(thread_id)
+    record: dict | None = await thread_meta_repo.get(thread_id)
 
     # Derive accurate status from the checkpointer
     config = {"configurable": {"thread_id": thread_id, "checkpoint_ns": ""}}
@@ -404,7 +379,6 @@ async def get_thread(thread_id: str, request: Request) -> ThreadResponse:
     )
 
 
-# ---------------------------------------------------------------------------
 @router.get("/{thread_id}/state", response_model=ThreadStateResponse)
 @require_permission("threads", "read", owner_check=True)
 async def get_thread_state(thread_id: str, request: Request) -> ThreadStateResponse:
@@ -443,10 +417,8 @@ async def get_thread_state(thread_id: str, request: Request) -> ThreadStateRespo
     next_tasks = [t.name for t in tasks_raw if hasattr(t, "name")]
     tasks = [{"id": getattr(t, "id", ""), "name": getattr(t, "name", "")} for t in tasks_raw]
 
-    values = serialize_channel_values(channel_values)
-
     return ThreadStateResponse(
-        values=values,
+        values=serialize_channel_values(channel_values),
         next=next_tasks,
         metadata=metadata,
         checkpoint={"id": checkpoint_id, "ts": str(metadata.get("created_at", ""))},
@@ -458,7 +430,7 @@ async def get_thread_state(thread_id: str, request: Request) -> ThreadStateRespo
 
 
 @router.post("/{thread_id}/state", response_model=ThreadStateResponse)
-@require_permission("threads", "write", owner_check=True, require_existing=True)
+@require_permission("threads", "write", owner_check=True)
 async def update_thread_state(thread_id: str, body: ThreadStateUpdateRequest, request: Request) -> ThreadStateResponse:
     """Update thread state (e.g. for human-in-the-loop resume or title rename).
 
@@ -467,10 +439,10 @@ async def update_thread_state(thread_id: str, body: ThreadStateUpdateRequest, re
     ThreadMetaStore abstraction so that ``/threads/search`` reflects the
     change immediately in both sqlite and memory backends.
     """
-    from app.gateway.deps import get_thread_store
+    from app.gateway.deps import get_thread_meta_repo
 
     checkpointer = get_checkpointer(request)
-    thread_store = get_thread_store(request)
+    thread_meta_repo = get_thread_meta_repo(request)
 
     # checkpoint_ns must be present in the config for aput — default to ""
     # (the root graph namespace).  checkpoint_id is optional; omitting it
@@ -534,7 +506,7 @@ async def update_thread_state(thread_id: str, body: ThreadStateUpdateRequest, re
         new_title = body.values["title"]
         if new_title:  # Skip empty strings and None
             try:
-                await thread_store.update_display_name(thread_id, new_title)
+                await thread_meta_repo.update_display_name(thread_id, new_title)
             except Exception:
                 logger.debug("Failed to sync title to thread_meta for %s (non-fatal)", sanitize_log_param(thread_id))
 
@@ -587,7 +559,7 @@ async def get_thread_history(thread_id: str, body: ThreadHistoryRequest, request
             if thread_data := channel_values.get("thread_data"):
                 values["thread_data"] = thread_data
 
-            # Attach messages only to the latest checkpoint entry.
+            # Attach messages from checkpointer only for the latest checkpoint
             if is_latest_checkpoint:
                 messages = channel_values.get("messages")
                 if messages:

backend/app/gateway/routers/uploads.py

@@ -4,15 +4,12 @@ import logging
 import os
 import stat
 
-from fastapi import APIRouter, Depends, File, HTTPException, Request, UploadFile
+from fastapi import APIRouter, File, HTTPException, Request, UploadFile
 from pydantic import BaseModel
 
 from app.gateway.authz import require_permission
-from app.gateway.deps import get_config
-from deerflow.config.app_config import AppConfig
 from deerflow.config.paths import get_paths
-from deerflow.runtime.user_context import get_effective_user_id
-from deerflow.sandbox.sandbox_provider import SandboxProvider, get_sandbox_provider
+from deerflow.sandbox.sandbox_provider import get_sandbox_provider
 from deerflow.uploads.manager import (
     PathTraversalError,
     delete_file_safe,
@@ -57,40 +54,12 @@ def _make_file_sandbox_writable(file_path: os.PathLike[str] | str) -> None:
     os.chmod(file_path, writable_mode, **chmod_kwargs)
 
 
-def _uses_thread_data_mounts(sandbox_provider: SandboxProvider) -> bool:
-    return bool(getattr(sandbox_provider, "uses_thread_data_mounts", False))
-
-
-def _get_uploads_config_value(app_config: AppConfig, key: str, default: object) -> object:
-    """Read a value from the uploads config, supporting dict and attribute access."""
-    uploads_cfg = getattr(app_config, "uploads", None)
-    if isinstance(uploads_cfg, dict):
-        return uploads_cfg.get(key, default)
-    return getattr(uploads_cfg, key, default)
-
-
-def _auto_convert_documents_enabled(app_config: AppConfig) -> bool:
-    """Return whether automatic host-side document conversion is enabled.
-
-    The secure default is disabled unless an operator explicitly opts in via
-    uploads.auto_convert_documents in config.yaml.
-    """
-    try:
-        raw = _get_uploads_config_value(app_config, "auto_convert_documents", False)
-        if isinstance(raw, str):
-            return raw.strip().lower() in {"1", "true", "yes", "on"}
-        return bool(raw)
-    except Exception:
-        return False
-
-
 @router.post("", response_model=UploadResponse)
-@require_permission("threads", "write", owner_check=True, require_existing=True)
+@require_permission("threads", "write", owner_check=True)
 async def upload_files(
     thread_id: str,
     request: Request,
     files: list[UploadFile] = File(...),
-    app_config: AppConfig = Depends(get_config),
 ) -> UploadResponse:
     """Upload multiple files to a thread's uploads directory."""
     if not files:
@@ -100,16 +69,12 @@ async def upload_files(
         uploads_dir = ensure_uploads_dir(thread_id)
     except ValueError as e:
         raise HTTPException(status_code=400, detail=str(e))
-    sandbox_uploads = get_paths().sandbox_uploads_dir(thread_id, user_id=get_effective_user_id())
+    sandbox_uploads = get_paths().sandbox_uploads_dir(thread_id)
     uploaded_files = []
 
-    sandbox_provider = get_sandbox_provider(app_config)
-    sync_to_sandbox = not _uses_thread_data_mounts(sandbox_provider)
-    sandbox = None
-    if sync_to_sandbox:
-        sandbox_id = sandbox_provider.acquire(thread_id)
-        sandbox = sandbox_provider.get(sandbox_id)
-    auto_convert_documents = _auto_convert_documents_enabled(app_config)
+    sandbox_provider = get_sandbox_provider()
+    sandbox_id = sandbox_provider.acquire(thread_id)
+    sandbox = sandbox_provider.get(sandbox_id)
 
     for file in files:
         if not file.filename:
@@ -128,7 +93,7 @@ async def upload_files(
 
             virtual_path = upload_virtual_path(safe_filename)
 
-            if sync_to_sandbox and sandbox is not None:
+            if sandbox_id != "local":
                 _make_file_sandbox_writable(file_path)
                 sandbox.update_file(virtual_path, content)
 
@@ -143,12 +108,12 @@ async def upload_files(
             logger.info(f"Saved file: {safe_filename} ({len(content)} bytes) to {file_info['path']}")
 
             file_ext = file_path.suffix.lower()
-            if auto_convert_documents and file_ext in CONVERTIBLE_EXTENSIONS:
+            if file_ext in CONVERTIBLE_EXTENSIONS:
                 md_path = await convert_file_to_markdown(file_path)
                 if md_path:
                     md_virtual_path = upload_virtual_path(md_path.name)
 
-                    if sync_to_sandbox and sandbox is not None:
+                    if sandbox_id != "local":
                         _make_file_sandbox_writable(md_path)
                         sandbox.update_file(md_virtual_path, md_path.read_bytes())
 
@@ -182,7 +147,7 @@ async def list_uploaded_files(thread_id: str, request: Request) -> dict:
     enrich_file_listing(result, thread_id)
 
     # Gateway additionally includes the sandbox-relative path.
-    sandbox_uploads = get_paths().sandbox_uploads_dir(thread_id, user_id=get_effective_user_id())
+    sandbox_uploads = get_paths().sandbox_uploads_dir(thread_id)
     for f in result["files"]:
         f["path"] = str(sandbox_uploads / f["filename"])
 
@@ -190,7 +155,7 @@ async def list_uploaded_files(thread_id: str, request: Request) -> dict:
 
 
 @router.delete("/{filename}")
-@require_permission("threads", "delete", owner_check=True, require_existing=True)
+@require_permission("threads", "delete", owner_check=True)
 async def delete_uploaded_file(thread_id: str, filename: str, request: Request) -> dict:
     """Delete a file from a thread's uploads directory."""
     try:

backend/app/gateway/services.py

@@ -12,8 +12,6 @@ import dataclasses
 import json
 import logging
 import re
-import time
-from collections.abc import Mapping
 from typing import Any
 
 from fastapi import HTTPException, Request
@@ -104,10 +102,9 @@ def resolve_agent_factory(assistant_id: str | None):
     """Resolve the agent factory callable from config.
 
     Custom agents are implemented as ``lead_agent`` + an ``agent_name``
-    injected into ``configurable`` or ``context`` — see
-    :func:`build_run_config`.  All ``assistant_id`` values therefore map to the
-    same factory; the routing happens inside ``make_lead_agent`` when it reads
-    ``cfg["agent_name"]``.
+    injected into ``configurable`` — see :func:`build_run_config`.  All
+    ``assistant_id`` values therefore map to the same factory; the routing
+    happens inside ``make_lead_agent`` when it reads ``cfg["agent_name"]``.
     """
     from deerflow.agents.lead_agent.agent import make_lead_agent
 
@@ -124,12 +121,10 @@ def build_run_config(
     """Build a RunnableConfig dict for the agent.
 
     When *assistant_id* refers to a custom agent (anything other than
-    ``"lead_agent"`` / ``None``), the name is forwarded as ``agent_name`` in
-    whichever runtime options container is active: ``context`` for
-    LangGraph >= 0.6.0 requests, otherwise ``configurable``.
-    ``make_lead_agent`` reads this key to load the matching
-    ``agents/<name>/SOUL.md`` and per-agent config — without it the agent
-    silently runs as the default lead agent.
+    ``"lead_agent"`` / ``None``), the name is forwarded as
+    ``configurable["agent_name"]``.  ``make_lead_agent`` reads this key to
+    load the matching ``agents/<name>/SOUL.md`` and per-agent config —
+    without it the agent silently runs as the default lead agent.
 
     This mirrors the channel manager's ``_resolve_run_params`` logic so that
     the LangGraph Platform-compatible HTTP API and the IM channel path behave
@@ -148,14 +143,7 @@ def build_run_config(
                     thread_id,
                     list(request_config.get("configurable", {}).keys()),
                 )
-            context_value = request_config["context"]
-            if context_value is None:
-                context = {}
-            elif isinstance(context_value, Mapping):
-                context = dict(context_value)
-            else:
-                raise ValueError("request config 'context' must be a mapping or null.")
-            config["context"] = context
+            config["context"] = request_config["context"]
         else:
             configurable = {"thread_id": thread_id}
             configurable.update(request_config.get("configurable", {}))
@@ -167,19 +155,13 @@ def build_run_config(
         config["configurable"] = {"thread_id": thread_id}
 
     # Inject custom agent name when the caller specified a non-default assistant.
-    # Honour an explicit agent_name in the active runtime options container.
-    if assistant_id and assistant_id != _DEFAULT_ASSISTANT_ID:
-        normalized = assistant_id.strip().lower().replace("_", "-")
-        if not normalized or not re.fullmatch(r"[a-z0-9-]+", normalized):
-            raise ValueError(f"Invalid assistant_id {assistant_id!r}: must contain only letters, digits, and hyphens after normalization.")
-        if "configurable" in config:
-            target = config["configurable"]
-        elif "context" in config:
-            target = config["context"]
-        else:
-            target = config.setdefault("configurable", {})
-        if target is not None and "agent_name" not in target:
-            target["agent_name"] = normalized
+    # Honour an explicit configurable["agent_name"] in the request if already set.
+    if assistant_id and assistant_id != _DEFAULT_ASSISTANT_ID and "configurable" in config:
+        if "agent_name" not in config["configurable"]:
+            normalized = assistant_id.strip().lower().replace("_", "-")
+            if not normalized or not re.fullmatch(r"[a-z0-9-]+", normalized):
+                raise ValueError(f"Invalid assistant_id {assistant_id!r}: must contain only letters, digits, and hyphens after normalization.")
+            config["configurable"]["agent_name"] = normalized
     if metadata:
         config.setdefault("metadata", {}).update(metadata)
     return config
@@ -247,15 +229,15 @@ async def start_run(
     # even for threads that were never explicitly created via POST /threads
     # (e.g. stateless runs).
     try:
-        existing = await run_ctx.thread_store.get(thread_id)
+        existing = await run_ctx.thread_meta_repo.get(thread_id)
         if existing is None:
-            await run_ctx.thread_store.create(
+            await run_ctx.thread_meta_repo.create(
                 thread_id,
                 assistant_id=body.assistant_id,
                 metadata=body.metadata,
             )
         else:
-            await run_ctx.thread_store.update_status(thread_id, "running")
+            await run_ctx.thread_meta_repo.update_status(thread_id, "running")
     except Exception:
         logger.warning("Failed to upsert thread_meta for %s (non-fatal)", sanitize_log_param(thread_id))
 
@@ -277,8 +259,6 @@ async def start_run(
             "is_plan_mode",
             "subagent_enabled",
             "max_concurrent_subagents",
-            "agent_name",
-            "is_bootstrap",
         }
         configurable = config.setdefault("configurable", {})
         for key in _CONTEXT_CONFIGURABLE_KEYS:
@@ -305,7 +285,7 @@ async def start_run(
     record.task = task
 
     # Title sync is handled by worker.py's finally block which reads the
-    # title from the checkpoint and calls thread_store.update_display_name
+    # title from the checkpoint and calls thread_meta_repo.update_display_name
     # after the run completes.
 
     return record

backend/debug.py

@@ -19,78 +19,24 @@ import asyncio
 import logging
 
 from dotenv import load_dotenv
+from langchain_core.messages import HumanMessage
 
-try:
-    from prompt_toolkit import PromptSession
-    from prompt_toolkit.history import InMemoryHistory
-
-    _HAS_PROMPT_TOOLKIT = True
-except ImportError:
-    _HAS_PROMPT_TOOLKIT = False
+from deerflow.agents import make_lead_agent
 
 load_dotenv()
 
-_LOG_FMT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-_LOG_DATEFMT = "%Y-%m-%d %H:%M:%S"
-
-
-def _logging_level_from_config(name: str) -> int:
-    """Map ``config.yaml`` ``log_level`` string to a ``logging`` level constant."""
-    mapping = logging.getLevelNamesMapping()
-    return mapping.get((name or "info").strip().upper(), logging.INFO)
-
-
-def _setup_logging(log_level: str) -> None:
-    """Send application logs to ``debug.log`` at *log_level*; do not print them on the console.
-
-    Idempotent: any pre-existing handlers on the root logger (e.g. installed by
-    ``logging.basicConfig`` in transitively imported modules) are removed so the
-    debug session output only lands in ``debug.log``.
-    """
-    level = _logging_level_from_config(log_level)
-    root = logging.root
-    for h in list(root.handlers):
-        root.removeHandler(h)
-        h.close()
-    root.setLevel(level)
-
-    file_handler = logging.FileHandler("debug.log", mode="a", encoding="utf-8")
-    file_handler.setLevel(level)
-    file_handler.setFormatter(logging.Formatter(_LOG_FMT, datefmt=_LOG_DATEFMT))
-    root.addHandler(file_handler)
-
-
-def _update_logging_level(log_level: str) -> None:
-    """Update the root logger and existing handlers to *log_level*."""
-    level = _logging_level_from_config(log_level)
-    root = logging.root
-    root.setLevel(level)
-    for handler in root.handlers:
-        handler.setLevel(level)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
 
 
 async def main():
-    # Install file logging first so warnings emitted while loading config do not
-    # leak onto the interactive terminal via Python's lastResort handler.
-    _setup_logging("info")
-
-    from deerflow.config import get_app_config
-
-    app_config = get_app_config()
-    _update_logging_level(app_config.log_level)
-
-    # Delay the rest of the deerflow imports until *after* logging is installed
-    # so that any import-time side effects (e.g. deerflow.agents starts a
-    # background skill-loader thread on import) emit logs to debug.log instead
-    # of leaking onto the interactive terminal via Python's lastResort handler.
-    from langchain_core.messages import HumanMessage
-    from langgraph.runtime import Runtime
-
-    from deerflow.agents import make_lead_agent
-    from deerflow.mcp import initialize_mcp_tools
-
     # Initialize MCP tools at startup
     try:
+        from deerflow.mcp import initialize_mcp_tools
+
         await initialize_mcp_tools()
     except Exception as e:
         print(f"Warning: Failed to initialize MCP tools: {e}")
@@ -106,27 +52,16 @@ async def main():
         }
     }
 
-    runtime = Runtime(context={"thread_id": config["configurable"]["thread_id"]})
-    config["configurable"]["__pregel_runtime"] = runtime
-
     agent = make_lead_agent(config)
 
-    session = PromptSession(history=InMemoryHistory()) if _HAS_PROMPT_TOOLKIT else None
-
     print("=" * 50)
     print("Lead Agent Debug Mode")
     print("Type 'quit' or 'exit' to stop")
-    print(f"Logs: debug.log (log_level={app_config.log_level})")
-    if not _HAS_PROMPT_TOOLKIT:
-        print("Tip: `uv sync --group dev` to enable arrow-key & history support")
     print("=" * 50)
 
     while True:
         try:
-            if session:
-                user_input = (await session.prompt_async("\nYou: ")).strip()
-            else:
-                user_input = input("\nYou: ").strip()
+            user_input = input("\nYou: ").strip()
             if not user_input:
                 continue
             if user_input.lower() in ("quit", "exit"):
@@ -135,15 +70,15 @@ async def main():
 
             # Invoke the agent
             state = {"messages": [HumanMessage(content=user_input)]}
-            result = await agent.ainvoke(state, config=config)
+            result = await agent.ainvoke(state, config=config, context={"thread_id": "debug-thread-001"})
 
             # Print the response
             if result.get("messages"):
                 last_message = result["messages"][-1]
                 print(f"\nAgent: {last_message.content}")
 
-        except (KeyboardInterrupt, EOFError):
-            print("\nGoodbye!")
+        except KeyboardInterrupt:
+            print("\nInterrupted. Goodbye!")
             break
         except Exception as e:
             print(f"\nError: {e}")

backend/docs/API.md

@@ -86,7 +86,6 @@ Content-Type: application/json
     ]
   },
   "config": {
-    "recursion_limit": 100,
     "configurable": {
       "model_name": "gpt-4",
       "thinking_enabled": false,
@@ -101,21 +100,6 @@ Content-Type: application/json
 - Use: `values`, `messages-tuple`, `custom`, `updates`, `events`, `debug`, `tasks`, `checkpoints`
 - Do not use: `tools` (deprecated/invalid in current `langgraph-api` and will trigger schema validation errors)
 
-**Recursion Limit:**
-
-`config.recursion_limit` caps the number of graph steps LangGraph will execute
-in a single run. The `/api/langgraph/*` endpoints go straight to the LangGraph
-server and therefore inherit LangGraph's native default of **25**, which is
-too low for plan-mode or subagent-heavy runs — the agent typically errors out
-with `GraphRecursionError` after the first round of subagent results comes
-back, before the lead agent can synthesize the final answer.
-
-DeerFlow's own Gateway and IM-channel paths mitigate this by defaulting to
-`100` in `build_run_config` (see `backend/app/gateway/services.py`), but
-clients calling the LangGraph API directly must set `recursion_limit`
-explicitly in the request body. `100` matches the Gateway default and is a
-safe starting point; increase it if you run deeply nested subagent graphs.
-
 **Configurable Options:**
 - `model_name` (string): Override the default model
 - `thinking_enabled` (boolean): Enable extended thinking for supported models
@@ -642,14 +626,6 @@ curl -X POST http://localhost:2026/api/langgraph/threads/abc123/runs \
   -H "Content-Type: application/json" \
   -d '{
     "input": {"messages": [{"role": "user", "content": "Hello"}]},
-    "config": {
-      "recursion_limit": 100,
-      "configurable": {"model_name": "gpt-4"}
-    }
+    "config": {"configurable": {"model_name": "gpt-4"}}
   }'
 ```
-
-> The `/api/langgraph/*` endpoints bypass DeerFlow's Gateway and inherit
-> LangGraph's native `recursion_limit` default of 25, which is too low for
-> plan-mode or subagent runs. Set `config.recursion_limit` explicitly — see
-> the [Create Run](#create-run) section for details.

backend/docs/ARCHITECTURE.md

@@ -199,7 +199,7 @@ class ThreadState(AgentState):
 │   Built-in Tools    │  │  Configured Tools   │  │     MCP Tools       │
 │  (packages/harness/deerflow/tools/)       │  │  (config.yaml)      │  │  (extensions.json)  │
 ├─────────────────────┤  ├─────────────────────┤  ├─────────────────────┤
-│ - present_files     │  │ - web_search        │  │ - github            │
+│ - present_file      │  │ - web_search        │  │ - github            │
 │ - ask_clarification │  │ - web_fetch         │  │ - filesystem        │
 │ - view_image        │  │ - bash              │  │ - postgres          │
 │                     │  │ - read_file         │  │ - brave-search      │

backend/docs/AUTH_TEST_DOCKER_GAP.md

@@ -1,77 +0,0 @@
-# Docker Test Gap (Section 七 7.4)
-
-This file documents the only **un-executed** test cases from
-`backend/docs/AUTH_TEST_PLAN.md` after the full release validation pass.
-
-## Why this gap exists
-
-The release validation environment (sg_dev: `10.251.229.92`) **does not have
-a Docker daemon installed**. The TC-DOCKER cases are container-runtime
-behavior tests that need an actual Docker engine to spin up
-`docker/docker-compose.yaml` services.
-
-```bash
-$ ssh sg_dev "which docker; docker --version"
-# (empty)
-# bash: docker: command not found
-```
-
-All other test plan sections were executed against either:
-- The local dev box (Mac, all services running locally), or
-- The deployed sg_dev instance (gateway + frontend + nginx via SSH tunnel)
-
-## Cases not executed
-
-| Case | Title | What it covers | Why not run |
-|---|---|---|---|
-| TC-DOCKER-01 | `users.db` volume persistence | Verify the `DEER_FLOW_HOME` bind mount survives container restart | needs `docker compose up` |
-| TC-DOCKER-02 | Session persistence across container restart | `AUTH_JWT_SECRET` env var keeps cookies valid after `docker compose down && up` | needs `docker compose down/up` |
-| TC-DOCKER-03 | Per-worker rate limiter divergence | Confirms in-process `_login_attempts` dict doesn't share state across `gunicorn` workers (4 by default in the compose file); known limitation, documented | needs multi-worker container |
-| TC-DOCKER-04 | IM channels skip AuthMiddleware | Verify Feishu/Slack/Telegram dispatchers run in-container against `http://langgraph:2024` without going through nginx | needs `docker logs` |
-| TC-DOCKER-05 | Admin credentials surfacing | **Updated post-simplify** — was "log scrape", now "0600 credential file in `DEER_FLOW_HOME`". The file-based behavior is already validated by TC-1.1 + TC-UPG-13 on sg_dev (non-Docker), so the only Docker-specific gap is verifying the volume mount carries the file out to the host | needs container + host volume |
-| TC-DOCKER-06 | Gateway-mode Docker deploy | `./scripts/deploy.sh --gateway` produces a 3-container topology (no `langgraph` container); same auth flow as standard mode | needs `docker compose --profile gateway` |
-
-## Coverage already provided by non-Docker tests
-
-The **auth-relevant** behavior in each Docker case is already exercised by
-the test cases that ran on sg_dev or local:
-
-| Docker case | Auth behavior covered by |
-|---|---|
-| TC-DOCKER-01 (volume persistence) | TC-REENT-01 on sg_dev (admin row survives gateway restart) — same SQLite file, just no container layer between |
-| TC-DOCKER-02 (session persistence) | TC-API-02/03/06 (cookie roundtrip), plus TC-REENT-04 (multi-cookie) — JWT verification is process-state-free, container restart is equivalent to `pkill uvicorn && uv run uvicorn` |
-| TC-DOCKER-03 (per-worker rate limit) | TC-GW-04 + TC-REENT-09 (single-worker rate limit + 5min expiry). The cross-worker divergence is an architectural property of the in-memory dict; no auth code path differs |
-| TC-DOCKER-04 (IM channels skip auth) | Code-level only: `app/channels/manager.py` uses `langgraph_sdk` directly with no cookie handling. The langgraph_auth handler is bypassed by going through SDK, not HTTP |
-| TC-DOCKER-05 (credential surfacing) | TC-1.1 on sg_dev (file at `~/deer-flow/backend/.deer-flow/admin_initial_credentials.txt`, mode 0600, password 22 chars) — the only Docker-unique step is whether the bind mount projects this path onto the host, which is a `docker compose` config check, not a runtime behavior change |
-| TC-DOCKER-06 (gateway-mode container) | Section 七 7.2 covered by TC-GW-01..05 + Section 二 (gateway-mode auth flow on sg_dev) — same Gateway code, container is just a packaging change |
-
-## Reproduction steps when Docker becomes available
-
-Anyone with `docker` + `docker compose` installed can reproduce the gap by
-running the test plan section verbatim. Pre-flight:
-
-```bash
-# Required on the host
-docker --version           # >=24.x
-docker compose version     # plugin >=2.x
-
-# Required env var (otherwise sessions reset on every container restart)
-echo "AUTH_JWT_SECRET=$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')" \
-  >> .env
-
-# Optional: pin DEER_FLOW_HOME to a stable host path
-echo "DEER_FLOW_HOME=$HOME/deer-flow-data" >> .env
-```
-
-Then run TC-DOCKER-01..06 from the test plan as written.
-
-## Decision log
-
-- **Not blocking the release.** The auth-relevant behavior in every Docker
-  case has an already-validated equivalent on bare metal. The gap is purely
-  about *container packaging* details (bind mounts, multi-worker, log
-  collection), not about whether the auth code paths work.
-- **TC-DOCKER-05 was updated in place** in `AUTH_TEST_PLAN.md` to reflect
-  the post-simplify reality (credentials file → 0600 file, no log leak).
-  The old "grep 'Password:' in docker logs" expectation would have failed
-  silently and given a false sense of coverage.

backend/docs/AUTH_TEST_PLAN.md

@@ -1478,28 +1478,13 @@ docker logs deer-flow-gateway 2>&1 | grep -E "ChannelManager|channel" | head -10
 
 **预期：** 无 auth 相关错误。渠道通过 `langgraph-sdk` 直连 LangGraph Server（`http://langgraph:2024`），不走 auth 层。
 
-#### TC-DOCKER-05: admin 密码写入 0600 凭证文件（不再走日志）
+#### TC-DOCKER-05: admin 密码在容器日志中可见
 
 ```bash
-# 凭证文件写在挂载到宿主机的 DEER_FLOW_HOME 下
-ls -la ${DEER_FLOW_HOME:-backend/.deer-flow}/admin_initial_credentials.txt
-# 预期文件权限: -rw------- (0600)
-
-cat ${DEER_FLOW_HOME:-backend/.deer-flow}/admin_initial_credentials.txt
-# 预期内容: email + password 行
-
-# 容器日志只输出文件路径，不输出密码本身
-docker logs deer-flow-gateway 2>&1 | grep -E "Credentials written to|Admin account"
-# 预期看到: "Credentials written to: /...../admin_initial_credentials.txt (mode 0600)"
-
-# 反向验证: 日志里 NEVER 出现明文密码
-docker logs deer-flow-gateway 2>&1 | grep -iE "Password: .{15,}" && echo "FAIL: leaked" || echo "OK: not leaked"
+docker logs deer-flow-gateway 2>&1 | grep "Password:"
 ```
 
-**预期：**
-- 凭证文件存在于 `DEER_FLOW_HOME` 下，权限 `0600`
-- 容器日志输出**路径**（不是密码本身），符合 CodeQL `py/clear-text-logging-sensitive-data` 规则
-- `grep "Password:"` 在日志中**应当无匹配**（旧行为已废弃，simplify pass 移除了日志泄露路径）
+**预期：** 首次启动时输出 admin 密码，运维可通过 `docker logs` 获取。
 
 #### TC-DOCKER-06: Gateway 模式 Docker 部署
 

backend/docs/CONFIGURATION.md

@@ -192,8 +192,8 @@ tools:
 ```
 
 **Built-in Tools**:
-- `web_search` - Search the web (DuckDuckGo, Tavily, Exa, InfoQuest, Firecrawl)
-- `web_fetch` - Fetch web pages (Jina AI, Exa, InfoQuest, Firecrawl)
+- `web_search` - Search the web (Tavily)
+- `web_fetch` - Fetch web pages (Jina AI)
 - `ls` - List directory contents
 - `read_file` - Read file contents
 - `write_file` - Write file contents

backend/docs/FILE_UPLOAD.md

@@ -2,12 +2,12 @@
 
 ## 概述
 
-DeerFlow 后端提供了完整的文件上传功能，支持多文件上传，并可选地将 Office 文档和 PDF 转换为 Markdown 格式。
+DeerFlow 后端提供了完整的文件上传功能，支持多文件上传，并自动将 Office 文档和 PDF 转换为 Markdown 格式。
 
 ## 功能特性
 
 - ✅ 支持多文件同时上传
-- ✅ 可选地转换文档为 Markdown（PDF、PPT、Excel、Word）
+- ✅ 自动转换文档为 Markdown（PDF、PPT、Excel、Word）
 - ✅ 文件存储在线程隔离的目录中
 - ✅ Agent 自动感知已上传的文件
 - ✅ 支持文件列表查询和删除
@@ -86,7 +86,7 @@ DELETE /api/threads/{thread_id}/uploads/{filename}
 
 ## 支持的文档格式
 
-以下格式在显式启用 `uploads.auto_convert_documents: true` 时会自动转换为 Markdown：
+以下格式会自动转换为 Markdown：
 - PDF (`.pdf`)
 - PowerPoint (`.ppt`, `.pptx`)
 - Excel (`.xls`, `.xlsx`)
@@ -94,8 +94,6 @@ DELETE /api/threads/{thread_id}/uploads/{filename}
 
 转换后的 Markdown 文件会保存在同一目录下，文件名为原文件名 + `.md` 扩展名。
 
-默认情况下，自动转换是关闭的，以避免在网关主机上对不受信任的 Office/PDF 上传执行解析。只有在受信任部署中明确接受此风险时，才应将 `uploads.auto_convert_documents` 设置为 `true`。
-
 ## Agent 集成
 
 ### 自动文件列举
@@ -209,7 +207,6 @@ backend/.deer-flow/threads/
 - 最大文件大小：100MB（可在 nginx.conf 中配置 `client_max_body_size`）
 - 文件名安全性：系统会自动验证文件路径，防止目录遍历攻击
 - 线程隔离：每个线程的上传文件相互隔离，无法跨线程访问
-- 自动文档转换默认关闭；如需启用，需在 `config.yaml` 中显式设置 `uploads.auto_convert_documents: true`
 
 ## 技术实现
 

backend/docs/GUARDRAILS.md

@@ -296,7 +296,7 @@ These are the tool names your provider will see in `request.tool_name`:
 | `web_search` | Web search query |
 | `web_fetch` | Fetch URL content |
 | `image_search` | Image search |
-| `present_files` | Present file to user |
+| `present_file` | Present file to user |
 | `view_image` | Display image |
 | `ask_clarification` | Ask user a question |
 | `task` | Delegate to subagent |

backend/docs/MCP_SERVER.md

@@ -45,41 +45,6 @@ Example:
 }
 ```
 
-## Custom Tool Interceptors
-
-You can register custom interceptors that run before every MCP tool call. This is useful for injecting per-request headers (e.g., user auth tokens from the LangGraph execution context), logging, or metrics.
-
-Declare interceptors in `extensions_config.json` using the `mcpInterceptors` field:
-
-```json
-{
-  "mcpInterceptors": [
-    "my_package.mcp.auth:build_auth_interceptor"
-  ],
-  "mcpServers": { ... }
-}
-```
-
-Each entry is a Python import path in `module:variable` format (resolved via `resolve_variable`). The variable must be a **no-arg builder function** that returns an async interceptor compatible with `MultiServerMCPClient`’s `tool_interceptors` interface, or `None` to skip.
-
-Example interceptor that injects auth headers from LangGraph metadata:
-
-```python
-def build_auth_interceptor():
-    async def interceptor(request, handler):
-        from langgraph.config import get_config
-        metadata = get_config().get("metadata", {})
-        headers = dict(request.headers or {})
-        if token := metadata.get("auth_token"):
-            headers["X-Auth-Token"] = token
-        return await handler(request.override(headers=headers))
-    return interceptor
-```
-
-- A single string value is accepted and normalized to a one-element list.
-- Invalid paths or builder failures are logged as warnings without blocking other interceptors.
-- The builder return value must be `callable`; non-callable values are skipped with a warning.
-
 ## How It Works
 
 MCP servers expose tools that are automatically discovered and integrated into DeerFlow’s agent system at runtime. Once enabled, these tools become available to agents without additional code changes.

backend/docs/README.md

@@ -15,7 +15,6 @@ This directory contains detailed documentation for the DeerFlow backend.
 
 | Document | Description |
 |----------|-------------|
-| [STREAMING.md](STREAMING.md) | Token-level streaming design: Gateway vs DeerFlowClient paths, `stream_mode` semantics, per-id dedup |
 | [FILE_UPLOAD.md](FILE_UPLOAD.md) | File upload functionality |
 | [PATH_EXAMPLES.md](PATH_EXAMPLES.md) | Path types and usage examples |
 | [summarization.md](summarization.md) | Context summarization feature |
@@ -48,7 +47,6 @@ docs/
 ├── PATH_EXAMPLES.md           # Path usage examples
 ├── summarization.md           # Summarization feature
 ├── plan_mode_usage.md         # Plan mode feature
-├── STREAMING.md               # Token-level streaming design
 ├── AUTO_TITLE_GENERATION.md   # Title generation
 ├── TITLE_GENERATION_IMPLEMENTATION.md  # Title implementation details
 └── TODO.md                    # Roadmap and issues

backend/docs/STREAMING.md

@@ -1,351 +0,0 @@
-# DeerFlow 流式输出设计
-
-本文档解释 DeerFlow 是如何把 LangGraph agent 的事件流端到端送到两类消费者（HTTP 客户端、嵌入式 Python 调用方）的：两条路径为什么**必须**并存、它们各自的契约是什么、以及设计里那些 non-obvious 的不变式。
-
----
-
-## TL;DR
-
-- DeerFlow 有**两条并行**的流式路径：**Gateway 路径**（async / HTTP SSE / JSON 序列化）服务浏览器和 IM 渠道；**DeerFlowClient 路径**（sync / in-process / 原生 LangChain 对象）服务 Jupyter、脚本、测试。它们**无法合并**——消费者模型不同。
-- 两条路径都从 `create_agent()` 工厂出发，核心都是订阅 LangGraph 的 `stream_mode=["values", "messages", "custom"]`。`values` 是节点级 state 快照，`messages` 是 LLM token 级 delta，`custom` 是显式 `StreamWriter` 事件。**这三种模式不是详细程度的梯度，是三个独立的事件源**，要 token 流就必须显式订阅 `messages`。
-- 嵌入式 client 为每个 `stream()` 调用维护三个 `set[str]`：`seen_ids` / `streamed_ids` / `counted_usage_ids`。三者看起来相似但管理**三个独立的不变式**，不能合并。
-
----
-
-## 为什么有两条流式路径
-
-两条路径服务的消费者模型根本不同：
-
-| 维度 | Gateway 路径 | DeerFlowClient 路径 |
-|---|---|---|
-| 入口 | FastAPI `/runs/stream` endpoint | `DeerFlowClient.stream(message)` |
-| 触发层 | `runtime/runs/worker.py::run_agent` | `packages/harness/deerflow/client.py::DeerFlowClient.stream` |
-| 执行模型 | `async def` + `agent.astream()` | sync generator + `agent.stream()` |
-| 事件传输 | `StreamBridge`（asyncio Queue）+ `sse_consumer` | 直接 `yield` |
-| 序列化 | `serialize(chunk)` → 纯 JSON dict，匹配 LangGraph Platform wire 格式 | `StreamEvent.data`，携带原生 LangChain 对象 |
-| 消费者 | 前端 `useStream` React hook、飞书/Slack/Telegram channel、LangGraph SDK 客户端 | Jupyter notebook、集成测试、内部 Python 脚本 |
-| 生命周期管理 | `RunManager`：run_id 跟踪、disconnect 语义、multitask 策略、heartbeat | 无；函数返回即结束 |
-| 断连恢复 | `Last-Event-ID` SSE 重连 | 无需要 |
-
-**两条路径的存在是 DRY 的刻意妥协**：Gateway 的全部基础设施（async + Queue + JSON + RunManager）**都是为了跨网络边界把事件送给 HTTP 消费者**。当生产者（agent）和消费者（Python 调用栈）在同一个进程时，这整套东西都是纯开销。
-
-### 为什么不能让 DeerFlowClient 复用 Gateway
-
-曾经考虑过三种复用方案，都被否决：
-
-1. **让 `client.stream()` 变成 `async def client.astream()`**  
-   breaking change。用户用不上的 `async for` / `asyncio.run()` 要硬塞进 Jupyter notebook 和同步脚本。DeerFlowClient 的一大卖点（"把 agent 当普通函数调用"）直接消失。
-
-2. **在 `client.stream()` 内部起一个独立事件循环线程，用 `StreamBridge` 在 sync/async 之间做桥接**  
-   引入线程池、队列、信号量。为了"消除重复"，把**复杂度**代替代码行数引进来。是典型的"wrong abstraction"——开销高于复用收益。
-
-3. **让 `run_agent` 自己兼容 sync mode**  
-   给 Gateway 加一条用不到的死分支，污染 worker.py 的焦点。
-
-所以两条路径的事件处理逻辑会**相似但不共享**。这是刻意设计，不是疏忽。
-
----
-
-## LangGraph `stream_mode` 三层语义
-
-LangGraph 的 `agent.stream(stream_mode=[...])` 是**多路复用**接口：一次订阅多个 mode，每个 mode 是一个独立的事件源。三种核心 mode：
-
-```mermaid
-flowchart LR
-    classDef values fill:#B8C5D1,stroke:#5A6B7A,color:#2C3E50
-    classDef messages fill:#C9B8A8,stroke:#7A6B5A,color:#2C3E50
-    classDef custom fill:#B5C4B1,stroke:#5A7A5A,color:#2C3E50
-
-    subgraph LG["LangGraph agent graph"]
-        direction TB
-        Node1["node: LLM call"]
-        Node2["node: tool call"]
-        Node3["node: reducer"]
-    end
-
-    LG -->|"每个节点完成后"| V["values: 完整 state 快照"]
-    Node1 -->|"LLM 每产生一个 token"| M["messages: (AIMessageChunk, meta)"]
-    Node1 -->|"StreamWriter.write()"| C["custom: 任意 dict"]
-
-    class V values
-    class M messages
-    class C custom
-```
-
-| Mode | 发射时机 | Payload | 粒度 |
-|---|---|---|---|
-| `values` | 每个 graph 节点完成后 | 完整 state dict（title、messages、artifacts）| 节点级 |
-| `messages` | LLM 每次 yield 一个 chunk；tool 节点完成时 | `(AIMessageChunk \| ToolMessage, metadata_dict)` | token 级 |
-| `custom` | 用户代码显式调用 `StreamWriter.write()` | 任意 dict | 应用定义 |
-
-### 两套命名的由来
-
-同一件事在**三个协议层**有三个名字：
-
-```
-Application                    HTTP / SSE                    LangGraph Graph
-┌──────────────┐               ┌──────────────┐              ┌──────────────┐
-│ frontend     │               │ LangGraph    │              │ agent.astream│
-│ useStream    │──"messages-   │ Platform SDK │──"messages"──│ graph.astream│
-│ Feishu IM    │   tuple"──────│ HTTP wire    │              │              │
-└──────────────┘               └──────────────┘              └──────────────┘
-```
-
-- **Graph 层**（`agent.stream` / `agent.astream`）：LangGraph Python 直接 API，mode 叫 **`"messages"`**。
-- **Platform SDK 层**（`langgraph-sdk` HTTP client）：跨进程 HTTP 契约，mode 叫 **`"messages-tuple"`**。
-- **Gateway worker** 显式做翻译：`if m == "messages-tuple": lg_modes.append("messages")`（`runtime/runs/worker.py:117-121`）。
-
-**后果**：`DeerFlowClient.stream()` 直接调 `agent.stream()`（Graph 层），所以必须传 `"messages"`。`app/channels/manager.py` 通过 `langgraph-sdk` 走 HTTP SDK，所以传 `"messages-tuple"`。**这两个字符串不能互相替代**，也不能抽成"一个共享常量"——它们是不同协议层的 type alias，共享只会让某一层说不是它母语的话。
-
----
-
-## Gateway 路径：async + HTTP SSE
-
-```mermaid
-sequenceDiagram
-    participant Client as HTTP Client
-    participant API as FastAPI<br/>thread_runs.py
-    participant Svc as services.py<br/>start_run
-    participant Worker as worker.py<br/>run_agent (async)
-    participant Bridge as StreamBridge<br/>(asyncio.Queue)
-    participant Agent as LangGraph<br/>agent.astream
-    participant SSE as sse_consumer
-
-    Client->>API: POST /runs/stream
-    API->>Svc: start_run(body)
-    Svc->>Bridge: create bridge
-    Svc->>Worker: asyncio.create_task(run_agent(...))
-    Svc-->>API: StreamingResponse(sse_consumer)
-    API-->>Client: event-stream opens
-
-    par worker (producer)
-        Worker->>Agent: astream(stream_mode=lg_modes)
-        loop 每个 chunk
-            Agent-->>Worker: (mode, chunk)
-            Worker->>Bridge: publish(run_id, event, serialize(chunk))
-        end
-        Worker->>Bridge: publish_end(run_id)
-    and sse_consumer (consumer)
-        SSE->>Bridge: subscribe(run_id)
-        loop 每个 event
-            Bridge-->>SSE: StreamEvent
-            SSE-->>Client: "event: <name>\ndata: <json>\n\n"
-        end
-    end
-```
-
-关键组件：
-
-- `runtime/runs/worker.py::run_agent` — 在 `asyncio.Task` 里跑 `agent.astream()`，把每个 chunk 通过 `serialize(chunk, mode=mode)` 转成 JSON，再 `bridge.publish()`。
-- `runtime/stream_bridge` — 抽象 Queue。`publish/subscribe` 解耦生产者和消费者，支持 `Last-Event-ID` 重连、心跳、多订阅者 fan-out。
-- `app/gateway/services.py::sse_consumer` — 从 bridge 订阅，格式化为 SSE wire 帧。
-- `runtime/serialization.py::serialize` — mode-aware 序列化；`messages` mode 下 `serialize_messages_tuple` 把 `(chunk, metadata)` 转成 `[chunk.model_dump(), metadata]`。
-
-**`StreamBridge` 的存在价值**：当生产者（`run_agent` 任务）和消费者（HTTP 连接）在不同的 asyncio task 里运行时，需要一个可以跨 task 传递事件的中介。Queue 同时还承担断连重连的 buffer 和多订阅者的 fan-out。
-
----
-
-## DeerFlowClient 路径：sync + in-process
-
-```mermaid
-sequenceDiagram
-    participant User as Python caller
-    participant Client as DeerFlowClient.stream
-    participant Agent as LangGraph<br/>agent.stream (sync)
-
-    User->>Client: for event in client.stream("hi"):
-    Client->>Agent: stream(stream_mode=["values","messages","custom"])
-    loop 每个 chunk
-        Agent-->>Client: (mode, chunk)
-        Client->>Client: 分发 mode<br/>构建 StreamEvent
-        Client-->>User: yield StreamEvent
-    end
-    Client-->>User: yield StreamEvent(type="end")
-```
-
-对比之下，sync 路径的每个环节都是显著更少的移动部件：
-
-- 没有 `RunManager` —— 一次 `stream()` 调用对应一次生命周期，无需 run_id。
-- 没有 `StreamBridge` —— 直接 `yield`，生产和消费在同一个 Python 调用栈，不需要跨 task 中介。
-- 没有 JSON 序列化 —— `StreamEvent.data` 直接装原生 LangChain 对象（`AIMessage.content`、`usage_metadata` 的 `UsageMetadata` TypedDict）。Jupyter 用户拿到的是真正的类型，不是匿名 dict。
-- 没有 asyncio —— 调用者可以直接 `for event in ...`，不必写 `async for`。
-
----
-
-## 消费语义：delta vs cumulative
-
-LangGraph `messages` mode 给出的是 **delta**：每个 `AIMessageChunk.content` 只包含这一次新 yield 的 token，**不是**从头的累计文本。
-
-这个语义和 LangChain 的 `fs2 Stream` 风格一致：**上游发增量，下游负责累加**。Gateway 路径里前端 `useStream` React hook 自己维护累加器；DeerFlowClient 路径里 `chat()` 方法替调用者做累加。
-
-### `DeerFlowClient.chat()` 的 O(n) 累加器
-
-```python
-chunks: dict[str, list[str]] = {}
-last_id: str = ""
-for event in self.stream(message, thread_id=thread_id, **kwargs):
-    if event.type == "messages-tuple" and event.data.get("type") == "ai":
-        msg_id = event.data.get("id") or ""
-        delta = event.data.get("content", "")
-        if delta:
-            chunks.setdefault(msg_id, []).append(delta)
-            last_id = msg_id
-return "".join(chunks.get(last_id, ()))
-```
-
-**为什么不是 `buffers[id] = buffers.get(id,"") + delta`**：CPython 的字符串 in-place concat 优化仅在 refcount=1 且 LHS 是 local name 时生效；这里字符串存在 dict 里被 reassign，优化失效，每次都是 O(n) 拷贝 → 总体 O(n²)。实测 50 KB / 5000 chunk 的回复要 100-300ms 纯拷贝开销。用 `list` + `"".join()` 是 O(n)。
-
----
-
-## 三个 id set 为什么不能合并
-
-`DeerFlowClient.stream()` 在一次调用生命周期内维护三个 `set[str]`：
-
-```python
-seen_ids: set[str] = set()           # values 路径内部 dedup
-streamed_ids: set[str] = set()       # messages → values 跨模式 dedup
-counted_usage_ids: set[str] = set()  # usage_metadata 幂等计数
-```
-
-乍看像是"三份几乎一样的东西"，实际每个管**不同的不变式**。
-
-| Set | 负责的不变式 | 被谁填充 | 被谁查询 |
-|---|---|---|---|
-| `seen_ids` | 连续两个 `values` 快照里同一条 message 只生成一个 `messages-tuple` 事件 | values 分支每处理一条消息就加入 | values 分支处理下一条消息前检查 |
-| `streamed_ids` | 如果一条消息已经通过 `messages` 模式 token 级流过，values 快照到达时**不要**再合成一次完整 `messages-tuple` | messages 分支每发一个 AI/tool 事件就加入 | values 分支看到消息时检查 |
-| `counted_usage_ids` | 同一个 `usage_metadata` 在 messages 末尾 chunk 和 values 快照的 final AIMessage 里各带一份，**累计总量只算一次** | `_account_usage()` 每次接受 usage 就加入 | `_account_usage()` 每次调用时检查 |
-
-### 为什么不能只用一个 set
-
-关键观察：**同一个 message id 在这三个 set 里的加入时机不同**。
-
-```mermaid
-sequenceDiagram
-    participant M as messages mode
-    participant V as values mode
-    participant SS as streamed_ids
-    participant SU as counted_usage_ids
-    participant SE as seen_ids
-
-    Note over M: 第一个 AI text chunk 到达
-    M->>SS: add(msg_id)
-    Note over M: 最后一个 chunk 带 usage
-    M->>SU: add(msg_id)
-    Note over V: snapshot 到达，包含同一条 AI message
-    V->>SE: add(msg_id)
-    V->>SS: 查询 → 已存在，跳过文本合成
-    V->>SU: 查询 → 已存在，不重复计数
-```
-
-- `seen_ids` **永远在 values 快照到达时**加入，所以它是 "values 已处理" 的标记。一条只出现在 messages 流里的消息（罕见但可能），`seen_ids` 里永远没有它。
-- `streamed_ids` **在 messages 流的第一个有效事件时**加入。一条只通过 values 快照到达的非 AI 消息（HumanMessage、被 truncate 的 tool 消息），`streamed_ids` 里永远没有它。
-- `counted_usage_ids` **只在看到非空 `usage_metadata` 时**加入。一条完全没有 usage 的消息（tool message、错误消息）永远不会进去。
-
-**集合包含关系**：`counted_usage_ids ⊆ (streamed_ids ∪ seen_ids)` 大致成立，但**不是严格子集**，因为一条消息可以在 messages 模式流完 text 但**在最后那个带 usage 的 chunk 之前**就被 values snapshot 赶上——此时它已经在 `streamed_ids` 里，但还不在 `counted_usage_ids` 里。把它们合并成一个 dict-of-flags 会让这个微妙的时序依赖**从类型系统里消失**，变成注释里的一句话。三个独立的 set 把不变式显式化了：每个 set 名对应一个可以口头回答的问题。
-
----
-
-## 端到端：一次真实对话的事件时序
-
-假设调用 `client.stream("Count from 1 to 15")`，LLM 给出 "one\ntwo\n...\nfifteen"（88 字符），tokenizer 把它拆成 ~35 个 BPE chunk。下面是事件到达序列的精简版：
-
-```mermaid
-sequenceDiagram
-    participant U as User
-    participant C as DeerFlowClient
-    participant A as LangGraph<br/>agent.stream
-
-    U->>C: stream("Count ... 15")
-    C->>A: stream(mode=["values","messages","custom"])
-
-    A-->>C: ("values", {messages: [HumanMessage]})
-    C-->>U: StreamEvent(type="values", ...)
-
-    Note over A,C: LLM 开始 yield token
-    loop 35 次，约 476ms
-        A-->>C: ("messages", (AIMessageChunk(content="ele"), meta))
-        C->>C: streamed_ids.add(ai-1)
-        C-->>U: StreamEvent(type="messages-tuple",<br/>data={type:ai, content:"ele", id:ai-1})
-    end
-
-    Note over A: LLM finish_reason=stop，最后一个 chunk 带 usage
-    A-->>C: ("messages", (AIMessageChunk(content="", usage_metadata={...}), meta))
-    C->>C: counted_usage_ids.add(ai-1)<br/>(无文本，不 yield)
-
-    A-->>C: ("values", {messages: [..., AIMessage(complete)]})
-    C->>C: ai-1 in streamed_ids → 跳过合成
-    C->>C: 捕获 usage (已在 counted_usage_ids，no-op)
-    C-->>U: StreamEvent(type="values", ...)
-
-    C-->>U: StreamEvent(type="end", data={usage:{...}})
-```
-
-关键观察：
-
-1. 用户看到 **35 个 messages-tuple 事件**，跨越约 476ms，每个事件带一个 token delta 和同一个 `id=ai-1`。
-2. 最后一个 `values` 快照里的 `AIMessage` **不会**再触发一个完整的 `messages-tuple` 事件——因为 `ai-1 in streamed_ids` 跳过了合成。
-3. `end` 事件里的 `usage` 正好等于那一份 cumulative usage，**不是它的两倍**——`counted_usage_ids` 在 messages 末尾 chunk 上已经吸收了，values 分支的重复访问是 no-op。
-4. 消费者拿到的 `content` 是**增量**："ele" 只包含 3 个字符，不是 "one\ntwo\n...ele"。想要完整文本要按 `id` 累加，`chat()` 已经帮你做了。
-
----
-
-## 为什么这个设计容易出 bug，以及测试策略
-
-本文档的直接起因是 bytedance/deer-flow#1969：`DeerFlowClient.stream()` 原本只订阅 `["values", "custom"]`，**漏了 `"messages"`**。结果 `client.stream("hello")` 等价于一次性返回，视觉上和 `chat()` 没区别。
-
-这类 bug 有三个结构性原因：
-
-1. **多协议层命名**：`messages` / `messages-tuple` / HTTP SSE `messages` 是同一概念的三个名字。在其中一层出错不会在另外两层报错。
-2. **多消费者模型**：Gateway 和 DeerFlowClient 是两套独立实现，**没有单一的"订阅哪些 mode"的 single source of truth**。前者订阅对了不代表后者也订阅对了。
-3. **mock 测试绕开了真实路径**：老测试用 `agent.stream.return_value = iter([dict_chunk, ...])` 喂 values 形状的 dict 模拟 state 快照。这样构造的输入**永远不会进入 `messages` mode 分支**，所以即使 `stream_mode` 里少一个元素，CI 依然全绿。
-
-### 防御手段
-
-真正的防线是**显式断言 "messages" mode 被订阅 + 用真实 chunk shape mock**：
-
-```python
-# tests/test_client.py::test_messages_mode_emits_token_deltas
-agent.stream.return_value = iter([
-    ("messages", (AIMessageChunk(content="Hel", id="ai-1"), {})),
-    ("messages", (AIMessageChunk(content="lo ", id="ai-1"), {})),
-    ("messages", (AIMessageChunk(content="world!", id="ai-1"), {})),
-    ("values", {"messages": [HumanMessage(...), AIMessage(content="Hello world!", id="ai-1")]}),
-])
-# ...
-assert [e.data["content"] for e in ai_text_events] == ["Hel", "lo ", "world!"]
-assert len(ai_text_events) == 3  # values snapshot must NOT re-synthesize
-assert "messages" in agent.stream.call_args.kwargs["stream_mode"]
-```
-
-**为什么这比"抽一个共享常量"更有效**：共享常量只能保证"用它的人写对字符串"，但新增消费者的人可能根本不知道常量在哪。行为断言强制任何改动都要穿过**实际执行路径**，改回 `["values", "custom"]` 会立刻让 `assert "messages" in ...` 失败。
-
-### 活体信号：BPE 子词边界
-
-回归的最终验证是让真实 LLM 数 1-15，然后看是否能在输出里看到 tokenizer 的子词切分：
-
-```
-[5.460s] 'ele' / 'ven'      eleven 被拆成两个 token
-[5.508s] 'tw'  / 'elve'     twelve 拆两个
-[5.568s] 'th'  / 'irteen'   thirteen 拆两个
-[5.623s] 'four'/ 'teen'     fourteen 拆两个
-[5.677s] 'f'   / 'if' / 'teen'  fifteen 拆三个
-```
-
-子词切分是 tokenizer 的外部事实，**无法伪造**。能看到它就说明数据流**逐 chunk** 地穿过了整条管道，没有被任何中间层缓冲成整段。这种"活体信号"在流式系统里是比单元测试更高置信度的证据。
-
----
-
-## 相关源码定位
-
-| 关心什么 | 看这里 |
-|---|---|
-| DeerFlowClient 嵌入式流 | `packages/harness/deerflow/client.py::DeerFlowClient.stream` |
-| `chat()` 的 delta 累加器 | `packages/harness/deerflow/client.py::DeerFlowClient.chat` |
-| Gateway async 流 | `packages/harness/deerflow/runtime/runs/worker.py::run_agent` |
-| HTTP SSE 帧输出 | `app/gateway/services.py::sse_consumer` / `format_sse` |
-| 序列化到 wire 格式 | `packages/harness/deerflow/runtime/serialization.py` |
-| LangGraph mode 命名翻译 | `packages/harness/deerflow/runtime/runs/worker.py:117-121` |
-| 飞书渠道的增量卡片更新 | `app/channels/manager.py::_handle_streaming_chat` |
-| Channels 自带的 delta/cumulative 防御性累加 | `app/channels/manager.py::_merge_stream_text` |
-| Frontend useStream 支持的 mode 集合 | `frontend/src/core/api/stream-mode.ts` |
-| 核心回归测试 | `backend/tests/test_client.py::TestStream::test_messages_mode_emits_token_deltas` |

backend/docs/TITLE_GENERATION_IMPLEMENTATION.md

@@ -124,7 +124,7 @@ title:
 # checkpointer.py
 from langgraph.checkpoint.sqlite import SqliteSaver
 
-checkpointer = SqliteSaver.from_conn_string("deerflow.db")
+checkpointer = SqliteSaver.from_conn_string("checkpoints.db")
 ```
 
 ```json

backend/docs/TODO.md

@@ -11,7 +11,6 @@
 - [x] Add Plan Mode with TodoList middleware
 - [x] Add vision model support with ViewImageMiddleware
 - [x] Skills system with SKILL.md format
-- [x] Replace `time.sleep(5)` with `asyncio.sleep()` in `packages/harness/deerflow/tools/builtins/task_tool.py` (subagent polling)
 
 ## Planned Features
 
@@ -22,9 +21,10 @@
 - [ ] Support for more document formats in upload
 - [ ] Skill marketplace / remote skill installation
 - [ ] Optimize async concurrency in agent hot path (IM channels multi-task scenario)
-- [ ] Replace `subprocess.run()` with `asyncio.create_subprocess_shell()` in `packages/harness/deerflow/sandbox/local/local_sandbox.py`
+  - Replace `time.sleep(5)` with `asyncio.sleep()` in `packages/harness/deerflow/tools/builtins/task_tool.py` (subagent polling)
+  - Replace `subprocess.run()` with `asyncio.create_subprocess_shell()` in `packages/harness/deerflow/sandbox/local/local_sandbox.py`
   - Replace sync `requests` with `httpx.AsyncClient` in community tools (tavily, jina_ai, firecrawl, infoquest, image_search)
-  - [x] Replace sync `model.invoke()` with async `model.ainvoke()` in title_middleware and memory updater
+  - Replace sync `model.invoke()` with async `model.ainvoke()` in title_middleware and memory updater
   - Consider `asyncio.to_thread()` wrapper for remaining blocking file I/O
   - For production: use `langgraph up` (multi-worker) instead of `langgraph dev` (single-worker)
 

backend/docs/summarization.md

@@ -41,13 +41,6 @@ summarization:
 
   # Custom summary prompt (optional)
   summary_prompt: null
-
-  # Tool names treated as skill file reads for skill rescue
-  skill_file_read_tool_names:
-    - read_file
-    - read
-    - view
-    - cat
 ```
 
 ### Configuration Options
@@ -132,26 +125,6 @@ keep:
 - **Default**: `null` (uses LangChain's default prompt)
 - **Description**: Custom prompt template for generating summaries. The prompt should guide the model to extract the most important context.
 
-#### `preserve_recent_skill_count`
-- **Type**: Integer (≥ 0)
-- **Default**: `5`
-- **Description**: Number of most-recently-loaded skill files (tool results whose tool name is in `skill_file_read_tool_names` and whose target path is under `skills.container_path`, e.g. `/mnt/skills/...`) that are rescued from summarization. Prevents the agent from losing skill instructions after compression. Set to `0` to disable skill rescue entirely.
-
-#### `preserve_recent_skill_tokens`
-- **Type**: Integer (≥ 0)
-- **Default**: `25000`
-- **Description**: Total token budget reserved for rescued skill reads. Once this budget is exhausted, older skill bundles are allowed to be summarized.
-
-#### `preserve_recent_skill_tokens_per_skill`
-- **Type**: Integer (≥ 0)
-- **Default**: `5000`
-- **Description**: Per-skill token cap. Any individual skill read whose tool result exceeds this size is not rescued (it falls through to the summarizer like ordinary content).
-
-#### `skill_file_read_tool_names`
-- **Type**: List of strings
-- **Default**: `["read_file", "read", "view", "cat"]`
-- **Description**: Tool names treated as skill file reads during summarization rescue. A tool call is only eligible for skill rescue when its name appears in this list and its target path is under `skills.container_path`.
-
 **Default Prompt Behavior:**
 The default LangChain prompt instructs the model to:
 - Extract highest quality/most relevant context
@@ -174,7 +147,6 @@ The default LangChain prompt instructs the model to:
    - A single summary message is added
    - Recent messages are preserved
 6. **AI/Tool Pair Protection**: The system ensures AI messages and their corresponding tool messages stay together
-7. **Skill Rescue**: Before the summary is generated, the most recently loaded skill files (tool results whose tool name is in `skill_file_read_tool_names` and whose target path is under `skills.container_path`) are lifted out of the summarization set and prepended to the preserved tail. Selection walks newest-first under three budgets: `preserve_recent_skill_count`, `preserve_recent_skill_tokens`, and `preserve_recent_skill_tokens_per_skill`. The triggering AIMessage and all of its paired ToolMessages move together so tool_call ↔ tool_result pairing stays intact.
 
 ### Token Counting
 

backend/packages/harness/deerflow/agents/__init__.py

@@ -1,14 +1,9 @@
+from .checkpointer import get_checkpointer, make_checkpointer, reset_checkpointer
 from .factory import create_deerflow_agent
 from .features import Next, Prev, RuntimeFeatures
 from .lead_agent import make_lead_agent
-from .lead_agent.prompt import prime_enabled_skills_cache
 from .thread_state import SandboxState, ThreadState
 
-# LangGraph imports deerflow.agents when registering the graph. Prime the
-# enabled-skills cache here so the request path can usually read a warm cache
-# without forcing synchronous filesystem work during prompt module import.
-prime_enabled_skills_cache()
-
 __all__ = [
     "create_deerflow_agent",
     "RuntimeFeatures",
@@ -17,4 +12,7 @@ __all__ = [
     "make_lead_agent",
     "SandboxState",
     "ThreadState",
+    "get_checkpointer",
+    "reset_checkpointer",
+    "make_checkpointer",
 ]

backend/packages/harness/deerflow/agents/checkpointer/async_provider.py

@@ -7,29 +7,28 @@ Supported backends: memory, sqlite, postgres.
 
 Usage (e.g. FastAPI lifespan)::
 
-    from deerflow.runtime.checkpointer.async_provider import make_checkpointer
+    from deerflow.agents.checkpointer.async_provider import make_checkpointer
 
     async with make_checkpointer() as checkpointer:
         app.state.checkpointer = checkpointer  # InMemorySaver if not configured
 
-For sync usage see :mod:`deerflow.runtime.checkpointer.provider`.
+For sync usage see :mod:`deerflow.agents.checkpointer.provider`.
 """
 
 from __future__ import annotations
 
-import asyncio
 import contextlib
 import logging
 from collections.abc import AsyncIterator
 
 from langgraph.types import Checkpointer
 
-from deerflow.config.app_config import AppConfig
-from deerflow.runtime.checkpointer.provider import (
+from deerflow.agents.checkpointer.provider import (
     POSTGRES_CONN_REQUIRED,
     POSTGRES_INSTALL,
     SQLITE_INSTALL,
 )
+from deerflow.config.app_config import get_app_config
 from deerflow.runtime.store._sqlite_utils import ensure_sqlite_parent_dir, resolve_sqlite_conn_str
 
 logger = logging.getLogger(__name__)
@@ -55,7 +54,7 @@ async def _async_checkpointer(config) -> AsyncIterator[Checkpointer]:
             raise ImportError(SQLITE_INSTALL) from exc
 
         conn_str = resolve_sqlite_conn_str(config.connection_string or "store.db")
-        await asyncio.to_thread(ensure_sqlite_parent_dir, conn_str)
+        ensure_sqlite_parent_dir(conn_str)
         async with AsyncSqliteSaver.from_conn_string(conn_str) as saver:
             await saver.setup()
             yield saver
@@ -123,11 +122,11 @@ async def _async_checkpointer_from_database(db_config) -> AsyncIterator[Checkpoi
 
 
 @contextlib.asynccontextmanager
-async def make_checkpointer(app_config: AppConfig) -> AsyncIterator[Checkpointer]:
+async def make_checkpointer() -> AsyncIterator[Checkpointer]:
     """Async context manager that yields a checkpointer for the caller's lifetime.
     Resources are opened on enter and closed on exit -- no global state::
 
-        async with make_checkpointer(app_config) as checkpointer:
+        async with make_checkpointer() as checkpointer:
             app.state.checkpointer = checkpointer
 
     Yields an ``InMemorySaver`` when no checkpointer is configured in *config.yaml*.
@@ -138,14 +137,16 @@ async def make_checkpointer(app_config: AppConfig) -> AsyncIterator[Checkpointer
     3. Default InMemorySaver
     """
 
+    config = get_app_config()
+
     # Legacy: standalone checkpointer config takes precedence
-    if app_config.checkpointer is not None:
-        async with _async_checkpointer(app_config.checkpointer) as saver:
+    if config.checkpointer is not None:
+        async with _async_checkpointer(config.checkpointer) as saver:
             yield saver
             return
 
     # Unified database config
-    db_config = getattr(app_config, "database", None)
+    db_config = getattr(config, "database", None)
     if db_config is not None and db_config.backend != "memory":
         async with _async_checkpointer_from_database(db_config) as saver:
             yield saver

backend/packages/harness/deerflow/agents/checkpointer/provider.py

@@ -7,7 +7,7 @@ Supported backends: memory, sqlite, postgres.
 
 Usage::
 
-    from deerflow.runtime.checkpointer.provider import get_checkpointer, checkpointer_context
+    from deerflow.agents.checkpointer.provider import get_checkpointer, checkpointer_context
 
     # Singleton — reused across calls, closed on process exit
     cp = get_checkpointer()
@@ -25,9 +25,9 @@ from collections.abc import Iterator
 
 from langgraph.types import Checkpointer
 
-from deerflow.config.app_config import AppConfig
+from deerflow.config.app_config import get_app_config
 from deerflow.config.checkpointer_config import CheckpointerConfig
-from deerflow.runtime.store._sqlite_utils import ensure_sqlite_parent_dir, resolve_sqlite_conn_str
+from deerflow.runtime.store._sqlite_utils import resolve_sqlite_conn_str
 
 logger = logging.getLogger(__name__)
 
@@ -67,7 +67,6 @@ def _sync_checkpointer_cm(config: CheckpointerConfig) -> Iterator[Checkpointer]:
             raise ImportError(SQLITE_INSTALL) from exc
 
         conn_str = resolve_sqlite_conn_str(config.connection_string or "store.db")
-        ensure_sqlite_parent_dir(conn_str)
         with SqliteSaver.from_conn_string(conn_str) as saver:
             saver.setup()
             logger.info("Checkpointer: using SqliteSaver (%s)", conn_str)
@@ -100,13 +99,10 @@ _checkpointer: Checkpointer | None = None
 _checkpointer_ctx = None  # open context manager keeping the connection alive
 
 
-def get_checkpointer(app_config: AppConfig) -> Checkpointer:
+def get_checkpointer() -> Checkpointer:
     """Return the global sync checkpointer singleton, creating it on first call.
 
-    Returns an ``InMemorySaver`` only when ``checkpointer`` is explicitly
-    absent from config.yaml. Any other failure (missing config, invalid
-    backend, connection error) propagates — silent degradation to in-memory
-    would drop persistent-run state on process restart.
+    Returns an ``InMemorySaver`` when no checkpointer is configured in *config.yaml*.
 
     Raises:
         ImportError: If the required package for the configured backend is not installed.
@@ -117,7 +113,25 @@ def get_checkpointer(app_config: AppConfig) -> Checkpointer:
     if _checkpointer is not None:
         return _checkpointer
 
-    config = app_config.checkpointer
+    # Ensure app config is loaded before checking checkpointer config
+    # This prevents returning InMemorySaver when config.yaml actually has a checkpointer section
+    # but hasn't been loaded yet
+    from deerflow.config.app_config import _app_config
+    from deerflow.config.checkpointer_config import get_checkpointer_config
+
+    config = get_checkpointer_config()
+
+    if config is None and _app_config is None:
+        # Only load app config lazily when neither the app config nor an explicit
+        # checkpointer config has been initialized yet. This keeps tests that
+        # intentionally set the global checkpointer config isolated from any
+        # ambient config.yaml on disk.
+        try:
+            get_app_config()
+        except FileNotFoundError:
+            # In test environments without config.yaml, this is expected.
+            pass
+        config = get_checkpointer_config()
     if config is None:
         from langgraph.checkpoint.memory import InMemorySaver
 
@@ -153,23 +167,25 @@ def reset_checkpointer() -> None:
 
 
 @contextlib.contextmanager
-def checkpointer_context(app_config: AppConfig) -> Iterator[Checkpointer]:
+def checkpointer_context() -> Iterator[Checkpointer]:
     """Sync context manager that yields a checkpointer and cleans up on exit.
 
     Unlike :func:`get_checkpointer`, this does **not** cache the instance —
     each ``with`` block creates and destroys its own connection.  Use it in
     CLI scripts or tests where you want deterministic cleanup::
 
-        with checkpointer_context(app_config) as cp:
+        with checkpointer_context() as cp:
             graph.invoke(input, config={"configurable": {"thread_id": "1"}})
 
     Yields an ``InMemorySaver`` when no checkpointer is configured in *config.yaml*.
     """
-    if app_config.checkpointer is None:
+
+    config = get_app_config()
+    if config.checkpointer is None:
         from langgraph.checkpoint.memory import InMemorySaver
 
         yield InMemorySaver()
         return
 
-    with _sync_checkpointer_cm(app_config.checkpointer) as saver:
+    with _sync_checkpointer_cm(config.checkpointer) as saver:
         yield saver

backend/packages/harness/deerflow/agents/lead_agent/agent.py

@@ -1,42 +1,31 @@
 import logging
 
 from langchain.agents import create_agent
-from langchain.agents.middleware import AgentMiddleware
+from langchain.agents.middleware import AgentMiddleware, SummarizationMiddleware
 from langchain_core.runnables import RunnableConfig
-from langgraph.graph.state import CompiledStateGraph
 
 from deerflow.agents.lead_agent.prompt import apply_prompt_template
-from deerflow.agents.memory.summarization_hook import memory_flush_hook
 from deerflow.agents.middlewares.clarification_middleware import ClarificationMiddleware
 from deerflow.agents.middlewares.loop_detection_middleware import LoopDetectionMiddleware
 from deerflow.agents.middlewares.memory_middleware import MemoryMiddleware
 from deerflow.agents.middlewares.subagent_limit_middleware import SubagentLimitMiddleware
-from deerflow.agents.middlewares.summarization_middleware import BeforeSummarizationHook, DeerFlowSummarizationMiddleware
 from deerflow.agents.middlewares.title_middleware import TitleMiddleware
 from deerflow.agents.middlewares.todo_middleware import TodoMiddleware
 from deerflow.agents.middlewares.token_usage_middleware import TokenUsageMiddleware
 from deerflow.agents.middlewares.tool_error_handling_middleware import build_lead_runtime_middlewares
 from deerflow.agents.middlewares.view_image_middleware import ViewImageMiddleware
 from deerflow.agents.thread_state import ThreadState
-from deerflow.config.agents_config import load_agent_config, validate_agent_name
-from deerflow.config.app_config import AppConfig
-from deerflow.config.deer_flow_context import DeerFlowContext
+from deerflow.config.agents_config import load_agent_config
+from deerflow.config.app_config import get_app_config
+from deerflow.config.summarization_config import get_summarization_config
 from deerflow.models import create_chat_model
 
 logger = logging.getLogger(__name__)
 
 
-def _get_runtime_config(config: RunnableConfig) -> dict:
-    """Merge legacy configurable options with LangGraph runtime context."""
-    cfg = dict(config.get("configurable", {}) or {})
-    context = config.get("context", {}) or {}
-    if isinstance(context, dict):
-        cfg.update(context)
-    return cfg
-
-
-def _resolve_model_name(app_config: AppConfig, requested_model_name: str | None = None) -> str:
+def _resolve_model_name(requested_model_name: str | None = None) -> str:
     """Resolve a runtime model name safely, falling back to default if invalid. Returns None if no models are configured."""
+    app_config = get_app_config()
     default_model_name = app_config.models[0].name if app_config.models else None
     if default_model_name is None:
         raise ValueError("No chat models are configured. Please configure at least one model in config.yaml.")
@@ -49,9 +38,9 @@ def _resolve_model_name(app_config: AppConfig, requested_model_name: str | None
     return default_model_name
 
 
-def _create_summarization_middleware(app_config: AppConfig) -> DeerFlowSummarizationMiddleware | None:
+def _create_summarization_middleware() -> SummarizationMiddleware | None:
     """Create and configure the summarization middleware from config."""
-    config = app_config.summarization
+    config = get_summarization_config()
 
     if not config.enabled:
         return None
@@ -72,9 +61,9 @@ def _create_summarization_middleware(app_config: AppConfig) -> DeerFlowSummariza
     # as middleware rather than lead_agent (SummarizationMiddleware is a
     # LangChain built-in, so we tag the model at creation time).
     if config.model_name:
-        model = create_chat_model(name=config.model_name, thinking_enabled=False, app_config=app_config)
+        model = create_chat_model(name=config.model_name, thinking_enabled=False)
     else:
-        model = create_chat_model(thinking_enabled=False, app_config=app_config)
+        model = create_chat_model(thinking_enabled=False)
     model = model.with_config(tags=["middleware:summarize"])
 
     # Prepare kwargs
@@ -90,28 +79,7 @@ def _create_summarization_middleware(app_config: AppConfig) -> DeerFlowSummariza
     if config.summary_prompt is not None:
         kwargs["summary_prompt"] = config.summary_prompt
 
-    hooks: list[BeforeSummarizationHook] = []
-    if app_config.memory.enabled:
-        hooks.append(memory_flush_hook)
-
-    # The logic below relies on two assumptions holding true: this factory is
-    # the sole entry point for DeerFlowSummarizationMiddleware, and the runtime
-    # config is not expected to change after startup.
-    try:
-        skills_container_path = app_config.skills.container_path or "/mnt/skills"
-    except Exception:
-        logger.exception("Failed to resolve skills container path; falling back to default")
-        skills_container_path = "/mnt/skills"
-
-    return DeerFlowSummarizationMiddleware(
-        **kwargs,
-        skills_container_path=skills_container_path,
-        skill_file_read_tool_names=config.skill_file_read_tool_names,
-        before_summarization=hooks,
-        preserve_recent_skill_count=config.preserve_recent_skill_count,
-        preserve_recent_skill_tokens=config.preserve_recent_skill_tokens,
-        preserve_recent_skill_tokens_per_skill=config.preserve_recent_skill_tokens_per_skill,
-    )
+    return SummarizationMiddleware(**kwargs)
 
 
 def _create_todo_list_middleware(is_plan_mode: bool) -> TodoMiddleware | None:
@@ -239,18 +207,10 @@ Being proactive with task management demonstrates thoroughness and ensures all r
 # ViewImageMiddleware should be before ClarificationMiddleware to inject image details before LLM
 # ToolErrorHandlingMiddleware should be before ClarificationMiddleware to convert tool exceptions to ToolMessages
 # ClarificationMiddleware should be last to intercept clarification requests after model calls
-def _build_middlewares(
-    app_config: AppConfig,
-    config: RunnableConfig,
-    *,
-    model_name: str | None,
-    agent_name: str | None = None,
-    custom_middlewares: list[AgentMiddleware] | None = None,
-):
+def _build_middlewares(config: RunnableConfig, model_name: str | None, agent_name: str | None = None, custom_middlewares: list[AgentMiddleware] | None = None):
     """Build middleware chain based on runtime configuration.
 
     Args:
-        app_config: Resolved application config.
         config: Runtime configuration containing configurable options like is_plan_mode.
         agent_name: If provided, MemoryMiddleware will use per-agent memory storage.
         custom_middlewares: Optional list of custom middlewares to inject into the chain.
@@ -258,22 +218,21 @@ def _build_middlewares(
     Returns:
         List of middleware instances.
     """
-    middlewares = build_lead_runtime_middlewares(app_config=app_config, lazy_init=True)
+    middlewares = build_lead_runtime_middlewares(lazy_init=True)
 
     # Add summarization middleware if enabled
-    summarization_middleware = _create_summarization_middleware(app_config)
+    summarization_middleware = _create_summarization_middleware()
     if summarization_middleware is not None:
         middlewares.append(summarization_middleware)
 
     # Add TodoList middleware if plan mode is enabled
-    cfg = _get_runtime_config(config)
-    is_plan_mode = cfg.get("is_plan_mode", False)
+    is_plan_mode = config.get("configurable", {}).get("is_plan_mode", False)
     todo_list_middleware = _create_todo_list_middleware(is_plan_mode)
     if todo_list_middleware is not None:
         middlewares.append(todo_list_middleware)
 
     # Add TokenUsageMiddleware when token_usage tracking is enabled
-    if app_config.token_usage.enabled:
+    if get_app_config().token_usage.enabled:
         middlewares.append(TokenUsageMiddleware())
 
     # Add TitleMiddleware
@@ -284,6 +243,7 @@ def _build_middlewares(
 
     # Add ViewImageMiddleware only if the current model supports vision.
     # Use the resolved runtime model_name from make_lead_agent to avoid stale config values.
+    app_config = get_app_config()
     model_config = app_config.get_model_config(model_name) if model_name else None
     if model_config is not None and model_config.supports_vision:
         middlewares.append(ViewImageMiddleware())
@@ -295,9 +255,9 @@ def _build_middlewares(
         middlewares.append(DeferredToolFilterMiddleware())
 
     # Add SubagentLimitMiddleware to truncate excess parallel task calls
-    subagent_enabled = cfg.get("subagent_enabled", False)
+    subagent_enabled = config.get("configurable", {}).get("subagent_enabled", False)
     if subagent_enabled:
-        max_concurrent_subagents = cfg.get("max_concurrent_subagents", 3)
+        max_concurrent_subagents = config.get("configurable", {}).get("max_concurrent_subagents", 3)
         middlewares.append(SubagentLimitMiddleware(max_concurrent=max_concurrent_subagents))
 
     # LoopDetectionMiddleware — detect and break repetitive tool call loops
@@ -312,33 +272,12 @@ def _build_middlewares(
     return middlewares
 
 
-def make_lead_agent(
-    config: RunnableConfig,
-    app_config: AppConfig | None = None,
-) -> CompiledStateGraph:
-    """Build the lead agent from runtime config.
-
-    Args:
-        config: LangGraph ``RunnableConfig`` carrying per-invocation options
-            (``thinking_enabled``, ``model_name``, ``is_plan_mode``, etc.).
-        app_config: Resolved application config. Required for in-process
-            entry points (DeerFlowClient, Gateway Worker). When omitted we
-            are being called via ``langgraph.json`` registration and reload
-            from disk — the LangGraph Server bootstrap path has no other
-            way to thread the value.
-    """
+def make_lead_agent(config: RunnableConfig):
     # Lazy import to avoid circular dependency
     from deerflow.tools import get_available_tools
     from deerflow.tools.builtins import setup_agent
 
-    if app_config is None:
-        # LangGraph Server registers ``make_lead_agent`` via ``langgraph.json``
-        # and hands us only a ``RunnableConfig``. Reload config from disk
-        # here — it's a pure function, equivalent to the process-global the
-        # old code path would have read.
-        app_config = AppConfig.from_file()
-
-    cfg = _get_runtime_config(config)
+    cfg = config.get("configurable", {})
 
     thinking_enabled = cfg.get("thinking_enabled", True)
     reasoning_effort = cfg.get("reasoning_effort", None)
@@ -347,16 +286,17 @@ def make_lead_agent(
     subagent_enabled = cfg.get("subagent_enabled", False)
     max_concurrent_subagents = cfg.get("max_concurrent_subagents", 3)
     is_bootstrap = cfg.get("is_bootstrap", False)
-    agent_name = validate_agent_name(cfg.get("agent_name"))
+    agent_name = cfg.get("agent_name")
 
     agent_config = load_agent_config(agent_name) if not is_bootstrap else None
-    # Custom agent model from agent config (if any), or None to let _resolve_model_name pick the default
-    agent_model_name = agent_config.model if agent_config and agent_config.model else None
+    # Custom agent model or fallback to global/default model resolution
+    agent_model_name = agent_config.model if agent_config and agent_config.model else _resolve_model_name()
 
-    # Final model name resolution: request → agent config → global default, with fallback for unknown names
-    model_name = _resolve_model_name(app_config, requested_model_name or agent_model_name)
+    # Final model name resolution with request override, then agent config, then global default
+    model_name = requested_model_name or agent_model_name
 
-    model_config = app_config.get_model_config(model_name)
+    app_config = get_app_config()
+    model_config = app_config.get_model_config(model_name) if model_name else None
 
     if model_config is None:
         raise ValueError("No chat model could be resolved. Please configure at least one model in config.yaml or provide a valid 'model_name'/'model' in the request.")
@@ -387,30 +327,26 @@ def make_lead_agent(
             "reasoning_effort": reasoning_effort,
             "is_plan_mode": is_plan_mode,
             "subagent_enabled": subagent_enabled,
-            "tool_groups": agent_config.tool_groups if agent_config else None,
-            "available_skills": ["bootstrap"] if is_bootstrap else (agent_config.skills if agent_config and agent_config.skills is not None else None),
         }
     )
 
     if is_bootstrap:
         # Special bootstrap agent with minimal prompt for initial custom agent creation flow
         return create_agent(
-            model=create_chat_model(name=model_name, thinking_enabled=thinking_enabled, app_config=app_config),
-            tools=get_available_tools(model_name=model_name, subagent_enabled=subagent_enabled, app_config=app_config) + [setup_agent],
-            middleware=_build_middlewares(app_config, config, model_name=model_name),
-            system_prompt=apply_prompt_template(app_config, subagent_enabled=subagent_enabled, max_concurrent_subagents=max_concurrent_subagents, available_skills=set(["bootstrap"])),
+            model=create_chat_model(name=model_name, thinking_enabled=thinking_enabled),
+            tools=get_available_tools(model_name=model_name, subagent_enabled=subagent_enabled) + [setup_agent],
+            middleware=_build_middlewares(config, model_name=model_name),
+            system_prompt=apply_prompt_template(subagent_enabled=subagent_enabled, max_concurrent_subagents=max_concurrent_subagents, available_skills=set(["bootstrap"])),
             state_schema=ThreadState,
-            context_schema=DeerFlowContext,
         )
 
     # Default lead agent (unchanged behavior)
     return create_agent(
-        model=create_chat_model(name=model_name, thinking_enabled=thinking_enabled, reasoning_effort=reasoning_effort, app_config=app_config),
-        tools=get_available_tools(model_name=model_name, groups=agent_config.tool_groups if agent_config else None, subagent_enabled=subagent_enabled, app_config=app_config),
-        middleware=_build_middlewares(app_config, config, model_name=model_name, agent_name=agent_name),
+        model=create_chat_model(name=model_name, thinking_enabled=thinking_enabled, reasoning_effort=reasoning_effort),
+        tools=get_available_tools(model_name=model_name, groups=agent_config.tool_groups if agent_config else None, subagent_enabled=subagent_enabled),
+        middleware=_build_middlewares(config, model_name=model_name, agent_name=agent_name),
         system_prompt=apply_prompt_template(
-            app_config, subagent_enabled=subagent_enabled, max_concurrent_subagents=max_concurrent_subagents, agent_name=agent_name, available_skills=set(agent_config.skills) if agent_config and agent_config.skills is not None else None
+            subagent_enabled=subagent_enabled, max_concurrent_subagents=max_concurrent_subagents, agent_name=agent_name, available_skills=set(agent_config.skills) if agent_config and agent_config.skills is not None else None
         ),
         state_schema=ThreadState,
-        context_schema=DeerFlowContext,
     )

backend/packages/harness/deerflow/agents/lead_agent/prompt.py

@@ -1,153 +1,28 @@
-import asyncio
 import logging
-import threading
 from datetime import datetime
 from functools import lru_cache
 
 from deerflow.config.agents_config import load_agent_soul
-from deerflow.config.app_config import AppConfig
 from deerflow.skills import load_skills
-from deerflow.skills.types import Skill
 from deerflow.subagents import get_available_subagent_names
 
 logger = logging.getLogger(__name__)
 
-_ENABLED_SKILLS_REFRESH_WAIT_TIMEOUT_SECONDS = 5.0
-_enabled_skills_lock = threading.Lock()
-_enabled_skills_cache: list[Skill] | None = None
-_enabled_skills_refresh_active = False
-_enabled_skills_refresh_version = 0
-_enabled_skills_refresh_event = threading.Event()
 
-
-def _load_enabled_skills_sync(app_config: AppConfig | None) -> list[Skill]:
-    return list(load_skills(app_config, enabled_only=True))
-
-
-def _start_enabled_skills_refresh_thread(app_config: AppConfig | None) -> None:
-    threading.Thread(
-        target=_refresh_enabled_skills_cache_worker,
-        args=(app_config,),
-        name="deerflow-enabled-skills-loader",
-        daemon=True,
-    ).start()
-
-
-def _refresh_enabled_skills_cache_worker(app_config: AppConfig | None) -> None:
-    global _enabled_skills_cache, _enabled_skills_refresh_active
-
-    while True:
-        with _enabled_skills_lock:
-            target_version = _enabled_skills_refresh_version
-
-        try:
-            skills = _load_enabled_skills_sync(app_config)
-        except (OSError, ImportError):
-            logger.exception("Failed to load enabled skills for prompt injection")
-            skills = []
-
-        with _enabled_skills_lock:
-            if _enabled_skills_refresh_version == target_version:
-                _enabled_skills_cache = skills
-                _enabled_skills_refresh_active = False
-                _enabled_skills_refresh_event.set()
-                return
-
-            # A newer invalidation happened while loading. Keep the worker alive
-            # and loop again so the cache always converges on the latest version.
-            _enabled_skills_cache = None
-
-
-def _ensure_enabled_skills_cache(app_config: AppConfig | None) -> threading.Event:
-    global _enabled_skills_refresh_active
-
-    with _enabled_skills_lock:
-        if _enabled_skills_cache is not None:
-            _enabled_skills_refresh_event.set()
-            return _enabled_skills_refresh_event
-        if _enabled_skills_refresh_active:
-            return _enabled_skills_refresh_event
-        _enabled_skills_refresh_active = True
-        _enabled_skills_refresh_event.clear()
-
-    _start_enabled_skills_refresh_thread(app_config)
-    return _enabled_skills_refresh_event
-
-
-def _invalidate_enabled_skills_cache(app_config: AppConfig | None) -> threading.Event:
-    global _enabled_skills_cache, _enabled_skills_refresh_active, _enabled_skills_refresh_version
-
-    _get_cached_skills_prompt_section.cache_clear()
-    with _enabled_skills_lock:
-        _enabled_skills_cache = None
-        _enabled_skills_refresh_version += 1
-        _enabled_skills_refresh_event.clear()
-        if _enabled_skills_refresh_active:
-            return _enabled_skills_refresh_event
-        _enabled_skills_refresh_active = True
-
-    _start_enabled_skills_refresh_thread(app_config)
-    return _enabled_skills_refresh_event
-
-
-def prime_enabled_skills_cache(app_config: AppConfig | None = None) -> None:
-    _ensure_enabled_skills_cache(app_config)
-
-
-def warm_enabled_skills_cache(app_config: AppConfig | None = None, timeout_seconds: float = _ENABLED_SKILLS_REFRESH_WAIT_TIMEOUT_SECONDS) -> bool:
-    if _ensure_enabled_skills_cache(app_config).wait(timeout=timeout_seconds):
-        return True
-
-    logger.warning("Timed out waiting %.1fs for enabled skills cache warm-up", timeout_seconds)
-    return False
-
-
-def _get_enabled_skills(app_config: AppConfig | None = None):
-    with _enabled_skills_lock:
-        cached = _enabled_skills_cache
-
-    if cached is not None:
-        return list(cached)
-
-    _ensure_enabled_skills_cache(app_config)
-    return []
+def _get_enabled_skills():
+    try:
+        return list(load_skills(enabled_only=True))
+    except Exception:
+        logger.exception("Failed to load enabled skills for prompt injection")
+        return []
 
 
 def _skill_mutability_label(category: str) -> str:
     return "[custom, editable]" if category == "custom" else "[built-in]"
 
 
-def clear_skills_system_prompt_cache(app_config: AppConfig | None = None) -> None:
-    _invalidate_enabled_skills_cache(app_config)
-
-
-async def refresh_skills_system_prompt_cache_async(app_config: AppConfig | None = None) -> None:
-    await asyncio.to_thread(_invalidate_enabled_skills_cache(app_config).wait)
-
-
-def _reset_skills_system_prompt_cache_state() -> None:
-    global _enabled_skills_cache, _enabled_skills_refresh_active, _enabled_skills_refresh_version
-
+def clear_skills_system_prompt_cache() -> None:
     _get_cached_skills_prompt_section.cache_clear()
-    with _enabled_skills_lock:
-        _enabled_skills_cache = None
-        _enabled_skills_refresh_active = False
-        _enabled_skills_refresh_version = 0
-        _enabled_skills_refresh_event.clear()
-
-
-def _refresh_enabled_skills_cache(app_config: AppConfig | None = None) -> None:
-    """Backward-compatible test helper for direct synchronous reload."""
-    try:
-        skills = _load_enabled_skills_sync(app_config)
-    except Exception:
-        logger.exception("Failed to load enabled skills for prompt injection")
-        skills = []
-
-    with _enabled_skills_lock:
-        _enabled_skills_cache = skills
-        _enabled_skills_refresh_active = False
-        _enabled_skills_refresh_event.set()
 
 
 def _build_skill_evolution_section(skill_evolution_enabled: bool) -> str:
@@ -166,53 +41,23 @@ Skip simple one-off tasks.
 """
 
 
-def _build_available_subagents_description(available_names: list[str], bash_available: bool, app_config: AppConfig) -> str:
-    """Dynamically build subagent type descriptions from registry.
-
-    Mirrors Codex's pattern where agent_type_description is dynamically generated
-    from all registered roles, so the LLM knows about every available type.
-    """
-    # Built-in descriptions (kept for backward compatibility with existing prompt quality)
-    builtin_descriptions = {
-        "general-purpose": "For ANY non-trivial task - web research, code exploration, file operations, analysis, etc.",
-        "bash": (
-            "For command execution (git, build, test, deploy operations)" if bash_available else "Not available in the current sandbox configuration. Use direct file/web tools or switch to AioSandboxProvider for isolated shell access."
-        ),
-    }
-
-    # Lazy import moved outside loop to avoid repeated import overhead
-    from deerflow.subagents.registry import get_subagent_config
-
-    lines = []
-    for name in available_names:
-        if name in builtin_descriptions:
-            lines.append(f"- **{name}**: {builtin_descriptions[name]}")
-        else:
-            config = get_subagent_config(name, app_config)
-            if config is not None:
-                desc = config.description.split("\n")[0].strip()  # First line only for brevity
-                lines.append(f"- **{name}**: {desc}")
-
-    return "\n".join(lines)
-
-
-def _build_subagent_section(max_concurrent: int, app_config: AppConfig) -> str:
+def _build_subagent_section(max_concurrent: int) -> str:
     """Build the subagent system prompt section with dynamic concurrency limit.
 
     Args:
         max_concurrent: Maximum number of concurrent subagent calls allowed per response.
-        app_config: Application config used to gate bash availability.
 
     Returns:
         Formatted subagent section string.
     """
     n = max_concurrent
-    available_names = get_available_subagent_names(app_config)
-    bash_available = "bash" in available_names
-
-    # Dynamically build subagent type descriptions from registry (aligned with Codex's
-    # agent_type_description pattern where all registered roles are listed in the tool spec).
-    available_subagents = _build_available_subagents_description(available_names, bash_available, app_config)
+    bash_available = "bash" in get_available_subagent_names()
+    available_subagents = (
+        "- **general-purpose**: For ANY non-trivial task - web research, code exploration, file operations, analysis, etc.\n- **bash**: For command execution (git, build, test, deploy operations)"
+        if bash_available
+        else "- **general-purpose**: For ANY non-trivial task - web research, code exploration, file operations, analysis, etc.\n"
+        "- **bash**: Not available in the current sandbox configuration. Use direct file/web tools or switch to AioSandboxProvider for isolated shell access."
+    )
     direct_tool_examples = "bash, ls, read_file, web_search, etc." if bash_available else "ls, read_file, web_search, etc."
     direct_execution_example = (
         '# User asks: "Run the tests"\n# Thinking: Cannot decompose into parallel sub-tasks\n# → Execute directly\n\nbash("npm test")  # Direct execution, not task()'
@@ -449,10 +294,7 @@ You: "Deploying to staging..." [proceed]
 - Use `read_file` tool to read uploaded files using their paths from the list
 - For PDF, PPT, Excel, and Word files, converted Markdown versions (*.md) are available alongside originals
 - All temporary work happens in `/mnt/user-data/workspace`
-- Treat `/mnt/user-data/workspace` as your default current working directory for coding and file-editing tasks
-- When writing scripts or commands that create/read files from the workspace, prefer relative paths such as `hello.txt`, `../uploads/data.csv`, and `../outputs/report.md`
-- Avoid hardcoding `/mnt/user-data/...` inside generated scripts when a relative path from the workspace is enough
-- Final deliverables must be copied to `/mnt/user-data/outputs` and presented using `present_files` tool
+- Final deliverables must be copied to `/mnt/user-data/outputs` and presented using `present_file` tool
 {acp_section}
 </working_directory>
 
@@ -539,34 +381,36 @@ combined with a FastAPI gateway for REST API access [citation:FastAPI](https://f
 """
 
 
-def _get_memory_context(app_config: AppConfig, agent_name: str | None = None) -> str:
+def _get_memory_context(agent_name: str | None = None) -> str:
     """Get memory context for injection into system prompt.
 
-    Returns an empty string when memory is disabled or the stored memory file
-    cannot be read/parsed. A corrupt memory.json degrades the prompt to
-    no-memory; it never kills the agent.
+    Args:
+        agent_name: If provided, loads per-agent memory. If None, loads global memory.
+
+    Returns:
+        Formatted memory context string wrapped in XML tags, or empty string if disabled.
     """
-    from deerflow.agents.memory import format_memory_for_injection, get_memory_data
-    from deerflow.runtime.user_context import get_effective_user_id
-
-    memory_config = app_config.memory
-    if not memory_config.enabled or not memory_config.injection_enabled:
-        return ""
-
     try:
-        memory_data = get_memory_data(memory_config, agent_name, user_id=get_effective_user_id())
-    except (OSError, ValueError, UnicodeDecodeError):
-        logger.exception("Failed to load memory data for prompt injection")
-        return ""
+        from deerflow.agents.memory import format_memory_for_injection, get_memory_data
+        from deerflow.config.memory_config import get_memory_config
 
-    memory_content = format_memory_for_injection(memory_data, max_tokens=memory_config.max_injection_tokens)
-    if not memory_content.strip():
-        return ""
+        config = get_memory_config()
+        if not config.enabled or not config.injection_enabled:
+            return ""
 
-    return f"""<memory>
+        memory_data = get_memory_data(agent_name)
+        memory_content = format_memory_for_injection(memory_data, max_tokens=config.max_injection_tokens)
+
+        if not memory_content.strip():
+            return ""
+
+        return f"""<memory>
 {memory_content}
 </memory>
 """
+    except Exception as e:
+        logger.error("Failed to load memory context: %s", e)
+        return ""
 
 
 @lru_cache(maxsize=32)
@@ -601,12 +445,19 @@ You have access to skills that provide optimized workflows for specific tasks. E
 </skill_system>"""
 
 
-def get_skills_prompt_section(app_config: AppConfig, available_skills: set[str] | None = None) -> str:
+def get_skills_prompt_section(available_skills: set[str] | None = None) -> str:
     """Generate the skills prompt section with available skills list."""
-    skills = _get_enabled_skills(app_config)
+    skills = _get_enabled_skills()
 
-    container_base_path = app_config.skills.container_path
-    skill_evolution_enabled = app_config.skill_evolution.enabled
+    try:
+        from deerflow.config import get_app_config
+
+        config = get_app_config()
+        container_base_path = config.skills.container_path
+        skill_evolution_enabled = config.skill_evolution.enabled
+    except Exception:
+        container_base_path = "/mnt/skills"
+        skill_evolution_enabled = False
 
     if not skills and not skill_evolution_enabled:
         return ""
@@ -630,7 +481,7 @@ def get_agent_soul(agent_name: str | None) -> str:
     return ""
 
 
-def get_deferred_tools_prompt_section(app_config: AppConfig) -> str:
+def get_deferred_tools_prompt_section() -> str:
     """Generate <available-deferred-tools> block for the system prompt.
 
     Lists only deferred tool names so the agent knows what exists
@@ -639,7 +490,12 @@ def get_deferred_tools_prompt_section(app_config: AppConfig) -> str:
     """
     from deerflow.tools.builtins.tool_search import get_deferred_registry
 
-    if not app_config.tool_search.enabled:
+    try:
+        from deerflow.config import get_app_config
+
+        if not get_app_config().tool_search.enabled:
+            return ""
+    except Exception:
         return ""
 
     registry = get_deferred_registry()
@@ -650,9 +506,15 @@ def get_deferred_tools_prompt_section(app_config: AppConfig) -> str:
     return f"<available-deferred-tools>\n{names}\n</available-deferred-tools>"
 
 
-def _build_acp_section(app_config: AppConfig) -> str:
+def _build_acp_section() -> str:
     """Build the ACP agent prompt section, only if ACP agents are configured."""
-    if not app_config.acp_agents:
+    try:
+        from deerflow.config.acp_config import get_acp_agents
+
+        agents = get_acp_agents()
+        if not agents:
+            return ""
+    except Exception:
         return ""
 
     return (
@@ -660,13 +522,19 @@ def _build_acp_section(app_config: AppConfig) -> str:
         "- ACP agents (e.g. codex, claude_code) run in their own independent workspace — NOT in `/mnt/user-data/`\n"
         "- When writing prompts for ACP agents, describe the task only — do NOT reference `/mnt/user-data` paths\n"
         "- ACP agent results are accessible at `/mnt/acp-workspace/` (read-only) — use `ls`, `read_file`, or `bash cp` to retrieve output files\n"
-        "- To deliver ACP output to the user: copy from `/mnt/acp-workspace/<file>` to `/mnt/user-data/outputs/<file>`, then use `present_files`"
+        "- To deliver ACP output to the user: copy from `/mnt/acp-workspace/<file>` to `/mnt/user-data/outputs/<file>`, then use `present_file`"
     )
 
 
-def _build_custom_mounts_section(app_config: AppConfig) -> str:
+def _build_custom_mounts_section() -> str:
     """Build a prompt section for explicitly configured sandbox mounts."""
-    mounts = app_config.sandbox.mounts or []
+    try:
+        from deerflow.config import get_app_config
+
+        mounts = get_app_config().sandbox.mounts or []
+    except Exception:
+        logger.exception("Failed to load configured sandbox mounts for the lead-agent prompt")
+        return ""
 
     if not mounts:
         return ""
@@ -680,20 +548,13 @@ def _build_custom_mounts_section(app_config: AppConfig) -> str:
     return f"\n**Custom Mounted Directories:**\n{mounts_list}\n- If the user needs files outside `/mnt/user-data`, use these absolute container paths directly when they match the requested directory"
 
 
-def apply_prompt_template(
-    app_config: AppConfig,
-    subagent_enabled: bool = False,
-    max_concurrent_subagents: int = 3,
-    *,
-    agent_name: str | None = None,
-    available_skills: set[str] | None = None,
-) -> str:
+def apply_prompt_template(subagent_enabled: bool = False, max_concurrent_subagents: int = 3, *, agent_name: str | None = None, available_skills: set[str] | None = None) -> str:
     # Get memory context
-    memory_context = _get_memory_context(app_config, agent_name)
+    memory_context = _get_memory_context(agent_name)
 
     # Include subagent section only if enabled (from runtime parameter)
     n = max_concurrent_subagents
-    subagent_section = _build_subagent_section(n, app_config) if subagent_enabled else ""
+    subagent_section = _build_subagent_section(n) if subagent_enabled else ""
 
     # Add subagent reminder to critical_reminders if enabled
     subagent_reminder = (
@@ -714,14 +575,14 @@ def apply_prompt_template(
     )
 
     # Get skills section
-    skills_section = get_skills_prompt_section(app_config, available_skills)
+    skills_section = get_skills_prompt_section(available_skills)
 
     # Get deferred tools section (tool_search)
-    deferred_tools_section = get_deferred_tools_prompt_section(app_config)
+    deferred_tools_section = get_deferred_tools_prompt_section()
 
     # Build ACP agent section only if ACP agents are configured
-    acp_section = _build_acp_section(app_config)
-    custom_mounts_section = _build_custom_mounts_section(app_config)
+    acp_section = _build_acp_section()
+    custom_mounts_section = _build_custom_mounts_section()
     acp_and_mounts_section = "\n".join(section for section in (acp_section, custom_mounts_section) if section)
 
     # Format the prompt with dynamic skills and memory

backend/packages/harness/deerflow/agents/memory/message_processing.py

@@ -1,109 +0,0 @@
-"""Shared helpers for turning conversations into memory update inputs."""
-
-from __future__ import annotations
-
-import re
-from copy import copy
-from typing import Any
-
-_UPLOAD_BLOCK_RE = re.compile(r"<uploaded_files>[\s\S]*?</uploaded_files>\n*", re.IGNORECASE)
-_CORRECTION_PATTERNS = (
-    re.compile(r"\bthat(?:'s| is) (?:wrong|incorrect)\b", re.IGNORECASE),
-    re.compile(r"\byou misunderstood\b", re.IGNORECASE),
-    re.compile(r"\btry again\b", re.IGNORECASE),
-    re.compile(r"\bredo\b", re.IGNORECASE),
-    re.compile(r"不对"),
-    re.compile(r"你理解错了"),
-    re.compile(r"你理解有误"),
-    re.compile(r"重试"),
-    re.compile(r"重新来"),
-    re.compile(r"换一种"),
-    re.compile(r"改用"),
-)
-_REINFORCEMENT_PATTERNS = (
-    re.compile(r"\byes[,.]?\s+(?:exactly|perfect|that(?:'s| is) (?:right|correct|it))\b", re.IGNORECASE),
-    re.compile(r"\bperfect(?:[.!?]|$)", re.IGNORECASE),
-    re.compile(r"\bexactly\s+(?:right|correct)\b", re.IGNORECASE),
-    re.compile(r"\bthat(?:'s| is)\s+(?:exactly\s+)?(?:right|correct|what i (?:wanted|needed|meant))\b", re.IGNORECASE),
-    re.compile(r"\bkeep\s+(?:doing\s+)?that\b", re.IGNORECASE),
-    re.compile(r"\bjust\s+(?:like\s+)?(?:that|this)\b", re.IGNORECASE),
-    re.compile(r"\bthis is (?:great|helpful)\b(?:[.!?]|$)", re.IGNORECASE),
-    re.compile(r"\bthis is what i wanted\b(?:[.!?]|$)", re.IGNORECASE),
-    re.compile(r"对[，,]?\s*就是这样(?:[。！？!?.]|$)"),
-    re.compile(r"完全正确(?:[。！？!?.]|$)"),
-    re.compile(r"(?:对[，,]?\s*)?就是这个意思(?:[。！？!?.]|$)"),
-    re.compile(r"正是我想要的(?:[。！？!?.]|$)"),
-    re.compile(r"继续保持(?:[。！？!?.]|$)"),
-)
-
-
-def extract_message_text(message: Any) -> str:
-    """Extract plain text from message content for filtering and signal detection."""
-    content = getattr(message, "content", "")
-    if isinstance(content, list):
-        text_parts: list[str] = []
-        for part in content:
-            if isinstance(part, str):
-                text_parts.append(part)
-            elif isinstance(part, dict):
-                text_val = part.get("text")
-                if isinstance(text_val, str):
-                    text_parts.append(text_val)
-        return " ".join(text_parts)
-    return str(content)
-
-
-def filter_messages_for_memory(messages: list[Any]) -> list[Any]:
-    """Keep only user inputs and final assistant responses for memory updates."""
-    filtered = []
-    skip_next_ai = False
-    for msg in messages:
-        msg_type = getattr(msg, "type", None)
-
-        if msg_type == "human":
-            content_str = extract_message_text(msg)
-            if "<uploaded_files>" in content_str:
-                stripped = _UPLOAD_BLOCK_RE.sub("", content_str).strip()
-                if not stripped:
-                    skip_next_ai = True
-                    continue
-                clean_msg = copy(msg)
-                clean_msg.content = stripped
-                filtered.append(clean_msg)
-                skip_next_ai = False
-            else:
-                filtered.append(msg)
-                skip_next_ai = False
-        elif msg_type == "ai":
-            tool_calls = getattr(msg, "tool_calls", None)
-            if not tool_calls:
-                if skip_next_ai:
-                    skip_next_ai = False
-                    continue
-                filtered.append(msg)
-
-    return filtered
-
-
-def detect_correction(messages: list[Any]) -> bool:
-    """Detect explicit user corrections in recent conversation turns."""
-    recent_user_msgs = [msg for msg in messages[-6:] if getattr(msg, "type", None) == "human"]
-
-    for msg in recent_user_msgs:
-        content = extract_message_text(msg).strip()
-        if content and any(pattern.search(content) for pattern in _CORRECTION_PATTERNS):
-            return True
-
-    return False
-
-
-def detect_reinforcement(messages: list[Any]) -> bool:
-    """Detect explicit positive reinforcement signals in recent conversation turns."""
-    recent_user_msgs = [msg for msg in messages[-6:] if getattr(msg, "type", None) == "human"]
-
-    for msg in recent_user_msgs:
-        content = extract_message_text(msg).strip()
-        if content and any(pattern.search(content) for pattern in _REINFORCEMENT_PATTERNS):
-            return True
-
-    return False

backend/packages/harness/deerflow/agents/memory/queue.py

@@ -4,29 +4,22 @@ import logging
 import threading
 import time
 from dataclasses import dataclass, field
-from datetime import UTC, datetime
+from datetime import datetime
 from typing import Any
 
-from deerflow.config.app_config import AppConfig
+from deerflow.config.memory_config import get_memory_config
 
 logger = logging.getLogger(__name__)
 
 
-# Module-level config pointer set by the middleware that owns the queue.
-# The queue runs on a background Timer thread where ``Runtime`` and FastAPI
-# request context are not accessible; the enqueuer (which does have runtime
-# context) is responsible for plumbing ``AppConfig`` through ``add()``.
-
-
 @dataclass
 class ConversationContext:
     """Context for a conversation to be processed for memory update."""
 
     thread_id: str
     messages: list[Any]
-    timestamp: datetime = field(default_factory=lambda: datetime.now(UTC))
+    timestamp: datetime = field(default_factory=datetime.utcnow)
     agent_name: str | None = None
-    user_id: str | None = None
     correction_detected: bool = False
     reinforcement_detected: bool = False
 
@@ -37,21 +30,10 @@ class MemoryUpdateQueue:
     This queue collects conversation contexts and processes them after
     a configurable debounce period. Multiple conversations received within
     the debounce window are batched together.
-
-    The queue captures an ``AppConfig`` reference at construction time and
-    reuses it for the MemoryUpdater it spawns. Callers must construct a
-    fresh queue when the config changes rather than reaching into a global.
     """
 
-    def __init__(self, app_config: AppConfig):
-        """Initialize the memory update queue.
-
-        Args:
-            app_config: Application config. The queue reads its own
-                ``memory`` section for debounce timing and hands the full
-                config to :class:`MemoryUpdater`.
-        """
-        self._app_config = app_config
+    def __init__(self):
+        """Initialize the memory update queue."""
         self._queue: list[ConversationContext] = []
         self._lock = threading.Lock()
         self._timer: threading.Timer | None = None
@@ -62,103 +44,65 @@ class MemoryUpdateQueue:
         thread_id: str,
         messages: list[Any],
         agent_name: str | None = None,
-        user_id: str | None = None,
         correction_detected: bool = False,
         reinforcement_detected: bool = False,
     ) -> None:
-        """Add a conversation to the update queue."""
-        config = self._app_config.memory
+        """Add a conversation to the update queue.
+
+        Args:
+            thread_id: The thread ID.
+            messages: The conversation messages.
+            agent_name: If provided, memory is stored per-agent. If None, uses global memory.
+            correction_detected: Whether recent turns include an explicit correction signal.
+            reinforcement_detected: Whether recent turns include a positive reinforcement signal.
+        """
+        config = get_memory_config()
         if not config.enabled:
             return
 
         with self._lock:
-            self._enqueue_locked(
+            existing_context = next(
+                (context for context in self._queue if context.thread_id == thread_id),
+                None,
+            )
+            merged_correction_detected = correction_detected or (existing_context.correction_detected if existing_context is not None else False)
+            merged_reinforcement_detected = reinforcement_detected or (existing_context.reinforcement_detected if existing_context is not None else False)
+            context = ConversationContext(
                 thread_id=thread_id,
                 messages=messages,
                 agent_name=agent_name,
-                user_id=user_id,
-                correction_detected=correction_detected,
-                reinforcement_detected=reinforcement_detected,
+                correction_detected=merged_correction_detected,
+                reinforcement_detected=merged_reinforcement_detected,
             )
+
+            # Check if this thread already has a pending update
+            # If so, replace it with the newer one
+            self._queue = [c for c in self._queue if c.thread_id != thread_id]
+            self._queue.append(context)
+
+            # Reset or start the debounce timer
             self._reset_timer()
 
         logger.info("Memory update queued for thread %s, queue size: %d", thread_id, len(self._queue))
 
-    def add_nowait(
-        self,
-        thread_id: str,
-        messages: list[Any],
-        agent_name: str | None = None,
-        user_id: str | None = None,
-        correction_detected: bool = False,
-        reinforcement_detected: bool = False,
-    ) -> None:
-        """Add a conversation and start processing immediately in the background."""
-        config = self._app_config.memory
-        if not config.enabled:
-            return
-
-        with self._lock:
-            self._enqueue_locked(
-                thread_id=thread_id,
-                messages=messages,
-                agent_name=agent_name,
-                user_id=user_id,
-                correction_detected=correction_detected,
-                reinforcement_detected=reinforcement_detected,
-            )
-            self._schedule_timer(0)
-
-        logger.info("Memory update queued for immediate processing on thread %s, queue size: %d", thread_id, len(self._queue))
-
-    def _enqueue_locked(
-        self,
-        *,
-        thread_id: str,
-        messages: list[Any],
-        agent_name: str | None,
-        user_id: str | None = None,
-        correction_detected: bool,
-        reinforcement_detected: bool,
-    ) -> None:
-        existing_context = next(
-            (context for context in self._queue if context.thread_id == thread_id),
-            None,
-        )
-        merged_correction_detected = correction_detected or (existing_context.correction_detected if existing_context is not None else False)
-        merged_reinforcement_detected = reinforcement_detected or (existing_context.reinforcement_detected if existing_context is not None else False)
-        context = ConversationContext(
-            thread_id=thread_id,
-            messages=messages,
-            agent_name=agent_name,
-            user_id=user_id,
-            correction_detected=merged_correction_detected,
-            reinforcement_detected=merged_reinforcement_detected,
-        )
-
-        self._queue = [c for c in self._queue if c.thread_id != thread_id]
-        self._queue.append(context)
-
     def _reset_timer(self) -> None:
         """Reset the debounce timer."""
-        config = self._app_config.memory
-        self._schedule_timer(config.debounce_seconds)
+        config = get_memory_config()
 
-        logger.debug("Memory update timer set for %ss", config.debounce_seconds)
-
-    def _schedule_timer(self, delay_seconds: float) -> None:
-        """Schedule queue processing after the provided delay."""
         # Cancel existing timer if any
         if self._timer is not None:
             self._timer.cancel()
 
+        # Start new timer
         self._timer = threading.Timer(
-            delay_seconds,
+            config.debounce_seconds,
             self._process_queue,
         )
         self._timer.daemon = True
         self._timer.start()
 
+        logger.debug("Memory update timer set for %ss", config.debounce_seconds)
+
     def _process_queue(self) -> None:
         """Process all queued conversation contexts."""
         # Import here to avoid circular dependency
@@ -166,8 +110,8 @@ class MemoryUpdateQueue:
 
         with self._lock:
             if self._processing:
-                # Preserve immediate flush semantics even if another worker is active.
-                self._schedule_timer(0)
+                # Already processing, reschedule
+                self._reset_timer()
                 return
 
             if not self._queue:
@@ -181,7 +125,7 @@ class MemoryUpdateQueue:
         logger.info("Processing %d queued memory updates", len(contexts_to_process))
 
         try:
-            updater = MemoryUpdater(self._app_config)
+            updater = MemoryUpdater()
 
             for context in contexts_to_process:
                 try:
@@ -192,7 +136,6 @@ class MemoryUpdateQueue:
                         agent_name=context.agent_name,
                         correction_detected=context.correction_detected,
                         reinforcement_detected=context.reinforcement_detected,
-                        user_id=context.user_id,
                     )
                     if success:
                         logger.info("Memory updated successfully for thread %s", context.thread_id)
@@ -221,13 +164,6 @@ class MemoryUpdateQueue:
 
         self._process_queue()
 
-    def flush_nowait(self) -> None:
-        """Start queue processing immediately in a background thread."""
-        with self._lock:
-            # Daemon thread: queued messages may be lost if the process exits
-            # before _process_queue completes. Acceptable for best-effort memory updates.
-            self._schedule_timer(0)
-
     def clear(self) -> None:
         """Clear the queue without processing.
 
@@ -253,35 +189,31 @@ class MemoryUpdateQueue:
             return self._processing
 
 
-# Queues keyed by ``id(AppConfig)`` so tests and multi-client setups with
-# distinct configs do not share a debounce queue.
-_memory_queues: dict[int, MemoryUpdateQueue] = {}
+# Global singleton instance
+_memory_queue: MemoryUpdateQueue | None = None
 _queue_lock = threading.Lock()
 
 
-def get_memory_queue(app_config: AppConfig) -> MemoryUpdateQueue:
-    """Get or create the memory update queue for the given app config."""
-    key = id(app_config)
-    with _queue_lock:
-        queue = _memory_queues.get(key)
-        if queue is None:
-            queue = MemoryUpdateQueue(app_config)
-            _memory_queues[key] = queue
-        return queue
+def get_memory_queue() -> MemoryUpdateQueue:
+    """Get the global memory update queue singleton.
 
-
-def reset_memory_queue(app_config: AppConfig | None = None) -> None:
-    """Reset memory queue(s).
-
-    Pass an ``app_config`` to reset only its queue, or omit to reset all
-    (useful at test teardown).
+    Returns:
+        The memory update queue instance.
     """
+    global _memory_queue
     with _queue_lock:
-        if app_config is not None:
-            queue = _memory_queues.pop(id(app_config), None)
-            if queue is not None:
-                queue.clear()
-            return
-        for queue in _memory_queues.values():
-            queue.clear()
-        _memory_queues.clear()
+        if _memory_queue is None:
+            _memory_queue = MemoryUpdateQueue()
+        return _memory_queue
+
+
+def reset_memory_queue() -> None:
+    """Reset the global memory queue.
+
+    This is useful for testing.
+    """
+    global _memory_queue
+    with _queue_lock:
+        if _memory_queue is not None:
+            _memory_queue.clear()
+        _memory_queue = None

backend/packages/harness/deerflow/agents/memory/storage.py

@@ -4,28 +4,22 @@ import abc
 import json
 import logging
 import threading
-import uuid
-from datetime import UTC, datetime
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
 from deerflow.config.agents_config import AGENT_NAME_PATTERN
-from deerflow.config.memory_config import MemoryConfig
+from deerflow.config.memory_config import get_memory_config
 from deerflow.config.paths import get_paths
 
 logger = logging.getLogger(__name__)
 
 
-def utc_now_iso_z() -> str:
-    """Current UTC time as ISO-8601 with ``Z`` suffix (matches prior naive-UTC output)."""
-    return datetime.now(UTC).isoformat().removesuffix("+00:00") + "Z"
-
-
 def create_empty_memory() -> dict[str, Any]:
     """Create an empty memory structure."""
     return {
         "version": "1.0",
-        "lastUpdated": utc_now_iso_z(),
+        "lastUpdated": datetime.utcnow().isoformat() + "Z",
         "user": {
             "workContext": {"summary": "", "updatedAt": ""},
             "personalContext": {"summary": "", "updatedAt": ""},
@@ -44,17 +38,17 @@ class MemoryStorage(abc.ABC):
     """Abstract base class for memory storage providers."""
 
     @abc.abstractmethod
-    def load(self, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+    def load(self, agent_name: str | None = None) -> dict[str, Any]:
         """Load memory data for the given agent."""
         pass
 
     @abc.abstractmethod
-    def reload(self, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+    def reload(self, agent_name: str | None = None) -> dict[str, Any]:
         """Force reload memory data for the given agent."""
         pass
 
     @abc.abstractmethod
-    def save(self, memory_data: dict[str, Any], agent_name: str | None = None, *, user_id: str | None = None) -> bool:
+    def save(self, memory_data: dict[str, Any], agent_name: str | None = None) -> bool:
         """Save memory data for the given agent."""
         pass
 
@@ -62,20 +56,11 @@ class MemoryStorage(abc.ABC):
 class FileMemoryStorage(MemoryStorage):
     """File-based memory storage provider."""
 
-    def __init__(self, memory_config: MemoryConfig):
-        """Initialize the file memory storage.
-
-        Args:
-            memory_config: Memory configuration (storage_path etc.). Stored on
-                the instance so per-request lookups don't need to reach for
-                ambient state.
-        """
-        self._memory_config = memory_config
-        # Per-user/agent memory cache: keyed by (user_id, agent_name) tuple (None = global)
+    def __init__(self):
+        """Initialize the file memory storage."""
+        # Per-agent memory cache: keyed by agent_name (None = global)
         # Value: (memory_data, file_mtime)
-        self._memory_cache: dict[tuple[str | None, str | None], tuple[dict[str, Any], float | None]] = {}
-        # Guards all reads and writes to _memory_cache across concurrent callers.
-        self._cache_lock = threading.Lock()
+        self._memory_cache: dict[str | None, tuple[dict[str, Any], float | None]] = {}
 
     def _validate_agent_name(self, agent_name: str) -> None:
         """Validate that the agent name is safe to use in filesystem paths.
@@ -88,28 +73,21 @@ class FileMemoryStorage(MemoryStorage):
         if not AGENT_NAME_PATTERN.match(agent_name):
             raise ValueError(f"Invalid agent name {agent_name!r}: names must match {AGENT_NAME_PATTERN.pattern}")
 
-    def _get_memory_file_path(self, agent_name: str | None = None, *, user_id: str | None = None) -> Path:
+    def _get_memory_file_path(self, agent_name: str | None = None) -> Path:
         """Get the path to the memory file."""
-        config = self._memory_config
-        if user_id is not None:
-            if agent_name is not None:
-                self._validate_agent_name(agent_name)
-                return get_paths().user_agent_memory_file(user_id, agent_name)
-            if config.storage_path and Path(config.storage_path).is_absolute():
-                return Path(config.storage_path)
-            return get_paths().user_memory_file(user_id)
-        # Legacy: no user_id
         if agent_name is not None:
             self._validate_agent_name(agent_name)
             return get_paths().agent_memory_file(agent_name)
+
+        config = get_memory_config()
         if config.storage_path:
             p = Path(config.storage_path)
             return p if p.is_absolute() else get_paths().base_dir / p
         return get_paths().memory_file
 
-    def _load_memory_from_file(self, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+    def _load_memory_from_file(self, agent_name: str | None = None) -> dict[str, Any]:
         """Load memory data from file."""
-        file_path = self._get_memory_file_path(agent_name, user_id=user_id)
+        file_path = self._get_memory_file_path(agent_name)
 
         if not file_path.exists():
             return create_empty_memory()
@@ -122,55 +100,46 @@ class FileMemoryStorage(MemoryStorage):
             logger.warning("Failed to load memory file: %s", e)
             return create_empty_memory()
 
-    def load(self, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+    def load(self, agent_name: str | None = None) -> dict[str, Any]:
         """Load memory data (cached with file modification time check)."""
-        file_path = self._get_memory_file_path(agent_name, user_id=user_id)
+        file_path = self._get_memory_file_path(agent_name)
 
         try:
             current_mtime = file_path.stat().st_mtime if file_path.exists() else None
         except OSError:
             current_mtime = None
 
-        cache_key = (user_id, agent_name)
-        with self._cache_lock:
-            cached = self._memory_cache.get(cache_key)
-            if cached is not None and cached[1] == current_mtime:
-                return cached[0]
+        cached = self._memory_cache.get(agent_name)
 
-        memory_data = self._load_memory_from_file(agent_name, user_id=user_id)
+        if cached is None or cached[1] != current_mtime:
+            memory_data = self._load_memory_from_file(agent_name)
+            self._memory_cache[agent_name] = (memory_data, current_mtime)
+            return memory_data
 
-        with self._cache_lock:
-            self._memory_cache[cache_key] = (memory_data, current_mtime)
+        return cached[0]
 
-        return memory_data
-
-    def reload(self, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+    def reload(self, agent_name: str | None = None) -> dict[str, Any]:
         """Reload memory data from file, forcing cache invalidation."""
-        file_path = self._get_memory_file_path(agent_name, user_id=user_id)
-        memory_data = self._load_memory_from_file(agent_name, user_id=user_id)
+        file_path = self._get_memory_file_path(agent_name)
+        memory_data = self._load_memory_from_file(agent_name)
 
         try:
             mtime = file_path.stat().st_mtime if file_path.exists() else None
         except OSError:
             mtime = None
 
-        cache_key = (user_id, agent_name)
-        with self._cache_lock:
-            self._memory_cache[cache_key] = (memory_data, mtime)
+        self._memory_cache[agent_name] = (memory_data, mtime)
         return memory_data
 
-    def save(self, memory_data: dict[str, Any], agent_name: str | None = None, *, user_id: str | None = None) -> bool:
+    def save(self, memory_data: dict[str, Any], agent_name: str | None = None) -> bool:
         """Save memory data to file and update cache."""
-        file_path = self._get_memory_file_path(agent_name, user_id=user_id)
+        file_path = self._get_memory_file_path(agent_name)
 
         try:
             file_path.parent.mkdir(parents=True, exist_ok=True)
-            # Shallow-copy before adding lastUpdated so the caller's dict is not
-            # mutated as a side-effect, and the cache reference is not silently
-            # updated before the file write succeeds.
-            memory_data = {**memory_data, "lastUpdated": utc_now_iso_z()}
+            memory_data["lastUpdated"] = datetime.utcnow().isoformat() + "Z"
 
-            temp_path = file_path.with_suffix(f".{uuid.uuid4().hex}.tmp")
+            temp_path = file_path.with_suffix(".tmp")
             with open(temp_path, "w", encoding="utf-8") as f:
                 json.dump(memory_data, f, indent=2, ensure_ascii=False)
 
@@ -181,9 +150,7 @@ class FileMemoryStorage(MemoryStorage):
             except OSError:
                 mtime = None
 
-            cache_key = (user_id, agent_name)
-            with self._cache_lock:
-                self._memory_cache[cache_key] = (memory_data, mtime)
+            self._memory_cache[agent_name] = (memory_data, mtime)
             logger.info("Memory saved to %s", file_path)
             return True
         except OSError as e:
@@ -191,31 +158,23 @@ class FileMemoryStorage(MemoryStorage):
             return False
 
 
-# Instances keyed by (storage_class_path, id(memory_config)) so tests can
-# construct isolated storages and multi-client setups with different configs
-# don't collide on a single process-wide singleton.
-_storage_instances: dict[tuple[str, int], MemoryStorage] = {}
+_storage_instance: MemoryStorage | None = None
 _storage_lock = threading.Lock()
 
 
-def get_memory_storage(memory_config: MemoryConfig) -> MemoryStorage:
-    """Get the configured memory storage instance.
-
-    Caches one instance per ``(storage_class, memory_config)`` pair. In
-    single-config deployments this collapses to one instance; in multi-client
-    or test scenarios each config gets its own storage.
-    """
-    key = (memory_config.storage_class, id(memory_config))
-    existing = _storage_instances.get(key)
-    if existing is not None:
-        return existing
+def get_memory_storage() -> MemoryStorage:
+    """Get the configured memory storage instance."""
+    global _storage_instance
+    if _storage_instance is not None:
+        return _storage_instance
 
     with _storage_lock:
-        existing = _storage_instances.get(key)
-        if existing is not None:
-            return existing
+        if _storage_instance is not None:
+            return _storage_instance
+
+        config = get_memory_config()
+        storage_class_path = config.storage_class
 
-        storage_class_path = memory_config.storage_class
         try:
             module_path, class_name = storage_class_path.rsplit(".", 1)
             import importlib
@@ -229,14 +188,13 @@ def get_memory_storage(memory_config: MemoryConfig) -> MemoryStorage:
             if not issubclass(storage_class, MemoryStorage):
                 raise TypeError(f"Configured memory storage '{storage_class_path}' is not a subclass of MemoryStorage")
 
-            instance = storage_class(memory_config)
+            _storage_instance = storage_class()
         except Exception as e:
             logger.error(
                 "Failed to load memory storage %s, falling back to FileMemoryStorage: %s",
                 storage_class_path,
                 e,
             )
-            instance = FileMemoryStorage(memory_config)
+            _storage_instance = FileMemoryStorage()
 
-        _storage_instances[key] = instance
-        return instance
+    return _storage_instance

backend/packages/harness/deerflow/agents/memory/summarization_hook.py

@@ -1,38 +0,0 @@
-"""Hooks fired before summarization removes messages from state."""
-
-from __future__ import annotations
-
-from deerflow.agents.memory.message_processing import detect_correction, detect_reinforcement, filter_messages_for_memory
-from deerflow.agents.memory.queue import get_memory_queue
-from deerflow.agents.middlewares.summarization_middleware import SummarizationEvent
-from deerflow.config.app_config import AppConfig
-
-
-def memory_flush_hook(event: SummarizationEvent) -> None:
-    """Flush messages about to be summarized into the memory queue.
-
-    Reads ``AppConfig`` from disk on every invocation. This hook is fired by
-    ``SummarizationMiddleware`` which has no ergonomic way to thread an
-    explicit ``app_config`` through; ``AppConfig.from_file()`` is a pure load
-    so the cost is acceptable for this rare pre-summarization callback.
-    """
-    app_config = AppConfig.from_file()
-    if not app_config.memory.enabled or not event.thread_id:
-        return
-
-    filtered_messages = filter_messages_for_memory(list(event.messages_to_summarize))
-    user_messages = [message for message in filtered_messages if getattr(message, "type", None) == "human"]
-    assistant_messages = [message for message in filtered_messages if getattr(message, "type", None) == "ai"]
-    if not user_messages or not assistant_messages:
-        return
-
-    correction_detected = detect_correction(filtered_messages)
-    reinforcement_detected = not correction_detected and detect_reinforcement(filtered_messages)
-    queue = get_memory_queue(app_config)
-    queue.add_nowait(
-        thread_id=event.thread_id,
-        messages=filtered_messages,
-        agent_name=event.agent_name,
-        correction_detected=correction_detected,
-        reinforcement_detected=reinforcement_detected,
-    )

backend/packages/harness/deerflow/agents/memory/updater.py

@@ -1,71 +1,67 @@
 """Memory updater for reading, writing, and updating memory data."""
 
-import asyncio
-import atexit
-import concurrent.futures
-import copy
 import json
 import logging
 import math
 import re
 import uuid
-from collections.abc import Awaitable
+from datetime import datetime
 from typing import Any
 
 from deerflow.agents.memory.prompt import (
     MEMORY_UPDATE_PROMPT,
     format_conversation_for_update,
 )
-from deerflow.agents.memory.storage import (
-    create_empty_memory,
-    get_memory_storage,
-    utc_now_iso_z,
-)
-from deerflow.config.app_config import AppConfig
-from deerflow.config.memory_config import MemoryConfig
+from deerflow.agents.memory.storage import create_empty_memory, get_memory_storage
+from deerflow.config.memory_config import get_memory_config
 from deerflow.models import create_chat_model
 
 logger = logging.getLogger(__name__)
 
-_SYNC_MEMORY_UPDATER_EXECUTOR = concurrent.futures.ThreadPoolExecutor(
-    max_workers=4,
-    thread_name_prefix="memory-updater-sync",
-)
-atexit.register(lambda: _SYNC_MEMORY_UPDATER_EXECUTOR.shutdown(wait=False))
-
 
 def _create_empty_memory() -> dict[str, Any]:
     """Backward-compatible wrapper around the storage-layer empty-memory factory."""
     return create_empty_memory()
 
 
-def _save_memory_to_file(memory_config: MemoryConfig, memory_data: dict[str, Any], agent_name: str | None = None, *, user_id: str | None = None) -> bool:
-    """Save via the configured memory storage."""
-    return get_memory_storage(memory_config).save(memory_data, agent_name, user_id=user_id)
+def _save_memory_to_file(memory_data: dict[str, Any], agent_name: str | None = None) -> bool:
+    """Backward-compatible wrapper around the configured memory storage save path."""
+    return get_memory_storage().save(memory_data, agent_name)
 
 
-def get_memory_data(memory_config: MemoryConfig, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+def get_memory_data(agent_name: str | None = None) -> dict[str, Any]:
     """Get the current memory data via storage provider."""
-    return get_memory_storage(memory_config).load(agent_name, user_id=user_id)
+    return get_memory_storage().load(agent_name)
 
 
-def reload_memory_data(memory_config: MemoryConfig, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+def reload_memory_data(agent_name: str | None = None) -> dict[str, Any]:
     """Reload memory data via storage provider."""
-    return get_memory_storage(memory_config).reload(agent_name, user_id=user_id)
+    return get_memory_storage().reload(agent_name)
 
 
-def import_memory_data(memory_config: MemoryConfig, memory_data: dict[str, Any], agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
-    """Persist imported memory data via storage provider."""
-    storage = get_memory_storage(memory_config)
-    if not storage.save(memory_data, agent_name, user_id=user_id):
+def import_memory_data(memory_data: dict[str, Any], agent_name: str | None = None) -> dict[str, Any]:
+    """Persist imported memory data via storage provider.
+
+    Args:
+        memory_data: Full memory payload to persist.
+        agent_name: If provided, imports into per-agent memory.
+
+    Returns:
+        The saved memory data after storage normalization.
+
+    Raises:
+        OSError: If persisting the imported memory fails.
+    """
+    storage = get_memory_storage()
+    if not storage.save(memory_data, agent_name):
         raise OSError("Failed to save imported memory data")
-    return storage.load(agent_name, user_id=user_id)
+    return storage.load(agent_name)
 
 
-def clear_memory_data(memory_config: MemoryConfig, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+def clear_memory_data(agent_name: str | None = None) -> dict[str, Any]:
     """Clear all stored memory data and persist an empty structure."""
     cleared_memory = create_empty_memory()
-    if not _save_memory_to_file(memory_config, cleared_memory, agent_name, user_id=user_id):
+    if not _save_memory_to_file(cleared_memory, agent_name):
         raise OSError("Failed to save cleared memory data")
     return cleared_memory
 
@@ -78,13 +74,10 @@ def _validate_confidence(confidence: float) -> float:
 
 
 def create_memory_fact(
-    memory_config: MemoryConfig,
     content: str,
     category: str = "context",
     confidence: float = 0.5,
     agent_name: str | None = None,
-    *,
-    user_id: str | None = None,
 ) -> dict[str, Any]:
     """Create a new fact and persist the updated memory data."""
     normalized_content = content.strip()
@@ -93,8 +86,8 @@ def create_memory_fact(
 
     normalized_category = category.strip() or "context"
     validated_confidence = _validate_confidence(confidence)
-    now = utc_now_iso_z()
-    memory_data = get_memory_data(memory_config, agent_name, user_id=user_id)
+    now = datetime.utcnow().isoformat() + "Z"
+    memory_data = get_memory_data(agent_name)
     updated_memory = dict(memory_data)
     facts = list(memory_data.get("facts", []))
     facts.append(
@@ -109,15 +102,15 @@ def create_memory_fact(
     )
     updated_memory["facts"] = facts
 
-    if not _save_memory_to_file(memory_config, updated_memory, agent_name, user_id=user_id):
+    if not _save_memory_to_file(updated_memory, agent_name):
         raise OSError("Failed to save memory data after creating fact")
 
     return updated_memory
 
 
-def delete_memory_fact(memory_config: MemoryConfig, fact_id: str, agent_name: str | None = None, *, user_id: str | None = None) -> dict[str, Any]:
+def delete_memory_fact(fact_id: str, agent_name: str | None = None) -> dict[str, Any]:
     """Delete a fact by its id and persist the updated memory data."""
-    memory_data = get_memory_data(memory_config, agent_name, user_id=user_id)
+    memory_data = get_memory_data(agent_name)
     facts = memory_data.get("facts", [])
     updated_facts = [fact for fact in facts if fact.get("id") != fact_id]
     if len(updated_facts) == len(facts):
@@ -126,24 +119,21 @@ def delete_memory_fact(memory_config: MemoryConfig, fact_id: str, agent_name: st
     updated_memory = dict(memory_data)
     updated_memory["facts"] = updated_facts
 
-    if not _save_memory_to_file(memory_config, updated_memory, agent_name, user_id=user_id):
+    if not _save_memory_to_file(updated_memory, agent_name):
         raise OSError(f"Failed to save memory data after deleting fact '{fact_id}'")
 
     return updated_memory
 
 
 def update_memory_fact(
-    memory_config: MemoryConfig,
     fact_id: str,
     content: str | None = None,
     category: str | None = None,
     confidence: float | None = None,
     agent_name: str | None = None,
-    *,
-    user_id: str | None = None,
 ) -> dict[str, Any]:
     """Update an existing fact and persist the updated memory data."""
-    memory_data = get_memory_data(memory_config, agent_name, user_id=user_id)
+    memory_data = get_memory_data(agent_name)
     updated_memory = dict(memory_data)
     updated_facts: list[dict[str, Any]] = []
     found = False
@@ -170,7 +160,7 @@ def update_memory_fact(
 
     updated_memory["facts"] = updated_facts
 
-    if not _save_memory_to_file(memory_config, updated_memory, agent_name, user_id=user_id):
+    if not _save_memory_to_file(updated_memory, agent_name):
         raise OSError(f"Failed to save memory data after updating fact '{fact_id}'")
 
     return updated_memory
@@ -213,39 +203,6 @@ def _extract_text(content: Any) -> str:
     return str(content)
 
 
-def _run_async_update_sync(coro: Awaitable[bool]) -> bool:
-    """Run an async memory update from sync code, including nested-loop contexts."""
-    handed_off = False
-
-    try:
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = None
-
-        if loop is not None and loop.is_running():
-            future = _SYNC_MEMORY_UPDATER_EXECUTOR.submit(asyncio.run, coro)
-            handed_off = True
-            return future.result()
-
-        handed_off = True
-        return asyncio.run(coro)
-    except Exception:
-        if not handed_off:
-            close = getattr(coro, "close", None)
-            if callable(close):
-                try:
-                    close()
-                except Exception:
-                    logger.debug(
-                        "Failed to close un-awaited memory update coroutine",
-                        exc_info=True,
-                    )
-
-        logger.exception("Failed to run async memory update from sync context")
-        return False
-
-
 # Matches sentences that describe a file-upload *event* rather than general
 # file-related work.  Deliberately narrow to avoid removing legitimate facts
 # such as "User works with CSV files" or "prefers PDF export".
@@ -295,141 +252,19 @@ def _fact_content_key(content: Any) -> str | None:
 class MemoryUpdater:
     """Updates memory using LLM based on conversation context."""
 
-    def __init__(self, app_config: AppConfig, model_name: str | None = None):
+    def __init__(self, model_name: str | None = None):
         """Initialize the memory updater.
 
         Args:
-            app_config: Application config (the updater needs both ``memory``
-                section for behavior and the full config for ``create_chat_model``).
             model_name: Optional model name to use. If None, uses config or default.
         """
-        self._app_config = app_config
         self._model_name = model_name
 
-    @property
-    def _memory_config(self) -> MemoryConfig:
-        return self._app_config.memory
-
     def _get_model(self):
         """Get the model for memory updates."""
-        model_name = self._model_name or self._memory_config.model_name
-        return create_chat_model(name=model_name, thinking_enabled=False, app_config=self._app_config)
-
-    def _build_correction_hint(
-        self,
-        correction_detected: bool,
-        reinforcement_detected: bool,
-    ) -> str:
-        """Build optional prompt hints for correction and reinforcement signals."""
-        correction_hint = ""
-        if correction_detected:
-            correction_hint = (
-                "IMPORTANT: Explicit correction signals were detected in this conversation. "
-                "Pay special attention to what the agent got wrong, what the user corrected, "
-                "and record the correct approach as a fact with category "
-                '"correction" and confidence >= 0.95 when appropriate.'
-            )
-        if reinforcement_detected:
-            reinforcement_hint = (
-                "IMPORTANT: Positive reinforcement signals were detected in this conversation. "
-                "The user explicitly confirmed the agent's approach was correct or helpful. "
-                "Record the confirmed approach, style, or preference as a fact with category "
-                '"preference" or "behavior" and confidence >= 0.9 when appropriate.'
-            )
-            correction_hint = (correction_hint + "\n" + reinforcement_hint).strip() if correction_hint else reinforcement_hint
-
-        return correction_hint
-
-    def _prepare_update_prompt(
-        self,
-        messages: list[Any],
-        agent_name: str | None,
-        correction_detected: bool,
-        reinforcement_detected: bool,
-        user_id: str | None = None,
-    ) -> tuple[dict[str, Any], str] | None:
-        """Load memory and build the update prompt for a conversation."""
-        config = self._memory_config
-        if not config.enabled or not messages:
-            return None
-
-        current_memory = get_memory_data(config, agent_name, user_id=user_id)
-        conversation_text = format_conversation_for_update(messages)
-        if not conversation_text.strip():
-            return None
-
-        correction_hint = self._build_correction_hint(
-            correction_detected=correction_detected,
-            reinforcement_detected=reinforcement_detected,
-        )
-        prompt = MEMORY_UPDATE_PROMPT.format(
-            current_memory=json.dumps(current_memory, indent=2),
-            conversation=conversation_text,
-            correction_hint=correction_hint,
-        )
-        return current_memory, prompt
-
-    def _finalize_update(
-        self,
-        current_memory: dict[str, Any],
-        response_content: Any,
-        thread_id: str | None,
-        agent_name: str | None,
-        user_id: str | None = None,
-    ) -> bool:
-        """Parse the model response, apply updates, and persist memory."""
-        response_text = _extract_text(response_content).strip()
-
-        if response_text.startswith("```"):
-            lines = response_text.split("\n")
-            response_text = "\n".join(lines[1:-1] if lines[-1] == "```" else lines[1:])
-
-        update_data = json.loads(response_text)
-        # Deep-copy before in-place mutation so a subsequent save() failure
-        # cannot corrupt the still-cached original object reference.
-        updated_memory = self._apply_updates(copy.deepcopy(current_memory), update_data, thread_id)
-        updated_memory = _strip_upload_mentions_from_memory(updated_memory)
-        return get_memory_storage(self._memory_config).save(updated_memory, agent_name, user_id=user_id)
-
-    async def aupdate_memory(
-        self,
-        messages: list[Any],
-        thread_id: str | None = None,
-        agent_name: str | None = None,
-        correction_detected: bool = False,
-        reinforcement_detected: bool = False,
-        user_id: str | None = None,
-    ) -> bool:
-        """Update memory asynchronously based on conversation messages."""
-        try:
-            prepared = await asyncio.to_thread(
-                self._prepare_update_prompt,
-                messages=messages,
-                agent_name=agent_name,
-                correction_detected=correction_detected,
-                reinforcement_detected=reinforcement_detected,
-                user_id=user_id,
-            )
-            if prepared is None:
-                return False
-
-            current_memory, prompt = prepared
-            model = self._get_model()
-            response = await model.ainvoke(prompt, config={"run_name": "memory_agent"})
-            return await asyncio.to_thread(
-                self._finalize_update,
-                current_memory=current_memory,
-                response_content=response.content,
-                thread_id=thread_id,
-                agent_name=agent_name,
-                user_id=user_id,
-            )
-        except json.JSONDecodeError as e:
-            logger.warning("Failed to parse LLM response for memory update: %s", e)
-            return False
-        except Exception as e:
-            logger.exception("Memory update failed: %s", e)
-            return False
+        config = get_memory_config()
+        model_name = self._model_name or config.model_name
+        return create_chat_model(name=model_name, thinking_enabled=False)
 
     def update_memory(
         self,
@@ -438,9 +273,8 @@ class MemoryUpdater:
         agent_name: str | None = None,
         correction_detected: bool = False,
         reinforcement_detected: bool = False,
-        user_id: str | None = None,
     ) -> bool:
-        """Synchronously update memory via the async updater path.
+        """Update memory based on conversation messages.
 
         Args:
             messages: List of conversation messages.
@@ -448,12 +282,11 @@ class MemoryUpdater:
             agent_name: If provided, updates per-agent memory. If None, updates global memory.
             correction_detected: Whether recent turns include an explicit correction signal.
             reinforcement_detected: Whether recent turns include a positive reinforcement signal.
-            user_id: If provided, scopes memory to a specific user.
 
         Returns:
             True if update was successful, False otherwise.
         """
-        config = self._memory_config
+        config = get_memory_config()
         if not config.enabled:
             return False
 
@@ -462,7 +295,7 @@ class MemoryUpdater:
 
         try:
             # Get current memory
-            current_memory = get_memory_data(config, agent_name, user_id=user_id)
+            current_memory = get_memory_data(agent_name)
 
             # Format conversation for prompt
             conversation_text = format_conversation_for_update(messages)
@@ -517,7 +350,7 @@ class MemoryUpdater:
             updated_memory = _strip_upload_mentions_from_memory(updated_memory)
 
             # Save
-            return get_memory_storage(config).save(updated_memory, agent_name, user_id=user_id)
+            return get_memory_storage().save(updated_memory, agent_name)
 
         except json.JSONDecodeError as e:
             logger.warning("Failed to parse LLM response for memory update: %s", e)
@@ -542,8 +375,8 @@ class MemoryUpdater:
         Returns:
             Updated memory data.
         """
-        config = self._memory_config
-        now = utc_now_iso_z()
+        config = get_memory_config()
+        now = datetime.utcnow().isoformat() + "Z"
 
         # Update user sections
         user_updates = update_data.get("user", {})
@@ -619,7 +452,6 @@ def update_memory_from_conversation(
     agent_name: str | None = None,
     correction_detected: bool = False,
     reinforcement_detected: bool = False,
-    user_id: str | None = None,
 ) -> bool:
     """Convenience function to update memory from a conversation.
 
@@ -629,10 +461,9 @@ def update_memory_from_conversation(
         agent_name: If provided, updates per-agent memory. If None, updates global memory.
         correction_detected: Whether recent turns include an explicit correction signal.
         reinforcement_detected: Whether recent turns include a positive reinforcement signal.
-        user_id: If provided, scopes memory to a specific user.
 
     Returns:
         True if successful, False otherwise.
     """
     updater = MemoryUpdater()
-    return updater.update_memory(messages, thread_id, agent_name, correction_detected, reinforcement_detected, user_id=user_id)
+    return updater.update_memory(messages, thread_id, agent_name, correction_detected, reinforcement_detected)

backend/packages/harness/deerflow/agents/middlewares/clarification_middleware.py

@@ -1,9 +1,7 @@
 """Middleware for intercepting clarification requests and presenting them to the user."""
 
-import json
 import logging
 from collections.abc import Callable
-from hashlib import sha256
 from typing import override
 
 from langchain.agents import AgentState
@@ -37,13 +35,6 @@ class ClarificationMiddleware(AgentMiddleware[ClarificationMiddlewareState]):
 
     state_schema = ClarificationMiddlewareState
 
-    def _stable_message_id(self, tool_call_id: str, formatted_message: str) -> str:
-        """Build a deterministic message ID so retried clarification calls replace, not append."""
-        if tool_call_id:
-            return f"clarification:{tool_call_id}"
-        digest = sha256(formatted_message.encode("utf-8")).hexdigest()[:16]
-        return f"clarification:{digest}"
-
     def _is_chinese(self, text: str) -> bool:
         """Check if text contains Chinese characters.
 
@@ -69,20 +60,6 @@ class ClarificationMiddleware(AgentMiddleware[ClarificationMiddlewareState]):
         context = args.get("context")
         options = args.get("options", [])
 
-        # Some models (e.g. Qwen3-Max) serialize array parameters as JSON strings
-        # instead of native arrays. Deserialize and normalize so `options`
-        # is always a list for the rendering logic below.
-        if isinstance(options, str):
-            try:
-                options = json.loads(options)
-            except (json.JSONDecodeError, TypeError):
-                options = [options]
-
-        if options is None:
-            options = []
-        elif not isinstance(options, list):
-            options = [options]
-
         # Type-specific icons
         type_icons = {
             "missing_info": "❓",
@@ -139,7 +116,6 @@ class ClarificationMiddleware(AgentMiddleware[ClarificationMiddlewareState]):
         # Create a ToolMessage with the formatted question
         # This will be added to the message history
         tool_message = ToolMessage(
-            id=self._stable_message_id(tool_call_id, formatted_message),
             content=formatted_message,
             tool_call_id=tool_call_id,
             name="ask_clarification",

backend/packages/harness/deerflow/agents/middlewares/dangling_tool_call_middleware.py

@@ -13,7 +13,6 @@ at the correct positions (immediately after each dangling AIMessage), not append
 to the end of the message list as before_model + add_messages reducer would do.
 """
 
-import json
 import logging
 from collections.abc import Awaitable, Callable
 from typing import override
@@ -34,44 +33,6 @@ class DanglingToolCallMiddleware(AgentMiddleware[AgentState]):
     offending AIMessage so the LLM receives a well-formed conversation.
     """
 
-    @staticmethod
-    def _message_tool_calls(msg) -> list[dict]:
-        """Return normalized tool calls from structured fields or raw provider payloads."""
-        tool_calls = getattr(msg, "tool_calls", None) or []
-        if tool_calls:
-            return list(tool_calls)
-
-        raw_tool_calls = (getattr(msg, "additional_kwargs", None) or {}).get("tool_calls") or []
-        normalized: list[dict] = []
-        for raw_tc in raw_tool_calls:
-            if not isinstance(raw_tc, dict):
-                continue
-
-            function = raw_tc.get("function")
-            name = raw_tc.get("name")
-            if not name and isinstance(function, dict):
-                name = function.get("name")
-
-            args = raw_tc.get("args", {})
-            if not args and isinstance(function, dict):
-                raw_args = function.get("arguments")
-                if isinstance(raw_args, str):
-                    try:
-                        parsed_args = json.loads(raw_args)
-                    except (TypeError, ValueError, json.JSONDecodeError):
-                        parsed_args = {}
-                    args = parsed_args if isinstance(parsed_args, dict) else {}
-
-            normalized.append(
-                {
-                    "id": raw_tc.get("id"),
-                    "name": name or "unknown",
-                    "args": args if isinstance(args, dict) else {},
-                }
-            )
-
-        return normalized
-
     def _build_patched_messages(self, messages: list) -> list | None:
         """Return a new message list with patches inserted at the correct positions.
 
@@ -90,7 +51,7 @@ class DanglingToolCallMiddleware(AgentMiddleware[AgentState]):
         for msg in messages:
             if getattr(msg, "type", None) != "ai":
                 continue
-            for tc in self._message_tool_calls(msg):
+            for tc in getattr(msg, "tool_calls", None) or []:
                 tc_id = tc.get("id")
                 if tc_id and tc_id not in existing_tool_msg_ids:
                     needs_patch = True
@@ -109,7 +70,7 @@ class DanglingToolCallMiddleware(AgentMiddleware[AgentState]):
             patched.append(msg)
             if getattr(msg, "type", None) != "ai":
                 continue
-            for tc in self._message_tool_calls(msg):
+            for tc in getattr(msg, "tool_calls", None) or []:
                 tc_id = tc.get("id")
                 if tc_id and tc_id not in existing_tool_msg_ids and tc_id not in patched_ids:
                     patched.append(

backend/packages/harness/deerflow/agents/middlewares/deferred_tool_filter_middleware.py

@@ -16,9 +16,6 @@ from typing import override
 from langchain.agents import AgentState
 from langchain.agents.middleware import AgentMiddleware
 from langchain.agents.middleware.types import ModelCallResult, ModelRequest, ModelResponse
-from langchain_core.messages import ToolMessage
-from langgraph.prebuilt.tool_node import ToolCallRequest
-from langgraph.types import Command
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +35,7 @@ class DeferredToolFilterMiddleware(AgentMiddleware[AgentState]):
         if not registry:
             return request
 
-        deferred_names = registry.deferred_names
+        deferred_names = {e.name for e in registry.entries}
         active_tools = [t for t in request.tools if getattr(t, "name", None) not in deferred_names]
 
         if len(active_tools) < len(request.tools):
@@ -46,28 +43,6 @@ class DeferredToolFilterMiddleware(AgentMiddleware[AgentState]):
 
         return request.override(tools=active_tools)
 
-    def _blocked_tool_message(self, request: ToolCallRequest) -> ToolMessage | None:
-        from deerflow.tools.builtins.tool_search import get_deferred_registry
-
-        registry = get_deferred_registry()
-        if not registry:
-            return None
-
-        tool_name = str(request.tool_call.get("name") or "")
-        if not tool_name:
-            return None
-
-        if not registry.contains(tool_name):
-            return None
-
-        tool_call_id = str(request.tool_call.get("id") or "missing_tool_call_id")
-        return ToolMessage(
-            content=(f"Error: Tool '{tool_name}' is deferred and has not been promoted yet. Call tool_search first to expose and promote this tool's schema, then retry."),
-            tool_call_id=tool_call_id,
-            name=tool_name,
-            status="error",
-        )
-
     @override
     def wrap_model_call(
         self,
@@ -76,17 +51,6 @@ class DeferredToolFilterMiddleware(AgentMiddleware[AgentState]):
     ) -> ModelCallResult:
         return handler(self._filter_tools(request))
 
-    @override
-    def wrap_tool_call(
-        self,
-        request: ToolCallRequest,
-        handler: Callable[[ToolCallRequest], ToolMessage | Command],
-    ) -> ToolMessage | Command:
-        blocked = self._blocked_tool_message(request)
-        if blocked is not None:
-            return blocked
-        return handler(request)
-
     @override
     async def awrap_model_call(
         self,
@@ -94,14 +58,3 @@ class DeferredToolFilterMiddleware(AgentMiddleware[AgentState]):
         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
     ) -> ModelCallResult:
         return await handler(self._filter_tools(request))
-
-    @override
-    async def awrap_tool_call(
-        self,
-        request: ToolCallRequest,
-        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
-    ) -> ToolMessage | Command:
-        blocked = self._blocked_tool_message(request)
-        if blocked is not None:
-            return blocked
-        return await handler(request)

backend/packages/harness/deerflow/agents/middlewares/llm_error_handling_middleware.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import threading
 import time
 from collections.abc import Awaitable, Callable
 from email.utils import parsedate_to_datetime
@@ -20,8 +19,6 @@ from langchain.agents.middleware.types import (
 from langchain_core.messages import AIMessage
 from langgraph.errors import GraphBubbleUp
 
-from deerflow.config.app_config import AppConfig
-
 logger = logging.getLogger(__name__)
 
 _RETRIABLE_STATUS_CODES = {408, 409, 425, 429, 500, 502, 503, 504}
@@ -70,80 +67,6 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
     retry_base_delay_ms: int = 1000
     retry_cap_delay_ms: int = 8000
 
-    circuit_failure_threshold: int = 5
-    circuit_recovery_timeout_sec: int = 60
-
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-
-        # Load Circuit Breaker configs from app config if available, fall back to defaults
-        try:
-            app_config = AppConfig.from_file()
-            self.circuit_failure_threshold = app_config.circuit_breaker.failure_threshold
-            self.circuit_recovery_timeout_sec = app_config.circuit_breaker.recovery_timeout_sec
-        except (FileNotFoundError, RuntimeError):
-            # Gracefully fall back to class defaults in test environments
-            pass
-
-        # Circuit Breaker state
-        self._circuit_lock = threading.Lock()
-        self._circuit_failure_count = 0
-        self._circuit_open_until = 0.0
-        self._circuit_state = "closed"
-        self._circuit_probe_in_flight = False
-
-    def _check_circuit(self) -> bool:
-        """Returns True if circuit is OPEN (fast fail), False otherwise."""
-        with self._circuit_lock:
-            now = time.time()
-
-            if self._circuit_state == "open":
-                if now < self._circuit_open_until:
-                    return True
-                self._circuit_state = "half_open"
-                self._circuit_probe_in_flight = False
-
-            if self._circuit_state == "half_open":
-                if self._circuit_probe_in_flight:
-                    return True
-                self._circuit_probe_in_flight = True
-                return False
-
-            return False
-
-    def _record_success(self) -> None:
-        with self._circuit_lock:
-            if self._circuit_state != "closed" or self._circuit_failure_count > 0:
-                logger.info("Circuit breaker reset (Closed). LLM service recovered.")
-            self._circuit_failure_count = 0
-            self._circuit_open_until = 0.0
-            self._circuit_state = "closed"
-            self._circuit_probe_in_flight = False
-
-    def _record_failure(self) -> None:
-        with self._circuit_lock:
-            if self._circuit_state == "half_open":
-                self._circuit_open_until = time.time() + self.circuit_recovery_timeout_sec
-                self._circuit_state = "open"
-                self._circuit_probe_in_flight = False
-                logger.error(
-                    "Circuit breaker probe failed (Open). Will probe again after %ds.",
-                    self.circuit_recovery_timeout_sec,
-                )
-                return
-
-            self._circuit_failure_count += 1
-            if self._circuit_failure_count >= self.circuit_failure_threshold:
-                self._circuit_open_until = time.time() + self.circuit_recovery_timeout_sec
-                if self._circuit_state != "open":
-                    self._circuit_state = "open"
-                    self._circuit_probe_in_flight = False
-                    logger.error(
-                        "Circuit breaker tripped (Open). Threshold reached (%d). Will probe after %ds.",
-                        self.circuit_failure_threshold,
-                        self.circuit_recovery_timeout_sec,
-                    )
-
     def _classify_error(self, exc: BaseException) -> tuple[bool, str]:
         detail = _extract_error_detail(exc)
         lowered = detail.lower()
@@ -160,8 +83,6 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
             "APITimeoutError",
             "APIConnectionError",
             "InternalServerError",
-            "ReadError",  # httpx.ReadError: connection dropped mid-stream
-            "RemoteProtocolError",  # httpx: server closed connection unexpectedly
         }:
             return True, "transient"
         if status_code in _RETRIABLE_STATUS_CODES:
@@ -183,9 +104,6 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
         reason_text = "provider is busy" if reason == "busy" else "provider request failed temporarily"
         return f"LLM request retry {attempt}/{self.retry_max_attempts}: {reason_text}. Retrying in {seconds}s."
 
-    def _build_circuit_breaker_message(self) -> str:
-        return "The configured LLM provider is currently unavailable due to continuous failures. Circuit breaker is engaged to protect the system. Please wait a moment before trying again."
-
     def _build_user_message(self, exc: BaseException, reason: str) -> str:
         detail = _extract_error_detail(exc)
         if reason == "quota":
@@ -220,20 +138,12 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
         request: ModelRequest,
         handler: Callable[[ModelRequest], ModelResponse],
     ) -> ModelCallResult:
-        if self._check_circuit():
-            return AIMessage(content=self._build_circuit_breaker_message())
-
         attempt = 1
         while True:
             try:
-                response = handler(request)
-                self._record_success()
-                return response
+                return handler(request)
             except GraphBubbleUp:
                 # Preserve LangGraph control-flow signals (interrupt/pause/resume).
-                with self._circuit_lock:
-                    if self._circuit_state == "half_open":
-                        self._circuit_probe_in_flight = False
                 raise
             except Exception as exc:
                 retriable, reason = self._classify_error(exc)
@@ -256,8 +166,6 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
                     _extract_error_detail(exc),
                     exc_info=exc,
                 )
-                if retriable:
-                    self._record_failure()
                 return AIMessage(content=self._build_user_message(exc, reason))
 
     @override
@@ -266,20 +174,12 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
         request: ModelRequest,
         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
     ) -> ModelCallResult:
-        if self._check_circuit():
-            return AIMessage(content=self._build_circuit_breaker_message())
-
         attempt = 1
         while True:
             try:
-                response = await handler(request)
-                self._record_success()
-                return response
+                return await handler(request)
             except GraphBubbleUp:
                 # Preserve LangGraph control-flow signals (interrupt/pause/resume).
-                with self._circuit_lock:
-                    if self._circuit_state == "half_open":
-                        self._circuit_probe_in_flight = False
                 raise
             except Exception as exc:
                 retriable, reason = self._classify_error(exc)
@@ -302,8 +202,6 @@ class LLMErrorHandlingMiddleware(AgentMiddleware[AgentState]):
                     _extract_error_detail(exc),
                     exc_info=exc,
                 )
-                if retriable:
-                    self._record_failure()
                 return AIMessage(content=self._build_user_message(exc, reason))
 
 

backend/packages/harness/deerflow/agents/middlewares/loop_detection_middleware.py

@@ -17,7 +17,6 @@ import json
 import logging
 import threading
 from collections import OrderedDict, defaultdict
-from copy import deepcopy
 from typing import override
 
 from langchain.agents import AgentState
@@ -25,8 +24,6 @@ from langchain.agents.middleware import AgentMiddleware
 from langchain_core.messages import HumanMessage
 from langgraph.runtime import Runtime
 
-from deerflow.config.deer_flow_context import DeerFlowContext
-
 logger = logging.getLogger(__name__)
 
 # Defaults — can be overridden via constructor
@@ -34,110 +31,40 @@ _DEFAULT_WARN_THRESHOLD = 3  # inject warning after 3 identical calls
 _DEFAULT_HARD_LIMIT = 5  # force-stop after 5 identical calls
 _DEFAULT_WINDOW_SIZE = 20  # track last N tool calls
 _DEFAULT_MAX_TRACKED_THREADS = 100  # LRU eviction limit
-_DEFAULT_TOOL_FREQ_WARN = 30  # warn after 30 calls to the same tool type
-_DEFAULT_TOOL_FREQ_HARD_LIMIT = 50  # force-stop after 50 calls to the same tool type
-
-
-def _normalize_tool_call_args(raw_args: object) -> tuple[dict, str | None]:
-    """Normalize tool call args to a dict plus an optional fallback key.
-
-    Some providers serialize ``args`` as a JSON string instead of a dict.
-    We defensively parse those cases so loop detection does not crash while
-    still preserving a stable fallback key for non-dict payloads.
-    """
-    if isinstance(raw_args, dict):
-        return raw_args, None
-
-    if isinstance(raw_args, str):
-        try:
-            parsed = json.loads(raw_args)
-        except (TypeError, ValueError, json.JSONDecodeError):
-            return {}, raw_args
-
-        if isinstance(parsed, dict):
-            return parsed, None
-        return {}, json.dumps(parsed, sort_keys=True, default=str)
-
-    if raw_args is None:
-        return {}, None
-
-    return {}, json.dumps(raw_args, sort_keys=True, default=str)
-
-
-def _stable_tool_key(name: str, args: dict, fallback_key: str | None) -> str:
-    """Derive a stable key from salient args without overfitting to noise."""
-    if name == "read_file" and fallback_key is None:
-        path = args.get("path") or ""
-        start_line = args.get("start_line")
-        end_line = args.get("end_line")
-
-        bucket_size = 200
-        try:
-            start_line = int(start_line) if start_line is not None else 1
-        except (TypeError, ValueError):
-            start_line = 1
-        try:
-            end_line = int(end_line) if end_line is not None else start_line
-        except (TypeError, ValueError):
-            end_line = start_line
-
-        start_line, end_line = sorted((start_line, end_line))
-        bucket_start = max(start_line, 1)
-        bucket_end = max(end_line, 1)
-        bucket_start = (bucket_start - 1) // bucket_size
-        bucket_end = (bucket_end - 1) // bucket_size
-        return f"{path}:{bucket_start}-{bucket_end}"
-
-    # write_file / str_replace are content-sensitive: same path may be updated
-    # with different payloads during iteration. Using only salient fields (path)
-    # can collapse distinct calls, so we hash full args to reduce false positives.
-    if name in {"write_file", "str_replace"}:
-        if fallback_key is not None:
-            return fallback_key
-        return json.dumps(args, sort_keys=True, default=str)
-
-    salient_fields = ("path", "url", "query", "command", "pattern", "glob", "cmd")
-    stable_args = {field: args[field] for field in salient_fields if args.get(field) is not None}
-    if stable_args:
-        return json.dumps(stable_args, sort_keys=True, default=str)
-
-    if fallback_key is not None:
-        return fallback_key
-
-    return json.dumps(args, sort_keys=True, default=str)
 
 
 def _hash_tool_calls(tool_calls: list[dict]) -> str:
-    """Deterministic hash of a set of tool calls (name + stable key).
+    """Deterministic hash of a set of tool calls (name + args).
 
     This is intended to be order-independent: the same multiset of tool calls
     should always produce the same hash, regardless of their input order.
     """
-    # Normalize each tool call to a stable (name, key) structure.
-    normalized: list[str] = []
+    # First normalize each tool call to a minimal (name, args) structure.
+    normalized: list[dict] = []
     for tc in tool_calls:
-        name = tc.get("name", "")
-        args, fallback_key = _normalize_tool_call_args(tc.get("args", {}))
-        key = _stable_tool_key(name, args, fallback_key)
+        normalized.append(
+            {
+                "name": tc.get("name", ""),
+                "args": tc.get("args", {}),
+            }
+        )
 
-        normalized.append(f"{name}:{key}")
-
-    # Sort so permutations of the same multiset of calls yield the same ordering.
-    normalized.sort()
+    # Sort by both name and a deterministic serialization of args so that
+    # permutations of the same multiset of calls yield the same ordering.
+    normalized.sort(
+        key=lambda tc: (
+            tc["name"],
+            json.dumps(tc["args"], sort_keys=True, default=str),
+        )
+    )
     blob = json.dumps(normalized, sort_keys=True, default=str)
     return hashlib.md5(blob.encode()).hexdigest()[:12]
 
 
 _WARNING_MSG = "[LOOP DETECTED] You are repeating the same tool calls. Stop calling tools and produce your final answer now. If you cannot complete the task, summarize what you accomplished so far."
 
-_TOOL_FREQ_WARNING_MSG = (
-    "[LOOP DETECTED] You have called {tool_name} {count} times without producing a final answer. Stop calling tools and produce your final answer now. If you cannot complete the task, summarize what you accomplished so far."
-)
-
 _HARD_STOP_MSG = "[FORCED STOP] Repeated tool calls exceeded the safety limit. Producing final answer with results collected so far."
 
-_TOOL_FREQ_HARD_STOP_MSG = "[FORCED STOP] Tool {tool_name} called {count} times — exceeded the per-tool safety limit. Producing final answer with results collected so far."
-
 
 class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
     """Detects and breaks repetitive tool call loops.
@@ -151,12 +78,6 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
             Default: 20.
         max_tracked_threads: Maximum number of threads to track before
             evicting the least recently used. Default: 100.
-        tool_freq_warn: Number of calls to the same tool *type* (regardless
-            of arguments) before injecting a frequency warning. Catches
-            cross-file read loops that hash-based detection misses.
-            Default: 30.
-        tool_freq_hard_limit: Number of calls to the same tool type before
-            forcing a stop. Default: 50.
     """
 
     def __init__(
@@ -165,27 +86,23 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
         hard_limit: int = _DEFAULT_HARD_LIMIT,
         window_size: int = _DEFAULT_WINDOW_SIZE,
         max_tracked_threads: int = _DEFAULT_MAX_TRACKED_THREADS,
-        tool_freq_warn: int = _DEFAULT_TOOL_FREQ_WARN,
-        tool_freq_hard_limit: int = _DEFAULT_TOOL_FREQ_HARD_LIMIT,
     ):
         super().__init__()
         self.warn_threshold = warn_threshold
         self.hard_limit = hard_limit
         self.window_size = window_size
         self.max_tracked_threads = max_tracked_threads
-        self.tool_freq_warn = tool_freq_warn
-        self.tool_freq_hard_limit = tool_freq_hard_limit
         self._lock = threading.Lock()
         # Per-thread tracking using OrderedDict for LRU eviction
         self._history: OrderedDict[str, list[str]] = OrderedDict()
         self._warned: dict[str, set[str]] = defaultdict(set)
-        # Per-thread, per-tool-type cumulative call counts
-        self._tool_freq: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
-        self._tool_freq_warned: dict[str, set[str]] = defaultdict(set)
 
-    def _get_thread_id(self, runtime: Runtime[DeerFlowContext]) -> str:
+    def _get_thread_id(self, runtime: Runtime) -> str:
         """Extract thread_id from runtime context for per-thread tracking."""
-        return runtime.context.thread_id or "default"
+        thread_id = runtime.context.get("thread_id") if runtime.context else None
+        if thread_id:
+            return thread_id
+        return "default"
 
     def _evict_if_needed(self) -> None:
         """Evict least recently used threads if over the limit.
@@ -195,19 +112,11 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
         while len(self._history) > self.max_tracked_threads:
             evicted_id, _ = self._history.popitem(last=False)
             self._warned.pop(evicted_id, None)
-            self._tool_freq.pop(evicted_id, None)
-            self._tool_freq_warned.pop(evicted_id, None)
             logger.debug("Evicted loop tracking for thread %s (LRU)", evicted_id)
 
     def _track_and_check(self, state: AgentState, runtime: Runtime) -> tuple[str | None, bool]:
         """Track tool calls and check for loops.
 
-        Two detection layers:
-          1. **Hash-based** (existing): catches identical tool call sets.
-          2. **Frequency-based** (new): catches the same *tool type* being
-             called many times with varying arguments (e.g. ``read_file``
-             on 40 different files).
-
         Returns:
             (warning_message_or_none, should_hard_stop)
         """
@@ -242,7 +151,6 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
             count = history.count(call_hash)
             tool_names = [tc.get("name", "?") for tc in tool_calls]
 
-            # --- Layer 1: hash-based (identical call sets) ---
             if count >= self.hard_limit:
                 logger.error(
                     "Loop hard limit reached — forcing stop",
@@ -269,40 +177,8 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
                         },
                     )
                     return _WARNING_MSG, False
-
-            # --- Layer 2: per-tool-type frequency ---
-            freq = self._tool_freq[thread_id]
-            for tc in tool_calls:
-                name = tc.get("name", "")
-                if not name:
-                    continue
-                freq[name] += 1
-                tc_count = freq[name]
-
-                if tc_count >= self.tool_freq_hard_limit:
-                    logger.error(
-                        "Tool frequency hard limit reached — forcing stop",
-                        extra={
-                            "thread_id": thread_id,
-                            "tool_name": name,
-                            "count": tc_count,
-                        },
-                    )
-                    return _TOOL_FREQ_HARD_STOP_MSG.format(tool_name=name, count=tc_count), True
-
-                if tc_count >= self.tool_freq_warn:
-                    warned = self._tool_freq_warned[thread_id]
-                    if name not in warned:
-                        warned.add(name)
-                        logger.warning(
-                            "Tool frequency warning — too many calls to same tool type",
-                            extra={
-                                "thread_id": thread_id,
-                                "tool_name": name,
-                                "count": tc_count,
-                            },
-                        )
-                        return _TOOL_FREQ_WARNING_MSG.format(tool_name=name, count=tc_count), False
+                # Warning already injected for this hash — suppress
+                return None, False
 
         return None, False
 
@@ -323,26 +199,6 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
         # Fallback: coerce unexpected types to str to avoid TypeError
         return str(content) + f"\n\n{text}"
 
-    @staticmethod
-    def _build_hard_stop_update(last_msg, content: str | list) -> dict:
-        """Clear tool-call metadata so forced-stop messages serialize as plain assistant text."""
-        update = {
-            "tool_calls": [],
-            "content": content,
-        }
-
-        additional_kwargs = dict(getattr(last_msg, "additional_kwargs", {}) or {})
-        for key in ("tool_calls", "function_call"):
-            additional_kwargs.pop(key, None)
-        update["additional_kwargs"] = additional_kwargs
-
-        response_metadata = deepcopy(getattr(last_msg, "response_metadata", {}) or {})
-        if response_metadata.get("finish_reason") == "tool_calls":
-            response_metadata["finish_reason"] = "stop"
-        update["response_metadata"] = response_metadata
-
-        return update
-
     def _apply(self, state: AgentState, runtime: Runtime) -> dict | None:
         warning, hard_stop = self._track_and_check(state, runtime)
 
@@ -350,8 +206,12 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
             # Strip tool_calls from the last AIMessage to force text output
             messages = state.get("messages", [])
             last_msg = messages[-1]
-            content = self._append_text(last_msg.content, warning or _HARD_STOP_MSG)
-            stripped_msg = last_msg.model_copy(update=self._build_hard_stop_update(last_msg, content))
+            stripped_msg = last_msg.model_copy(
+                update={
+                    "tool_calls": [],
+                    "content": self._append_text(last_msg.content, _HARD_STOP_MSG),
+                }
+            )
             return {"messages": [stripped_msg]}
 
         if warning:
@@ -366,11 +226,11 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
         return None
 
     @override
-    def after_model(self, state: AgentState, runtime: Runtime[DeerFlowContext]) -> dict | None:
+    def after_model(self, state: AgentState, runtime: Runtime) -> dict | None:
         return self._apply(state, runtime)
 
     @override
-    async def aafter_model(self, state: AgentState, runtime: Runtime[DeerFlowContext]) -> dict | None:
+    async def aafter_model(self, state: AgentState, runtime: Runtime) -> dict | None:
         return self._apply(state, runtime)
 
     def reset(self, thread_id: str | None = None) -> None:
@@ -379,10 +239,6 @@ class LoopDetectionMiddleware(AgentMiddleware[AgentState]):
             if thread_id:
                 self._history.pop(thread_id, None)
                 self._warned.pop(thread_id, None)
-                self._tool_freq.pop(thread_id, None)
-                self._tool_freq_warned.pop(thread_id, None)
             else:
                 self._history.clear()
                 self._warned.clear()
-                self._tool_freq.clear()
-                self._tool_freq_warned.clear()

backend/packages/harness/deerflow/agents/middlewares/memory_middleware.py

@@ -1,19 +1,50 @@
 """Middleware for memory mechanism."""
 
 import logging
-from typing import override
+import re
+from typing import Any, override
 
 from langchain.agents import AgentState
 from langchain.agents.middleware import AgentMiddleware
+from langgraph.config import get_config
 from langgraph.runtime import Runtime
 
-from deerflow.agents.memory.message_processing import detect_correction, detect_reinforcement, filter_messages_for_memory
 from deerflow.agents.memory.queue import get_memory_queue
-from deerflow.config.deer_flow_context import DeerFlowContext
-from deerflow.runtime.user_context import get_effective_user_id
+from deerflow.config.memory_config import get_memory_config
 
 logger = logging.getLogger(__name__)
 
+_UPLOAD_BLOCK_RE = re.compile(r"<uploaded_files>[\s\S]*?</uploaded_files>\n*", re.IGNORECASE)
+_CORRECTION_PATTERNS = (
+    re.compile(r"\bthat(?:'s| is) (?:wrong|incorrect)\b", re.IGNORECASE),
+    re.compile(r"\byou misunderstood\b", re.IGNORECASE),
+    re.compile(r"\btry again\b", re.IGNORECASE),
+    re.compile(r"\bredo\b", re.IGNORECASE),
+    re.compile(r"不对"),
+    re.compile(r"你理解错了"),
+    re.compile(r"你理解有误"),
+    re.compile(r"重试"),
+    re.compile(r"重新来"),
+    re.compile(r"换一种"),
+    re.compile(r"改用"),
+)
+
+_REINFORCEMENT_PATTERNS = (
+    re.compile(r"\byes[,.]?\s+(?:exactly|perfect|that(?:'s| is) (?:right|correct|it))\b", re.IGNORECASE),
+    re.compile(r"\bperfect(?:[.!?]|$)", re.IGNORECASE),
+    re.compile(r"\bexactly\s+(?:right|correct)\b", re.IGNORECASE),
+    re.compile(r"\bthat(?:'s| is)\s+(?:exactly\s+)?(?:right|correct|what i (?:wanted|needed|meant))\b", re.IGNORECASE),
+    re.compile(r"\bkeep\s+(?:doing\s+)?that\b", re.IGNORECASE),
+    re.compile(r"\bjust\s+(?:like\s+)?(?:that|this)\b", re.IGNORECASE),
+    re.compile(r"\bthis is (?:great|helpful)\b(?:[.!?]|$)", re.IGNORECASE),
+    re.compile(r"\bthis is what i wanted\b(?:[.!?]|$)", re.IGNORECASE),
+    re.compile(r"对[，,]?\s*就是这样(?:[。！？!?.]|$)"),
+    re.compile(r"完全正确(?:[。！？!?.]|$)"),
+    re.compile(r"(?:对[，,]?\s*)?就是这个意思(?:[。！？!?.]|$)"),
+    re.compile(r"正是我想要的(?:[。！？!?.]|$)"),
+    re.compile(r"继续保持(?:[。！？!?.]|$)"),
+)
+
 
 class MemoryMiddlewareState(AgentState):
     """Compatible with the `ThreadState` schema."""
@@ -21,6 +52,125 @@ class MemoryMiddlewareState(AgentState):
     pass
 
 
+def _extract_message_text(message: Any) -> str:
+    """Extract plain text from message content for filtering and signal detection."""
+    content = getattr(message, "content", "")
+    if isinstance(content, list):
+        text_parts: list[str] = []
+        for part in content:
+            if isinstance(part, str):
+                text_parts.append(part)
+            elif isinstance(part, dict):
+                text_val = part.get("text")
+                if isinstance(text_val, str):
+                    text_parts.append(text_val)
+        return " ".join(text_parts)
+    return str(content)
+
+
+def _filter_messages_for_memory(messages: list[Any]) -> list[Any]:
+    """Filter messages to keep only user inputs and final assistant responses.
+
+    This filters out:
+    - Tool messages (intermediate tool call results)
+    - AI messages with tool_calls (intermediate steps, not final responses)
+    - The <uploaded_files> block injected by UploadsMiddleware into human messages
+      (file paths are session-scoped and must not persist in long-term memory).
+      The user's actual question is preserved; only turns whose content is entirely
+      the upload block (nothing remains after stripping) are dropped along with
+      their paired assistant response.
+
+    Only keeps:
+    - Human messages (with the ephemeral upload block removed)
+    - AI messages without tool_calls (final assistant responses), unless the
+      paired human turn was upload-only and had no real user text.
+
+    Args:
+        messages: List of all conversation messages.
+
+    Returns:
+        Filtered list containing only user inputs and final assistant responses.
+    """
+    filtered = []
+    skip_next_ai = False
+    for msg in messages:
+        msg_type = getattr(msg, "type", None)
+
+        if msg_type == "human":
+            content_str = _extract_message_text(msg)
+            if "<uploaded_files>" in content_str:
+                # Strip the ephemeral upload block; keep the user's real question.
+                stripped = _UPLOAD_BLOCK_RE.sub("", content_str).strip()
+                if not stripped:
+                    # Nothing left — the entire turn was upload bookkeeping;
+                    # skip it and the paired assistant response.
+                    skip_next_ai = True
+                    continue
+                # Rebuild the message with cleaned content so the user's question
+                # is still available for memory summarisation.
+                from copy import copy
+
+                clean_msg = copy(msg)
+                clean_msg.content = stripped
+                filtered.append(clean_msg)
+                skip_next_ai = False
+            else:
+                filtered.append(msg)
+                skip_next_ai = False
+        elif msg_type == "ai":
+            tool_calls = getattr(msg, "tool_calls", None)
+            if not tool_calls:
+                if skip_next_ai:
+                    skip_next_ai = False
+                    continue
+                filtered.append(msg)
+        # Skip tool messages and AI messages with tool_calls
+
+    return filtered
+
+
+def detect_correction(messages: list[Any]) -> bool:
+    """Detect explicit user corrections in recent conversation turns.
+
+    The queue keeps only one pending context per thread, so callers pass the
+    latest filtered message list. Checking only recent user turns keeps signal
+    detection conservative while avoiding stale corrections from long histories.
+    """
+    recent_user_msgs = [msg for msg in messages[-6:] if getattr(msg, "type", None) == "human"]
+
+    for msg in recent_user_msgs:
+        content = _extract_message_text(msg).strip()
+        if not content:
+            continue
+        if any(pattern.search(content) for pattern in _CORRECTION_PATTERNS):
+            return True
+
+    return False
+
+
+def detect_reinforcement(messages: list[Any]) -> bool:
+    """Detect explicit positive reinforcement signals in recent conversation turns.
+
+    Complements detect_correction() by identifying when the user confirms the
+    agent's approach was correct. This allows the memory system to record what
+    worked well, not just what went wrong.
+
+    The queue keeps only one pending context per thread, so callers pass the
+    latest filtered message list. Checking only recent user turns keeps signal
+    detection conservative while avoiding stale signals from long histories.
+    """
+    recent_user_msgs = [msg for msg in messages[-6:] if getattr(msg, "type", None) == "human"]
+
+    for msg in recent_user_msgs:
+        content = _extract_message_text(msg).strip()
+        if not content:
+            continue
+        if any(pattern.search(content) for pattern in _REINFORCEMENT_PATTERNS):
+            return True
+
+    return False
+
+
 class MemoryMiddleware(AgentMiddleware[MemoryMiddlewareState]):
     """Middleware that queues conversation for memory update after agent execution.
 
@@ -43,7 +193,7 @@ class MemoryMiddleware(AgentMiddleware[MemoryMiddlewareState]):
         self._agent_name = agent_name
 
     @override
-    def after_agent(self, state: MemoryMiddlewareState, runtime: Runtime[DeerFlowContext]) -> dict | None:
+    def after_agent(self, state: MemoryMiddlewareState, runtime: Runtime) -> dict | None:
         """Queue conversation for memory update after agent completes.
 
         Args:
@@ -53,11 +203,15 @@ class MemoryMiddleware(AgentMiddleware[MemoryMiddlewareState]):
         Returns:
             None (no state changes needed from this middleware).
         """
-        memory_config = runtime.context.app_config.memory
-        if not memory_config.enabled:
+        config = get_memory_config()
+        if not config.enabled:
             return None
 
-        thread_id = runtime.context.thread_id
+        # Get thread ID from runtime context first, then fall back to LangGraph's configurable metadata
+        thread_id = runtime.context.get("thread_id") if runtime.context else None
+        if thread_id is None:
+            config_data = get_config()
+            thread_id = config_data.get("configurable", {}).get("thread_id")
         if not thread_id:
             logger.debug("No thread_id in context, skipping memory update")
             return None
@@ -69,7 +223,7 @@ class MemoryMiddleware(AgentMiddleware[MemoryMiddlewareState]):
             return None
 
         # Filter to only keep user inputs and final assistant responses
-        filtered_messages = filter_messages_for_memory(messages)
+        filtered_messages = _filter_messages_for_memory(messages)
 
         # Only queue if there's meaningful conversation
         # At minimum need one user message and one assistant response
@@ -82,16 +236,11 @@ class MemoryMiddleware(AgentMiddleware[MemoryMiddlewareState]):
         # Queue the filtered conversation for memory update
         correction_detected = detect_correction(filtered_messages)
         reinforcement_detected = not correction_detected and detect_reinforcement(filtered_messages)
-        # Capture user_id at enqueue time while the request context is still alive.
-        # threading.Timer fires on a different thread where ContextVar values are not
-        # propagated, so we must store user_id explicitly in ConversationContext.
-        user_id = get_effective_user_id()
-        queue = get_memory_queue(runtime.context.app_config)
+        queue = get_memory_queue()
         queue.add(
             thread_id=thread_id,
             messages=filtered_messages,
             agent_name=self._agent_name,
-            user_id=user_id,
             correction_detected=correction_detected,
             reinforcement_detected=reinforcement_detected,
         )

backend/packages/harness/deerflow/agents/middlewares/sandbox_audit_middleware.py

@@ -23,119 +23,25 @@ logger = logging.getLogger(__name__)
 
 # Each pattern is compiled once at import time.
 _HIGH_RISK_PATTERNS: list[re.Pattern[str]] = [
-    # --- original rules (retained) ---
-    re.compile(r"rm\s+-[^\s]*r[^\s]*\s+(/\*?|~/?\*?|/home\b|/root\b)\s*$"),
+    re.compile(r"rm\s+-[^\s]*r[^\s]*\s+(/\*?|~/?\*?|/home\b|/root\b)\s*$"),  # rm -rf / /* ~ /home /root
+    re.compile(r"(curl|wget).+\|\s*(ba)?sh"),  # curl|sh, wget|sh
     re.compile(r"dd\s+if="),
     re.compile(r"mkfs"),
     re.compile(r"cat\s+/etc/shadow"),
-    re.compile(r">+\s*/etc/"),
-    # --- pipe to sh/bash (generalised, replaces old curl|sh rule) ---
-    re.compile(r"\|\s*(ba)?sh\b"),
-    # --- command substitution (targeted – only dangerous executables) ---
-    re.compile(r"[`$]\(?\s*(curl|wget|bash|sh|python|ruby|perl|base64)"),
-    # --- base64 decode piped to execution ---
-    re.compile(r"base64\s+.*-d.*\|"),
-    # --- overwrite system binaries ---
-    re.compile(r">+\s*(/usr/bin/|/bin/|/sbin/)"),
-    # --- overwrite shell startup files ---
-    re.compile(r">+\s*~/?\.(bashrc|profile|zshrc|bash_profile)"),
-    # --- process environment leakage ---
-    re.compile(r"/proc/[^/]+/environ"),
-    # --- dynamic linker hijack (one-step escalation) ---
-    re.compile(r"\b(LD_PRELOAD|LD_LIBRARY_PATH)\s*="),
-    # --- bash built-in networking (bypasses tool allowlists) ---
-    re.compile(r"/dev/tcp/"),
-    # --- fork bomb ---
-    re.compile(r"\S+\(\)\s*\{[^}]*\|\s*\S+\s*&"),  # :(){ :|:& };:
-    re.compile(r"while\s+true.*&\s*done"),  # while true; do bash & done
+    re.compile(r">\s*/etc/"),  # overwrite /etc/ files
 ]
 
 _MEDIUM_RISK_PATTERNS: list[re.Pattern[str]] = [
-    re.compile(r"chmod\s+777"),
-    re.compile(r"pip3?\s+install"),
+    re.compile(r"chmod\s+777"),  # overly permissive, but reversible
+    re.compile(r"pip\s+install"),
+    re.compile(r"pip3\s+install"),
     re.compile(r"apt(-get)?\s+install"),
-    # sudo/su: no-op under Docker root; warn so LLM is aware
-    re.compile(r"\b(sudo|su)\b"),
-    # PATH modification: long attack chain, warn rather than block
-    re.compile(r"\bPATH\s*="),
 ]
 
 
-def _split_compound_command(command: str) -> list[str]:
-    """Split a compound command into sub-commands (quote-aware).
-
-    Scans the raw command string so unquoted shell control operators are
-    recognised even when they are not surrounded by whitespace
-    (e.g. ``safe;rm -rf /`` or ``rm -rf /&&echo ok``). Operators inside
-    quotes are ignored. If the command ends with an unclosed quote or a
-    dangling escape, return the whole command unchanged (fail-closed —
-    safer to classify the unsplit string than silently drop parts).
-    """
-    parts: list[str] = []
-    current: list[str] = []
-    in_single_quote = False
-    in_double_quote = False
-    escaping = False
-    index = 0
-
-    while index < len(command):
-        char = command[index]
-
-        if escaping:
-            current.append(char)
-            escaping = False
-            index += 1
-            continue
-
-        if char == "\\" and not in_single_quote:
-            current.append(char)
-            escaping = True
-            index += 1
-            continue
-
-        if char == "'" and not in_double_quote:
-            in_single_quote = not in_single_quote
-            current.append(char)
-            index += 1
-            continue
-
-        if char == '"' and not in_single_quote:
-            in_double_quote = not in_double_quote
-            current.append(char)
-            index += 1
-            continue
-
-        if not in_single_quote and not in_double_quote:
-            if command.startswith("&&", index) or command.startswith("||", index):
-                part = "".join(current).strip()
-                if part:
-                    parts.append(part)
-                current = []
-                index += 2
-                continue
-            if char == ";":
-                part = "".join(current).strip()
-                if part:
-                    parts.append(part)
-                current = []
-                index += 1
-                continue
-
-        current.append(char)
-        index += 1
-
-    # Unclosed quote or dangling escape → fail-closed, return whole command
-    if in_single_quote or in_double_quote or escaping:
-        return [command]
-
-    part = "".join(current).strip()
-    if part:
-        parts.append(part)
-    return parts if parts else [command]
-
-
-def _classify_single_command(command: str) -> str:
-    """Classify a single (non-compound) command. Return 'block', 'warn', or 'pass'."""
+def _classify_command(command: str) -> str:
+    """Return 'block', 'warn', or 'pass'."""
+    # Normalize for matching (collapse whitespace)
     normalized = " ".join(command.split())
 
     for pattern in _HIGH_RISK_PATTERNS:
@@ -160,35 +66,6 @@ def _classify_single_command(command: str) -> str:
     return "pass"
 
 
-def _classify_command(command: str) -> str:
-    """Return 'block', 'warn', or 'pass'.
-
-    Strategy:
-    1. First scan the *whole* raw command against high-risk patterns. This
-       catches structural attacks like ``while true; do bash & done`` or
-       ``:(){ :|:& };:`` that span multiple shell statements — splitting them
-       on ``;`` would destroy the pattern context.
-    2. Then split compound commands (e.g. ``cmd1 && cmd2 ; cmd3``) and
-       classify each sub-command independently. The most severe verdict wins.
-    """
-    # Pass 1: whole-command high-risk scan (catches multi-statement patterns)
-    normalized = " ".join(command.split())
-    for pattern in _HIGH_RISK_PATTERNS:
-        if pattern.search(normalized):
-            return "block"
-
-    # Pass 2: per-sub-command classification
-    sub_commands = _split_compound_command(command)
-    worst = "pass"
-    for sub in sub_commands:
-        verdict = _classify_single_command(sub)
-        if verdict == "block":
-            return "block"  # short-circuit: can't get worse
-        if verdict == "warn":
-            worst = "warn"
-    return worst
-
-
 # ---------------------------------------------------------------------------
 # Middleware
 # ---------------------------------------------------------------------------

backend/packages/harness/deerflow/agents/middlewares/summarization_middleware.py

@@ -1,347 +0,0 @@
-"""Summarization middleware extensions for DeerFlow."""
-
-from __future__ import annotations
-
-import logging
-from collections.abc import Collection
-from dataclasses import dataclass
-from typing import Any, Protocol, runtime_checkable
-
-from langchain.agents import AgentState
-from langchain.agents.middleware import SummarizationMiddleware
-from langchain_core.messages import AIMessage, AnyMessage, RemoveMessage, ToolMessage
-from langgraph.config import get_config
-from langgraph.graph.message import REMOVE_ALL_MESSAGES
-from langgraph.runtime import Runtime
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class SummarizationEvent:
-    """Context emitted before conversation history is summarized away."""
-
-    messages_to_summarize: tuple[AnyMessage, ...]
-    preserved_messages: tuple[AnyMessage, ...]
-    thread_id: str | None
-    agent_name: str | None
-    runtime: Runtime
-
-
-@runtime_checkable
-class BeforeSummarizationHook(Protocol):
-    """Hook invoked before summarization removes messages from state."""
-
-    def __call__(self, event: SummarizationEvent) -> None: ...
-
-
-def _resolve_thread_id(runtime: Runtime) -> str | None:
-    """Resolve the current thread ID from runtime context or LangGraph config."""
-    thread_id = runtime.context.get("thread_id") if runtime.context else None
-    if thread_id is None:
-        try:
-            config_data = get_config()
-        except RuntimeError:
-            return None
-        thread_id = config_data.get("configurable", {}).get("thread_id")
-    return thread_id
-
-
-def _resolve_agent_name(runtime: Runtime) -> str | None:
-    """Resolve the current agent name from runtime context or LangGraph config."""
-    agent_name = runtime.context.get("agent_name") if runtime.context else None
-    if agent_name is None:
-        try:
-            config_data = get_config()
-        except RuntimeError:
-            return None
-        agent_name = config_data.get("configurable", {}).get("agent_name")
-    return agent_name
-
-
-def _tool_call_path(tool_call: dict[str, Any]) -> str | None:
-    """Best-effort extraction of a file path argument from a read_file-like tool call."""
-    args = tool_call.get("args") or {}
-    if not isinstance(args, dict):
-        return None
-    for key in ("path", "file_path", "filepath"):
-        value = args.get(key)
-        if isinstance(value, str) and value:
-            return value
-    return None
-
-
-def _clone_ai_message(
-    message: AIMessage,
-    tool_calls: list[dict[str, Any]],
-    *,
-    content: Any | None = None,
-) -> AIMessage:
-    """Clone an AIMessage while replacing its tool_calls list and optional content."""
-    update: dict[str, Any] = {"tool_calls": tool_calls}
-    if content is not None:
-        update["content"] = content
-    return message.model_copy(update=update)
-
-
-@dataclass
-class _SkillBundle:
-    """Skill-related tool calls and tool results associated with one AIMessage."""
-
-    ai_index: int
-    skill_tool_indices: tuple[int, ...]
-    skill_tool_call_ids: frozenset[str]
-    skill_tool_tokens: int
-    skill_key: str
-
-
-class DeerFlowSummarizationMiddleware(SummarizationMiddleware):
-    """Summarization middleware with pre-compression hook dispatch and skill rescue."""
-
-    def __init__(
-        self,
-        *args,
-        skills_container_path: str | None = None,
-        skill_file_read_tool_names: Collection[str] | None = None,
-        before_summarization: list[BeforeSummarizationHook] | None = None,
-        preserve_recent_skill_count: int = 5,
-        preserve_recent_skill_tokens: int = 25_000,
-        preserve_recent_skill_tokens_per_skill: int = 5_000,
-        **kwargs,
-    ) -> None:
-        super().__init__(*args, **kwargs)
-        self._skills_container_path = skills_container_path or "/mnt/skills"
-        self._skill_file_read_tool_names = frozenset(skill_file_read_tool_names or {"read_file", "read", "view", "cat"})
-        self._before_summarization_hooks = before_summarization or []
-        self._preserve_recent_skill_count = max(0, preserve_recent_skill_count)
-        self._preserve_recent_skill_tokens = max(0, preserve_recent_skill_tokens)
-        self._preserve_recent_skill_tokens_per_skill = max(0, preserve_recent_skill_tokens_per_skill)
-
-    def before_model(self, state: AgentState, runtime: Runtime) -> dict | None:
-        return self._maybe_summarize(state, runtime)
-
-    async def abefore_model(self, state: AgentState, runtime: Runtime) -> dict | None:
-        return await self._amaybe_summarize(state, runtime)
-
-    def _maybe_summarize(self, state: AgentState, runtime: Runtime) -> dict | None:
-        messages = state["messages"]
-        self._ensure_message_ids(messages)
-
-        total_tokens = self.token_counter(messages)
-        if not self._should_summarize(messages, total_tokens):
-            return None
-
-        cutoff_index = self._determine_cutoff_index(messages)
-        if cutoff_index <= 0:
-            return None
-
-        messages_to_summarize, preserved_messages = self._partition_with_skill_rescue(messages, cutoff_index)
-        self._fire_hooks(messages_to_summarize, preserved_messages, runtime)
-        summary = self._create_summary(messages_to_summarize)
-        new_messages = self._build_new_messages(summary)
-
-        return {
-            "messages": [
-                RemoveMessage(id=REMOVE_ALL_MESSAGES),
-                *new_messages,
-                *preserved_messages,
-            ]
-        }
-
-    async def _amaybe_summarize(self, state: AgentState, runtime: Runtime) -> dict | None:
-        messages = state["messages"]
-        self._ensure_message_ids(messages)
-
-        total_tokens = self.token_counter(messages)
-        if not self._should_summarize(messages, total_tokens):
-            return None
-
-        cutoff_index = self._determine_cutoff_index(messages)
-        if cutoff_index <= 0:
-            return None
-
-        messages_to_summarize, preserved_messages = self._partition_with_skill_rescue(messages, cutoff_index)
-        self._fire_hooks(messages_to_summarize, preserved_messages, runtime)
-        summary = await self._acreate_summary(messages_to_summarize)
-        new_messages = self._build_new_messages(summary)
-
-        return {
-            "messages": [
-                RemoveMessage(id=REMOVE_ALL_MESSAGES),
-                *new_messages,
-                *preserved_messages,
-            ]
-        }
-
-    def _partition_with_skill_rescue(
-        self,
-        messages: list[AnyMessage],
-        cutoff_index: int,
-    ) -> tuple[list[AnyMessage], list[AnyMessage]]:
-        """Partition like the parent, then rescue recently-loaded skill bundles."""
-        to_summarize, preserved = self._partition_messages(messages, cutoff_index)
-
-        if self._preserve_recent_skill_count == 0 or self._preserve_recent_skill_tokens == 0 or not to_summarize:
-            return to_summarize, preserved
-
-        try:
-            bundles = self._find_skill_bundles(to_summarize, self._skills_container_path)
-        except Exception:
-            logger.exception("Skill-preserving summarization rescue failed; falling back to default partition")
-            return to_summarize, preserved
-
-        if not bundles:
-            return to_summarize, preserved
-
-        rescue_bundles = self._select_bundles_to_rescue(bundles)
-        if not rescue_bundles:
-            return to_summarize, preserved
-
-        bundles_by_ai_index = {bundle.ai_index: bundle for bundle in rescue_bundles}
-        rescue_tool_indices = {idx for bundle in rescue_bundles for idx in bundle.skill_tool_indices}
-        rescued: list[AnyMessage] = []
-        remaining: list[AnyMessage] = []
-        for i, msg in enumerate(to_summarize):
-            bundle = bundles_by_ai_index.get(i)
-            if bundle is not None and isinstance(msg, AIMessage):
-                rescued_tool_calls = [tc for tc in msg.tool_calls if tc.get("id") in bundle.skill_tool_call_ids]
-                remaining_tool_calls = [tc for tc in msg.tool_calls if tc.get("id") not in bundle.skill_tool_call_ids]
-
-                if rescued_tool_calls:
-                    rescued.append(_clone_ai_message(msg, rescued_tool_calls, content=""))
-                if remaining_tool_calls or msg.content:
-                    remaining.append(_clone_ai_message(msg, remaining_tool_calls))
-                continue
-
-            if i in rescue_tool_indices:
-                rescued.append(msg)
-                continue
-
-            remaining.append(msg)
-
-        return remaining, rescued + preserved
-
-    def _find_skill_bundles(
-        self,
-        messages: list[AnyMessage],
-        skills_root: str,
-    ) -> list[_SkillBundle]:
-        """Locate AIMessage + paired ToolMessage groups that load skill files."""
-        bundles: list[_SkillBundle] = []
-        n = len(messages)
-        i = 0
-        while i < n:
-            msg = messages[i]
-            if not (isinstance(msg, AIMessage) and msg.tool_calls):
-                i += 1
-                continue
-
-            tool_calls = list(msg.tool_calls)
-            skill_paths_by_id: dict[str, str] = {}
-            for tc in tool_calls:
-                if self._is_skill_tool_call(tc, skills_root):
-                    tc_id = tc.get("id")
-                    path = _tool_call_path(tc)
-                    if tc_id and path:
-                        skill_paths_by_id[tc_id] = path
-
-            if not skill_paths_by_id:
-                i += 1
-                continue
-
-            skill_tool_tokens = 0
-            skill_key_parts: list[str] = []
-            skill_tool_indices: list[int] = []
-            matched_skill_call_ids: set[str] = set()
-
-            j = i + 1
-            while j < n and isinstance(messages[j], ToolMessage):
-                j += 1
-
-            for k in range(i + 1, j):
-                tool_msg = messages[k]
-                if isinstance(tool_msg, ToolMessage) and tool_msg.tool_call_id in skill_paths_by_id:
-                    skill_tool_tokens += self.token_counter([tool_msg])
-                    skill_key_parts.append(skill_paths_by_id[tool_msg.tool_call_id])
-                    skill_tool_indices.append(k)
-                    matched_skill_call_ids.add(tool_msg.tool_call_id)
-
-            if not skill_tool_indices:
-                i = j
-                continue
-
-            bundles.append(
-                _SkillBundle(
-                    ai_index=i,
-                    skill_tool_indices=tuple(skill_tool_indices),
-                    skill_tool_call_ids=frozenset(matched_skill_call_ids),
-                    skill_tool_tokens=skill_tool_tokens,
-                    skill_key="|".join(sorted(skill_key_parts)),
-                )
-            )
-            i = j
-
-        return bundles
-
-    def _select_bundles_to_rescue(self, bundles: list[_SkillBundle]) -> list[_SkillBundle]:
-        """Pick bundles to keep, walking newest-first under count/token budgets."""
-        selected: list[_SkillBundle] = []
-        if not bundles:
-            return selected
-
-        seen_skill_keys: set[str] = set()
-        total_tokens = 0
-        kept = 0
-
-        for bundle in reversed(bundles):
-            if kept >= self._preserve_recent_skill_count:
-                break
-            if bundle.skill_key in seen_skill_keys:
-                continue
-            if bundle.skill_tool_tokens > self._preserve_recent_skill_tokens_per_skill:
-                continue
-            if total_tokens + bundle.skill_tool_tokens > self._preserve_recent_skill_tokens:
-                continue
-
-            selected.append(bundle)
-            total_tokens += bundle.skill_tool_tokens
-            kept += 1
-            seen_skill_keys.add(bundle.skill_key)
-
-        selected.reverse()
-        return selected
-
-    def _is_skill_tool_call(self, tool_call: dict[str, Any], skills_root: str) -> bool:
-        """Return True when ``tool_call`` reads a file under the configured skills root."""
-        name = tool_call.get("name") or ""
-        if name not in self._skill_file_read_tool_names:
-            return False
-        path = _tool_call_path(tool_call)
-        if not path:
-            return False
-        normalized_root = skills_root.rstrip("/")
-        return path == normalized_root or path.startswith(normalized_root + "/")
-
-    def _fire_hooks(
-        self,
-        messages_to_summarize: list[AnyMessage],
-        preserved_messages: list[AnyMessage],
-        runtime: Runtime,
-    ) -> None:
-        if not self._before_summarization_hooks:
-            return
-
-        event = SummarizationEvent(
-            messages_to_summarize=tuple(messages_to_summarize),
-            preserved_messages=tuple(preserved_messages),
-            thread_id=_resolve_thread_id(runtime),
-            agent_name=_resolve_agent_name(runtime),
-            runtime=runtime,
-        )
-
-        for hook in self._before_summarization_hooks:
-            try:
-                hook(event)
-            except Exception:
-                hook_name = getattr(hook, "__name__", None) or type(hook).__name__
-                logger.exception("before_summarization hook %s failed", hook_name)

backend/packages/harness/deerflow/agents/middlewares/thread_data_middleware.py

@@ -3,12 +3,11 @@ from typing import NotRequired, override
 
 from langchain.agents import AgentState
 from langchain.agents.middleware import AgentMiddleware
+from langgraph.config import get_config
 from langgraph.runtime import Runtime
 
 from deerflow.agents.thread_state import ThreadDataState
-from deerflow.config.deer_flow_context import DeerFlowContext
 from deerflow.config.paths import Paths, get_paths
-from deerflow.runtime.user_context import get_effective_user_id
 
 logger = logging.getLogger(__name__)
 
@@ -47,50 +46,50 @@ class ThreadDataMiddleware(AgentMiddleware[ThreadDataMiddlewareState]):
         self._paths = Paths(base_dir) if base_dir else get_paths()
         self._lazy_init = lazy_init
 
-    def _get_thread_paths(self, thread_id: str, user_id: str | None = None) -> dict[str, str]:
+    def _get_thread_paths(self, thread_id: str) -> dict[str, str]:
         """Get the paths for a thread's data directories.
 
         Args:
             thread_id: The thread ID.
-            user_id: Optional user ID for per-user path isolation.
 
         Returns:
             Dictionary with workspace_path, uploads_path, and outputs_path.
         """
         return {
-            "workspace_path": str(self._paths.sandbox_work_dir(thread_id, user_id=user_id)),
-            "uploads_path": str(self._paths.sandbox_uploads_dir(thread_id, user_id=user_id)),
-            "outputs_path": str(self._paths.sandbox_outputs_dir(thread_id, user_id=user_id)),
+            "workspace_path": str(self._paths.sandbox_work_dir(thread_id)),
+            "uploads_path": str(self._paths.sandbox_uploads_dir(thread_id)),
+            "outputs_path": str(self._paths.sandbox_outputs_dir(thread_id)),
         }
 
-    def _create_thread_directories(self, thread_id: str, user_id: str | None = None) -> dict[str, str]:
+    def _create_thread_directories(self, thread_id: str) -> dict[str, str]:
         """Create the thread data directories.
 
         Args:
             thread_id: The thread ID.
-            user_id: Optional user ID for per-user path isolation.
 
         Returns:
             Dictionary with the created directory paths.
         """
-        self._paths.ensure_thread_dirs(thread_id, user_id=user_id)
-        return self._get_thread_paths(thread_id, user_id=user_id)
+        self._paths.ensure_thread_dirs(thread_id)
+        return self._get_thread_paths(thread_id)
 
     @override
-    def before_agent(self, state: ThreadDataMiddlewareState, runtime: Runtime[DeerFlowContext]) -> dict | None:
-        thread_id = runtime.context.thread_id
+    def before_agent(self, state: ThreadDataMiddlewareState, runtime: Runtime) -> dict | None:
+        context = runtime.context or {}
+        thread_id = context.get("thread_id")
+        if thread_id is None:
+            config = get_config()
+            thread_id = config.get("configurable", {}).get("thread_id")
 
-        if not thread_id:
+        if thread_id is None:
             raise ValueError("Thread ID is required in runtime context or config.configurable")
 
-        user_id = get_effective_user_id()
-
         if self._lazy_init:
             # Lazy initialization: only compute paths, don't create directories
-            paths = self._get_thread_paths(thread_id, user_id=user_id)
+            paths = self._get_thread_paths(thread_id)
         else:
             # Eager initialization: create directories immediately
-            paths = self._create_thread_directories(thread_id, user_id=user_id)
+            paths = self._create_thread_directories(thread_id)
             logger.debug("Created thread data directories for thread %s", thread_id)
 
         return {

backend/packages/harness/deerflow/agents/middlewares/title_middleware.py

@@ -1,7 +1,6 @@
 """Middleware for automatic thread title generation."""
 
 import logging
-import re
 from typing import Any, NotRequired, override
 
 from langchain.agents import AgentState
@@ -9,9 +8,7 @@ from langchain.agents.middleware import AgentMiddleware
 from langgraph.config import get_config
 from langgraph.runtime import Runtime
 
-from deerflow.config.app_config import AppConfig
-from deerflow.config.deer_flow_context import DeerFlowContext
-from deerflow.config.title_config import TitleConfig
+from deerflow.config.title_config import get_title_config
 from deerflow.models import create_chat_model
 
 logger = logging.getLogger(__name__)
@@ -47,9 +44,10 @@ class TitleMiddleware(AgentMiddleware[TitleMiddlewareState]):
 
         return ""
 
-    def _should_generate_title(self, state: TitleMiddlewareState, title_config: TitleConfig) -> bool:
+    def _should_generate_title(self, state: TitleMiddlewareState) -> bool:
         """Check if we should generate a title for this thread."""
-        if not title_config.enabled:
+        config = get_title_config()
+        if not config.enabled:
             return False
 
         # Check if thread already has a title in state
@@ -68,39 +66,37 @@ class TitleMiddleware(AgentMiddleware[TitleMiddlewareState]):
         # Generate title after first complete exchange
         return len(user_messages) == 1 and len(assistant_messages) >= 1
 
-    def _build_title_prompt(self, state: TitleMiddlewareState, title_config: TitleConfig) -> tuple[str, str]:
+    def _build_title_prompt(self, state: TitleMiddlewareState) -> tuple[str, str]:
         """Extract user/assistant messages and build the title prompt.
 
         Returns (prompt_string, user_msg) so callers can use user_msg as fallback.
         """
+        config = get_title_config()
         messages = state.get("messages", [])
 
         user_msg_content = next((m.content for m in messages if m.type == "human"), "")
         assistant_msg_content = next((m.content for m in messages if m.type == "ai"), "")
 
         user_msg = self._normalize_content(user_msg_content)
-        assistant_msg = self._strip_think_tags(self._normalize_content(assistant_msg_content))
+        assistant_msg = self._normalize_content(assistant_msg_content)
 
-        prompt = title_config.prompt_template.format(
-            max_words=title_config.max_words,
+        prompt = config.prompt_template.format(
+            max_words=config.max_words,
             user_msg=user_msg[:500],
             assistant_msg=assistant_msg[:500],
         )
         return prompt, user_msg
 
-    def _strip_think_tags(self, text: str) -> str:
-        """Remove <think>...</think> blocks emitted by reasoning models (e.g. minimax, DeepSeek-R1)."""
-        return re.sub(r"<think>[\s\S]*?</think>", "", text, flags=re.IGNORECASE).strip()
-
-    def _parse_title(self, content: object, title_config: TitleConfig) -> str:
+    def _parse_title(self, content: object) -> str:
         """Normalize model output into a clean title string."""
+        config = get_title_config()
         title_content = self._normalize_content(content)
-        title_content = self._strip_think_tags(title_content)
         title = title_content.strip().strip('"').strip("'")
-        return title[: title_config.max_chars] if len(title) > title_config.max_chars else title
+        return title[: config.max_chars] if len(title) > config.max_chars else title
 
-    def _fallback_title(self, user_msg: str, title_config: TitleConfig) -> str:
-        fallback_chars = min(title_config.max_chars, 50)
+    def _fallback_title(self, user_msg: str) -> str:
+        config = get_title_config()
+        fallback_chars = min(config.max_chars, 50)
         if len(user_msg) > fallback_chars:
             return user_msg[:fallback_chars].rstrip() + "..."
         return user_msg if user_msg else "New Conversation"
@@ -119,39 +115,39 @@ class TitleMiddleware(AgentMiddleware[TitleMiddlewareState]):
         config["tags"] = [*(config.get("tags") or []), "middleware:title"]
         return config
 
-    def _generate_title_result(self, state: TitleMiddlewareState, title_config: TitleConfig) -> dict | None:
+    def _generate_title_result(self, state: TitleMiddlewareState) -> dict | None:
         """Generate a local fallback title without blocking on an LLM call."""
-        if not self._should_generate_title(state, title_config):
+        if not self._should_generate_title(state):
             return None
 
-        _, user_msg = self._build_title_prompt(state, title_config)
-        return {"title": self._fallback_title(user_msg, title_config)}
+        _, user_msg = self._build_title_prompt(state)
+        return {"title": self._fallback_title(user_msg)}
 
-    async def _agenerate_title_result(self, state: TitleMiddlewareState, app_config: AppConfig) -> dict | None:
+    async def _agenerate_title_result(self, state: TitleMiddlewareState) -> dict | None:
         """Generate a title asynchronously and fall back locally on failure."""
-        title_config = app_config.title
-        if not self._should_generate_title(state, title_config):
+        if not self._should_generate_title(state):
             return None
 
-        prompt, user_msg = self._build_title_prompt(state, title_config)
+        config = get_title_config()
+        prompt, user_msg = self._build_title_prompt(state)
 
         try:
-            if title_config.model_name:
-                model = create_chat_model(name=title_config.model_name, thinking_enabled=False, app_config=app_config)
+            if config.model_name:
+                model = create_chat_model(name=config.model_name, thinking_enabled=False)
             else:
-                model = create_chat_model(thinking_enabled=False, app_config=app_config)
+                model = create_chat_model(thinking_enabled=False)
             response = await model.ainvoke(prompt, config=self._get_runnable_config())
-            title = self._parse_title(response.content, title_config)
+            title = self._parse_title(response.content)
             if title:
                 return {"title": title}
         except Exception:
             logger.debug("Failed to generate async title; falling back to local title", exc_info=True)
-        return {"title": self._fallback_title(user_msg, title_config)}
+        return {"title": self._fallback_title(user_msg)}
 
     @override
-    def after_model(self, state: TitleMiddlewareState, runtime: Runtime[DeerFlowContext]) -> dict | None:
-        return self._generate_title_result(state, runtime.context.app_config.title)
+    def after_model(self, state: TitleMiddlewareState, runtime: Runtime) -> dict | None:
+        return self._generate_title_result(state)
 
     @override
-    async def aafter_model(self, state: TitleMiddlewareState, runtime: Runtime[DeerFlowContext]) -> dict | None:
-        return await self._agenerate_title_result(state, runtime.context.app_config)
+    async def aafter_model(self, state: TitleMiddlewareState, runtime: Runtime) -> dict | None:
+        return await self._agenerate_title_result(state)

backend/packages/harness/deerflow/agents/middlewares/todo_middleware.py

@@ -1,14 +1,9 @@
-"""Middleware that extends TodoListMiddleware with context-loss detection and premature-exit prevention.
+"""Middleware that extends TodoListMiddleware with context-loss detection.
 
 When the message history is truncated (e.g., by SummarizationMiddleware), the
 original `write_todos` tool call and its ToolMessage can be scrolled out of the
 active context window. This middleware detects that situation and injects a
 reminder message so the model still knows about the outstanding todo list.
-
-Additionally, this middleware prevents the agent from exiting the loop while
-there are still incomplete todo items. When the model produces a final response
-(no tool calls) but todos are not yet complete, the middleware injects a reminder
-and jumps back to the model node to force continued engagement.
 """
 
 from __future__ import annotations
@@ -17,7 +12,6 @@ from typing import Any, override
 
 from langchain.agents.middleware import TodoListMiddleware
 from langchain.agents.middleware.todo import PlanningState, Todo
-from langchain.agents.middleware.types import hook_config
 from langchain_core.messages import AIMessage, HumanMessage
 from langgraph.runtime import Runtime
 
@@ -40,11 +34,6 @@ def _reminder_in_messages(messages: list[Any]) -> bool:
     return False
 
 
-def _completion_reminder_count(messages: list[Any]) -> int:
-    """Return the number of todo_completion_reminder HumanMessages in *messages*."""
-    return sum(1 for msg in messages if isinstance(msg, HumanMessage) and getattr(msg, "name", None) == "todo_completion_reminder")
-
-
 def _format_todos(todos: list[Todo]) -> str:
     """Format a list of Todo items into a human-readable string."""
     lines: list[str] = []
@@ -68,7 +57,7 @@ class TodoMiddleware(TodoListMiddleware):
     def before_model(
         self,
         state: PlanningState,
-        runtime: Runtime,
+        runtime: Runtime,  # noqa: ARG002
     ) -> dict[str, Any] | None:
         """Inject a todo-list reminder when write_todos has left the context window."""
         todos: list[Todo] = state.get("todos") or []  # type: ignore[assignment]
@@ -109,71 +98,3 @@ class TodoMiddleware(TodoListMiddleware):
     ) -> dict[str, Any] | None:
         """Async version of before_model."""
         return self.before_model(state, runtime)
-
-    # Maximum number of completion reminders before allowing the agent to exit.
-    # This prevents infinite loops when the agent cannot make further progress.
-    _MAX_COMPLETION_REMINDERS = 2
-
-    @hook_config(can_jump_to=["model"])
-    @override
-    def after_model(
-        self,
-        state: PlanningState,
-        runtime: Runtime,
-    ) -> dict[str, Any] | None:
-        """Prevent premature agent exit when todo items are still incomplete.
-
-        In addition to the base class check for parallel ``write_todos`` calls,
-        this override intercepts model responses that have no tool calls while
-        there are still incomplete todo items. It injects a reminder
-        ``HumanMessage`` and jumps back to the model node so the agent
-        continues working through the todo list.
-
-        A retry cap of ``_MAX_COMPLETION_REMINDERS`` (default 2) prevents
-        infinite loops when the agent cannot make further progress.
-        """
-        # 1. Preserve base class logic (parallel write_todos detection).
-        base_result = super().after_model(state, runtime)
-        if base_result is not None:
-            return base_result
-
-        # 2. Only intervene when the agent wants to exit (no tool calls).
-        messages = state.get("messages") or []
-        last_ai = next((m for m in reversed(messages) if isinstance(m, AIMessage)), None)
-        if not last_ai or last_ai.tool_calls:
-            return None
-
-        # 3. Allow exit when all todos are completed or there are no todos.
-        todos: list[Todo] = state.get("todos") or []  # type: ignore[assignment]
-        if not todos or all(t.get("status") == "completed" for t in todos):
-            return None
-
-        # 4. Enforce a reminder cap to prevent infinite re-engagement loops.
-        if _completion_reminder_count(messages) >= self._MAX_COMPLETION_REMINDERS:
-            return None
-
-        # 5. Inject a reminder and force the agent back to the model.
-        incomplete = [t for t in todos if t.get("status") != "completed"]
-        incomplete_text = "\n".join(f"- [{t.get('status', 'pending')}] {t.get('content', '')}" for t in incomplete)
-        reminder = HumanMessage(
-            name="todo_completion_reminder",
-            content=(
-                "<system_reminder>\n"
-                "You have incomplete todo items that must be finished before giving your final response:\n\n"
-                f"{incomplete_text}\n\n"
-                "Please continue working on these tasks. Call `write_todos` to mark items as completed "
-                "as you finish them, and only respond when all items are done.\n"
-                "</system_reminder>"
-            ),
-        )
-        return {"jump_to": "model", "messages": [reminder]}
-
-    @override
-    @hook_config(can_jump_to=["model"])
-    async def aafter_model(
-        self,
-        state: PlanningState,
-        runtime: Runtime,
-    ) -> dict[str, Any] | None:
-        """Async version of after_model."""
-        return self.after_model(state, runtime)

backend/packages/harness/deerflow/agents/middlewares/tool_error_handling_middleware.py

@@ -1,10 +1,8 @@
 """Tool error handling middleware and shared runtime middleware builders."""
 
-from __future__ import annotations
-
 import logging
 from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, override
+from typing import override
 
 from langchain.agents import AgentState
 from langchain.agents.middleware import AgentMiddleware
@@ -13,9 +11,6 @@ from langgraph.errors import GraphBubbleUp
 from langgraph.prebuilt.tool_node import ToolCallRequest
 from langgraph.types import Command
 
-if TYPE_CHECKING:
-    from deerflow.config.app_config import AppConfig
-
 logger = logging.getLogger(__name__)
 
 _MISSING_TOOL_CALL_ID = "missing_tool_call_id"
@@ -72,7 +67,6 @@ class ToolErrorHandlingMiddleware(AgentMiddleware[AgentState]):
 
 def _build_runtime_middlewares(
     *,
-    app_config: "AppConfig",
     include_uploads: bool,
     include_dangling_tool_call_patch: bool,
     lazy_init: bool = True,
@@ -100,7 +94,9 @@ def _build_runtime_middlewares(
     middlewares.append(LLMErrorHandlingMiddleware())
 
     # Guardrail middleware (if configured)
-    guardrails_config = app_config.guardrails
+    from deerflow.config.guardrails_config import get_guardrails_config
+
+    guardrails_config = get_guardrails_config()
     if guardrails_config.enabled and guardrails_config.provider:
         import inspect
 
@@ -129,10 +125,9 @@ def _build_runtime_middlewares(
     return middlewares
 
 
-def build_lead_runtime_middlewares(*, app_config: "AppConfig", lazy_init: bool = True) -> list[AgentMiddleware]:
+def build_lead_runtime_middlewares(*, lazy_init: bool = True) -> list[AgentMiddleware]:
     """Middlewares shared by lead agent runtime before lead-only middlewares."""
     return _build_runtime_middlewares(
-        app_config=app_config,
         include_uploads=True,
         include_dangling_tool_call_patch=True,
         lazy_init=lazy_init,

backend/packages/harness/deerflow/agents/middlewares/uploads_middleware.py

@@ -9,9 +9,7 @@ from langchain.agents.middleware import AgentMiddleware
 from langchain_core.messages import HumanMessage
 from langgraph.runtime import Runtime
 
-from deerflow.config.deer_flow_context import DeerFlowContext
 from deerflow.config.paths import Paths, get_paths
-from deerflow.runtime.user_context import get_effective_user_id
 from deerflow.utils.file_conversion import extract_outline
 
 logger = logging.getLogger(__name__)
@@ -186,7 +184,7 @@ class UploadsMiddleware(AgentMiddleware[UploadsMiddlewareState]):
         return files if files else None
 
     @override
-    def before_agent(self, state: UploadsMiddlewareState, runtime: Runtime[DeerFlowContext]) -> dict | None:
+    def before_agent(self, state: UploadsMiddlewareState, runtime: Runtime) -> dict | None:
         """Inject uploaded files information before agent execution.
 
         New files come from the current message's additional_kwargs.files.
@@ -215,8 +213,15 @@ class UploadsMiddleware(AgentMiddleware[UploadsMiddlewareState]):
             return None
 
         # Resolve uploads directory for existence checks
-        thread_id = runtime.context.thread_id
-        uploads_dir = self._paths.sandbox_uploads_dir(thread_id, user_id=get_effective_user_id()) if thread_id else None
+        thread_id = (runtime.context or {}).get("thread_id")
+        if thread_id is None:
+            try:
+                from langgraph.config import get_config
+
+                thread_id = get_config().get("configurable", {}).get("thread_id")
+            except RuntimeError:
+                pass  # get_config() raises outside a runnable context (e.g. unit tests)
+        uploads_dir = self._paths.sandbox_uploads_dir(thread_id) if thread_id else None
 
         # Get newly uploaded files from the current message's additional_kwargs.files
         new_files = self._files_from_kwargs(last_message, uploads_dir) or []
@@ -257,25 +262,21 @@ class UploadsMiddleware(AgentMiddleware[UploadsMiddlewareState]):
         files_message = self._create_files_message(new_files, historical_files)
 
         # Extract original content - handle both string and list formats
-        original_content = last_message.content
-        if isinstance(original_content, str):
-            # Simple case: string content, just prepend files message
-            updated_content = f"{files_message}\n\n{original_content}"
-        elif isinstance(original_content, list):
-            # Complex case: list content (multimodal), preserve all blocks
-            # Prepend files message as the first text block
-            files_block = {"type": "text", "text": f"{files_message}\n\n"}
-            # Keep all original blocks (including images)
-            updated_content = [files_block, *original_content]
-        else:
-            # Other types, preserve as-is
-            updated_content = original_content
+        original_content = ""
+        if isinstance(last_message.content, str):
+            original_content = last_message.content
+        elif isinstance(last_message.content, list):
+            text_parts = []
+            for block in last_message.content:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    text_parts.append(block.get("text", ""))
+            original_content = "\n".join(text_parts)
 
         # Create new message with combined content.
         # Preserve additional_kwargs (including files metadata) so the frontend
         # can read structured file info from the streamed message.
         updated_message = HumanMessage(
-            content=updated_content,
+            content=f"{files_message}\n\n{original_content}",
             id=last_message.id,
             additional_kwargs=last_message.additional_kwargs,
         )

backend/packages/harness/deerflow/client.py

@@ -25,7 +25,7 @@ import uuid
 from collections.abc import Generator, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any
 
 from langchain.agents import create_agent
 from langchain.agents.middleware import AgentMiddleware
@@ -36,12 +36,10 @@ from deerflow.agents.lead_agent.agent import _build_middlewares
 from deerflow.agents.lead_agent.prompt import apply_prompt_template
 from deerflow.agents.thread_state import ThreadState
 from deerflow.config.agents_config import AGENT_NAME_PATTERN
-from deerflow.config.app_config import AppConfig
-from deerflow.config.deer_flow_context import DeerFlowContext
-from deerflow.config.extensions_config import ExtensionsConfig
+from deerflow.config.app_config import get_app_config, reload_app_config
+from deerflow.config.extensions_config import ExtensionsConfig, SkillStateConfig, get_extensions_config, reload_extensions_config
 from deerflow.config.paths import get_paths
 from deerflow.models import create_chat_model
-from deerflow.runtime.user_context import get_effective_user_id
 from deerflow.skills.installer import install_skill_from_archive
 from deerflow.uploads.manager import (
     claim_unique_filename,
@@ -57,9 +55,6 @@ from deerflow.uploads.manager import (
 logger = logging.getLogger(__name__)
 
 
-StreamEventType = Literal["values", "messages-tuple", "custom", "end"]
-
-
 @dataclass
 class StreamEvent:
     """A single event from the streaming agent response.
@@ -74,7 +69,7 @@ class StreamEvent:
         data: Event payload. Contents vary by type.
     """
 
-    type: StreamEventType
+    type: str
     data: dict[str, Any] = field(default_factory=dict)
 
 
@@ -117,7 +112,6 @@ class DeerFlowClient:
         config_path: str | None = None,
         checkpointer=None,
         *,
-        config: AppConfig | None = None,
         model_name: str | None = None,
         thinking_enabled: bool = True,
         subagent_enabled: bool = False,
@@ -132,14 +126,9 @@ class DeerFlowClient:
 
         Args:
             config_path: Path to config.yaml. Uses default resolution if None.
-                Ignored when ``config`` is provided.
             checkpointer: LangGraph checkpointer instance for state persistence.
                 Required for multi-turn conversations on the same thread_id.
                 Without a checkpointer, each call is stateless.
-            config: Optional pre-constructed AppConfig. When provided, it takes
-                precedence over ``config_path`` and no file is read. Enables
-                multi-client isolation: two clients with different configs can
-                coexist in the same process without touching process-global state.
             model_name: Override the default model name from config.
             thinking_enabled: Enable model's extended thinking.
             subagent_enabled: Enable subagent delegation.
@@ -148,18 +137,9 @@ class DeerFlowClient:
             available_skills: Optional set of skill names to make available. If None (default), all scanned skills are available.
             middlewares: Optional list of custom middlewares to inject into the agent.
         """
-        # Constructor-captured config: the client owns its AppConfig for its lifetime.
-        # Multiple clients with different configs do not contend.
-        #
-        # Priority: explicit ``config=`` > explicit ``config_path=`` > ``AppConfig.from_file()``
-        # with default path resolution. There is no ambient global fallback; if
-        # config.yaml cannot be located, ``from_file`` raises loudly.
-        if config is not None:
-            self._app_config = config
-        elif config_path is not None:
-            self._app_config = AppConfig.from_file(config_path)
-        else:
-            self._app_config = AppConfig.from_file()
+        if config_path is not None:
+            reload_app_config(config_path)
+        self._app_config = get_app_config()
 
         if agent_name is not None and not AGENT_NAME_PATTERN.match(agent_name):
             raise ValueError(f"Invalid agent name '{agent_name}'. Must match pattern: {AGENT_NAME_PATTERN.pattern}")
@@ -187,15 +167,6 @@ class DeerFlowClient:
         self._agent = None
         self._agent_config_key = None
 
-    def _reload_config(self) -> None:
-        """Reload config from file and refresh the cached reference.
-
-        Only the client's own ``_app_config`` is rebuilt. Other clients
-        and the process-global are untouched, so multi-client coexistence
-        survives reload.
-        """
-        self._app_config = AppConfig.from_file()
-
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------
@@ -253,11 +224,10 @@ class DeerFlowClient:
         max_concurrent_subagents = cfg.get("max_concurrent_subagents", 3)
 
         kwargs: dict[str, Any] = {
-            "model": create_chat_model(name=model_name, thinking_enabled=thinking_enabled, app_config=self._app_config),
+            "model": create_chat_model(name=model_name, thinking_enabled=thinking_enabled),
             "tools": self._get_tools(model_name=model_name, subagent_enabled=subagent_enabled),
-            "middleware": _build_middlewares(self._app_config, config, model_name=model_name, agent_name=self._agent_name, custom_middlewares=self._middlewares),
+            "middleware": _build_middlewares(config, model_name=model_name, agent_name=self._agent_name, custom_middlewares=self._middlewares),
             "system_prompt": apply_prompt_template(
-                self._app_config,
                 subagent_enabled=subagent_enabled,
                 max_concurrent_subagents=max_concurrent_subagents,
                 agent_name=self._agent_name,
@@ -267,9 +237,9 @@ class DeerFlowClient:
         }
         checkpointer = self._checkpointer
         if checkpointer is None:
-            from deerflow.runtime.checkpointer import get_checkpointer
+            from deerflow.agents.checkpointer import get_checkpointer
 
-            checkpointer = get_checkpointer(self._app_config)
+            checkpointer = get_checkpointer()
         if checkpointer is not None:
             kwargs["checkpointer"] = checkpointer
 
@@ -277,51 +247,12 @@ class DeerFlowClient:
         self._agent_config_key = key
         logger.info("Agent created: agent_name=%s, model=%s, thinking=%s", self._agent_name, model_name, thinking_enabled)
 
-    def _get_tools(self, *, model_name: str | None, subagent_enabled: bool):
+    @staticmethod
+    def _get_tools(*, model_name: str | None, subagent_enabled: bool):
         """Lazy import to avoid circular dependency at module level."""
         from deerflow.tools import get_available_tools
 
-        return get_available_tools(model_name=model_name, subagent_enabled=subagent_enabled, app_config=self._app_config)
-
-    @staticmethod
-    def _serialize_tool_calls(tool_calls) -> list[dict]:
-        """Reshape LangChain tool_calls into the wire format used in events."""
-        return [{"name": tc["name"], "args": tc["args"], "id": tc.get("id")} for tc in tool_calls]
-
-    @staticmethod
-    def _ai_text_event(msg_id: str | None, text: str, usage: dict | None) -> "StreamEvent":
-        """Build a ``messages-tuple`` AI text event, attaching usage when present."""
-        data: dict[str, Any] = {"type": "ai", "content": text, "id": msg_id}
-        if usage:
-            data["usage_metadata"] = usage
-        return StreamEvent(type="messages-tuple", data=data)
-
-    @staticmethod
-    def _ai_tool_calls_event(msg_id: str | None, tool_calls) -> "StreamEvent":
-        """Build a ``messages-tuple`` AI tool-calls event."""
-        return StreamEvent(
-            type="messages-tuple",
-            data={
-                "type": "ai",
-                "content": "",
-                "id": msg_id,
-                "tool_calls": DeerFlowClient._serialize_tool_calls(tool_calls),
-            },
-        )
-
-    @staticmethod
-    def _tool_message_event(msg: ToolMessage) -> "StreamEvent":
-        """Build a ``messages-tuple`` tool-result event from a ToolMessage."""
-        return StreamEvent(
-            type="messages-tuple",
-            data={
-                "type": "tool",
-                "content": DeerFlowClient._extract_text(msg.content),
-                "name": msg.name,
-                "tool_call_id": msg.tool_call_id,
-                "id": msg.id,
-            },
-        )
+        return get_available_tools(model_name=model_name, subagent_enabled=subagent_enabled)
 
     @staticmethod
     def _serialize_message(msg) -> dict:
@@ -329,7 +260,7 @@ class DeerFlowClient:
         if isinstance(msg, AIMessage):
             d: dict[str, Any] = {"type": "ai", "content": msg.content, "id": getattr(msg, "id", None)}
             if msg.tool_calls:
-                d["tool_calls"] = DeerFlowClient._serialize_tool_calls(msg.tool_calls)
+                d["tool_calls"] = [{"name": tc["name"], "args": tc["args"], "id": tc.get("id")} for tc in msg.tool_calls]
             if getattr(msg, "usage_metadata", None):
                 d["usage_metadata"] = msg.usage_metadata
             return d
@@ -384,108 +315,6 @@ class DeerFlowClient:
             return "\n".join(pieces) if pieces else ""
         return str(content)
 
-    # ------------------------------------------------------------------
-    # Public API — threads
-    # ------------------------------------------------------------------
-
-    def list_threads(self, limit: int = 10) -> dict:
-        """List the recent N threads.
-
-        Args:
-            limit: Maximum number of threads to return. Default is 10.
-
-        Returns:
-            Dict with "thread_list" key containing list of thread info dicts,
-            sorted by thread creation time descending.
-        """
-        checkpointer = self._checkpointer
-        if checkpointer is None:
-            from deerflow.runtime.checkpointer.provider import get_checkpointer
-
-            checkpointer = get_checkpointer(self._app_config)
-
-        thread_info_map = {}
-
-        for cp in checkpointer.list(config=None, limit=limit):
-            cfg = cp.config.get("configurable", {})
-            thread_id = cfg.get("thread_id")
-            if not thread_id:
-                continue
-
-            ts = cp.checkpoint.get("ts")
-            checkpoint_id = cfg.get("checkpoint_id")
-
-            if thread_id not in thread_info_map:
-                channel_values = cp.checkpoint.get("channel_values", {})
-                thread_info_map[thread_id] = {
-                    "thread_id": thread_id,
-                    "created_at": ts,
-                    "updated_at": ts,
-                    "latest_checkpoint_id": checkpoint_id,
-                    "title": channel_values.get("title"),
-                }
-            else:
-                # Explicitly compare timestamps to ensure accuracy when iterating over unordered namespaces.
-                # Treat None as "missing" and only compare when existing values are non-None.
-                if ts is not None:
-                    current_created = thread_info_map[thread_id]["created_at"]
-                    if current_created is None or ts < current_created:
-                        thread_info_map[thread_id]["created_at"] = ts
-
-                    current_updated = thread_info_map[thread_id]["updated_at"]
-                    if current_updated is None or ts > current_updated:
-                        thread_info_map[thread_id]["updated_at"] = ts
-                        thread_info_map[thread_id]["latest_checkpoint_id"] = checkpoint_id
-                        channel_values = cp.checkpoint.get("channel_values", {})
-                        thread_info_map[thread_id]["title"] = channel_values.get("title")
-
-        threads = list(thread_info_map.values())
-        threads.sort(key=lambda x: x.get("created_at") or "", reverse=True)
-
-        return {"thread_list": threads[:limit]}
-
-    def get_thread(self, thread_id: str) -> dict:
-        """Get the complete thread record, including all node execution records.
-
-        Args:
-            thread_id: Thread ID.
-
-        Returns:
-            Dict containing the thread's full checkpoint history.
-        """
-        checkpointer = self._checkpointer
-        if checkpointer is None:
-            from deerflow.runtime.checkpointer.provider import get_checkpointer
-
-            checkpointer = get_checkpointer(self._app_config)
-
-        config = {"configurable": {"thread_id": thread_id}}
-        checkpoints = []
-
-        for cp in checkpointer.list(config):
-            channel_values = dict(cp.checkpoint.get("channel_values", {}))
-            if "messages" in channel_values:
-                channel_values["messages"] = [self._serialize_message(m) if hasattr(m, "content") else m for m in channel_values["messages"]]
-
-            cfg = cp.config.get("configurable", {})
-            parent_cfg = cp.parent_config.get("configurable", {}) if cp.parent_config else {}
-
-            checkpoints.append(
-                {
-                    "checkpoint_id": cfg.get("checkpoint_id"),
-                    "parent_checkpoint_id": parent_cfg.get("checkpoint_id"),
-                    "ts": cp.checkpoint.get("ts"),
-                    "metadata": cp.metadata,
-                    "values": channel_values,
-                    "pending_writes": [{"task_id": w[0], "channel": w[1], "value": w[2]} for w in getattr(cp, "pending_writes", [])],
-                }
-            )
-
-        # Sort globally by timestamp to prevent partial ordering issues caused by different namespaces (e.g., subgraphs)
-        checkpoints.sort(key=lambda x: x["ts"] if x["ts"] else "")
-
-        return {"thread_id": thread_id, "checkpoints": checkpoints}
-
     # ------------------------------------------------------------------
     # Public API — conversation
     # ------------------------------------------------------------------
@@ -507,53 +336,6 @@ class DeerFlowClient:
         consumers can switch between HTTP streaming and embedded mode
         without changing their event-handling logic.
 
-        Token-level streaming
-        ~~~~~~~~~~~~~~~~~~~~~
-        This method subscribes to LangGraph's ``messages`` stream mode, so
-        ``messages-tuple`` events for AI text are emitted as **deltas** as
-        the model generates tokens, not as one cumulative dump at node
-        completion.  Each delta carries a stable ``id`` — consumers that
-        want the full text must accumulate ``content`` per ``id``.
-        ``chat()`` already does this for you.
-
-        Tool calls and tool results are still emitted once per logical
-        message.  ``values`` events continue to carry full state snapshots
-        after each graph node finishes; AI text already delivered via the
-        ``messages`` stream is **not** re-synthesized from the snapshot to
-        avoid duplicate deliveries.
-
-        Why not reuse Gateway's ``run_agent``?
-        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        Gateway (``runtime/runs/worker.py``) has a complete streaming
-        pipeline: ``run_agent`` → ``StreamBridge`` → ``sse_consumer``.  It
-        looks like this client duplicates that work, but the two paths
-        serve different audiences and **cannot** share execution:
-
-        * ``run_agent`` is ``async def`` and uses ``agent.astream()``;
-          this method is a sync generator using ``agent.stream()`` so
-          callers can write ``for event in client.stream(...)`` without
-          touching asyncio.  Bridging the two would require spinning up
-          an event loop + thread per call.
-        * Gateway events are JSON-serialized by ``serialize()`` for SSE
-          wire transmission.  This client yields in-process stream event
-          payloads directly as Python data structures (``StreamEvent``
-          with ``data`` as a plain ``dict``), without the extra
-          JSON/SSE serialization layer used for HTTP delivery.
-        * ``StreamBridge`` is an asyncio-queue decoupling producers from
-          consumers across an HTTP boundary (``Last-Event-ID`` replay,
-          heartbeats, multi-subscriber fan-out).  A single in-process
-          caller with a direct iterator needs none of that.
-
-        So ``DeerFlowClient.stream()`` is a parallel, sync, in-process
-        consumer of the same ``create_agent()`` factory — not a wrapper
-        around Gateway.  The two paths **should** stay in sync on which
-        LangGraph stream modes they subscribe to; that invariant is
-        enforced by ``tests/test_client.py::test_messages_mode_emits_token_deltas``
-        rather than by a shared constant, because the three layers
-        (Graph, Platform SDK, HTTP) each use their own naming
-        (``messages`` vs ``messages-tuple``) and cannot literally share
-        a string.
-
         Args:
             message: User message text.
             thread_id: Thread ID for conversation context. Auto-generated if None.
@@ -564,8 +346,8 @@ class DeerFlowClient:
             StreamEvent with one of:
             - type="values"          data={"title": str|None, "messages": [...], "artifacts": [...]}
             - type="custom"          data={...}
-            - type="messages-tuple"  data={"type": "ai", "content": <delta>, "id": str}
-            - type="messages-tuple"  data={"type": "ai", "content": <delta>, "id": str, "usage_metadata": {...}}
+            - type="messages-tuple"  data={"type": "ai", "content": str, "id": str}
+            - type="messages-tuple"  data={"type": "ai", "content": str, "id": str, "usage_metadata": {...}}
             - type="messages-tuple"  data={"type": "ai", "content": "", "id": str, "tool_calls": [...]}
             - type="messages-tuple"  data={"type": "tool", "content": str, "name": str, "tool_call_id": str, "id": str}
             - type="end"             data={"usage": {"input_tokens": int, "output_tokens": int, "total_tokens": int}}
@@ -577,50 +359,18 @@ class DeerFlowClient:
         self._ensure_agent(config)
 
         state: dict[str, Any] = {"messages": [HumanMessage(content=message)]}
-        context = DeerFlowContext(app_config=self._app_config, thread_id=thread_id, agent_name=self._agent_name)
+        context = {"thread_id": thread_id}
+        if self._agent_name:
+            context["agent_name"] = self._agent_name
 
         seen_ids: set[str] = set()
-        # Cross-mode handoff: ids already streamed via LangGraph ``messages``
-        # mode so the ``values`` path skips re-synthesis of the same message.
-        streamed_ids: set[str] = set()
-        # The same message id carries identical cumulative ``usage_metadata``
-        # in both the final ``messages`` chunk and the values snapshot —
-        # count it only on whichever arrives first.
-        counted_usage_ids: set[str] = set()
         cumulative_usage: dict[str, int] = {"input_tokens": 0, "output_tokens": 0, "total_tokens": 0}
 
-        def _account_usage(msg_id: str | None, usage: Any) -> dict | None:
-            """Add *usage* to cumulative totals if this id has not been counted.
-
-            ``usage`` is a ``langchain_core.messages.UsageMetadata`` TypedDict
-            or ``None``; typed as ``Any`` because TypedDicts are not
-            structurally assignable to plain ``dict`` under strict type
-            checking.  Returns the normalized usage dict (for attaching
-            to an event) when we accepted it, otherwise ``None``.
-            """
-            if not usage:
-                return None
-            if msg_id and msg_id in counted_usage_ids:
-                return None
-            if msg_id:
-                counted_usage_ids.add(msg_id)
-            input_tokens = usage.get("input_tokens", 0) or 0
-            output_tokens = usage.get("output_tokens", 0) or 0
-            total_tokens = usage.get("total_tokens", 0) or 0
-            cumulative_usage["input_tokens"] += input_tokens
-            cumulative_usage["output_tokens"] += output_tokens
-            cumulative_usage["total_tokens"] += total_tokens
-            return {
-                "input_tokens": input_tokens,
-                "output_tokens": output_tokens,
-                "total_tokens": total_tokens,
-            }
-
         for item in self._agent.stream(
             state,
             config=config,
             context=context,
-            stream_mode=["values", "messages", "custom"],
+            stream_mode=["values", "custom"],
         ):
             if isinstance(item, tuple) and len(item) == 2:
                 mode, chunk = item
@@ -632,36 +382,6 @@ class DeerFlowClient:
                 yield StreamEvent(type="custom", data=chunk)
                 continue
 
-            if mode == "messages":
-                # LangGraph ``messages`` mode emits ``(message_chunk, metadata)``.
-                if isinstance(chunk, tuple) and len(chunk) == 2:
-                    msg_chunk, _metadata = chunk
-                else:
-                    msg_chunk = chunk
-
-                msg_id = getattr(msg_chunk, "id", None)
-
-                if isinstance(msg_chunk, AIMessage):
-                    text = self._extract_text(msg_chunk.content)
-                    counted_usage = _account_usage(msg_id, msg_chunk.usage_metadata)
-
-                    if text:
-                        if msg_id:
-                            streamed_ids.add(msg_id)
-                        yield self._ai_text_event(msg_id, text, counted_usage)
-
-                    if msg_chunk.tool_calls:
-                        if msg_id:
-                            streamed_ids.add(msg_id)
-                        yield self._ai_tool_calls_event(msg_id, msg_chunk.tool_calls)
-
-                elif isinstance(msg_chunk, ToolMessage):
-                    if msg_id:
-                        streamed_ids.add(msg_id)
-                    yield self._tool_message_event(msg_chunk)
-                continue
-
-            # mode == "values"
             messages = chunk.get("messages", [])
 
             for msg in messages:
@@ -671,25 +391,47 @@ class DeerFlowClient:
                 if msg_id:
                     seen_ids.add(msg_id)
 
-                # Already streamed via ``messages`` mode; only (defensively)
-                # capture usage here and skip re-synthesizing the event.
-                if msg_id and msg_id in streamed_ids:
-                    if isinstance(msg, AIMessage):
-                        _account_usage(msg_id, getattr(msg, "usage_metadata", None))
-                    continue
-
                 if isinstance(msg, AIMessage):
-                    counted_usage = _account_usage(msg_id, msg.usage_metadata)
+                    # Track token usage from AI messages
+                    usage = getattr(msg, "usage_metadata", None)
+                    if usage:
+                        cumulative_usage["input_tokens"] += usage.get("input_tokens", 0) or 0
+                        cumulative_usage["output_tokens"] += usage.get("output_tokens", 0) or 0
+                        cumulative_usage["total_tokens"] += usage.get("total_tokens", 0) or 0
 
                     if msg.tool_calls:
-                        yield self._ai_tool_calls_event(msg_id, msg.tool_calls)
+                        yield StreamEvent(
+                            type="messages-tuple",
+                            data={
+                                "type": "ai",
+                                "content": "",
+                                "id": msg_id,
+                                "tool_calls": [{"name": tc["name"], "args": tc["args"], "id": tc.get("id")} for tc in msg.tool_calls],
+                            },
+                        )
 
                     text = self._extract_text(msg.content)
                     if text:
-                        yield self._ai_text_event(msg_id, text, counted_usage)
+                        event_data: dict[str, Any] = {"type": "ai", "content": text, "id": msg_id}
+                        if usage:
+                            event_data["usage_metadata"] = {
+                                "input_tokens": usage.get("input_tokens", 0) or 0,
+                                "output_tokens": usage.get("output_tokens", 0) or 0,
+                                "total_tokens": usage.get("total_tokens", 0) or 0,
+                            }
+                        yield StreamEvent(type="messages-tuple", data=event_data)
 
                 elif isinstance(msg, ToolMessage):
-                    yield self._tool_message_event(msg)
+                    yield StreamEvent(
+                        type="messages-tuple",
+                        data={
+                            "type": "tool",
+                            "content": self._extract_text(msg.content),
+                            "name": getattr(msg, "name", None),
+                            "tool_call_id": getattr(msg, "tool_call_id", None),
+                            "id": msg_id,
+                        },
+                    )
 
             # Emit a values event for each state snapshot
             yield StreamEvent(
@@ -706,12 +448,10 @@ class DeerFlowClient:
     def chat(self, message: str, *, thread_id: str | None = None, **kwargs) -> str:
         """Send a message and return the final text response.
 
-        Convenience wrapper around :meth:`stream` that accumulates delta
-        ``messages-tuple`` events per ``id`` and returns the text of the
-        **last** AI message to complete.  Intermediate AI messages (e.g.
-        planner drafts) are discarded — only the final id's accumulated
-        text is returned.  Use :meth:`stream` directly if you need every
-        delta as it arrives.
+        Convenience wrapper around :meth:`stream` that returns only the
+        **last** AI text from ``messages-tuple`` events. If the agent emits
+        multiple text segments in one turn, intermediate segments are
+        discarded. Use :meth:`stream` directly to capture all events.
 
         Args:
             message: User message text.
@@ -719,21 +459,15 @@ class DeerFlowClient:
             **kwargs: Override client defaults (same as stream()).
 
         Returns:
-            The accumulated text of the last AI message, or empty string
-            if no AI text was produced.
+            The last AI message text, or empty string if no response.
         """
-        # Per-id delta lists joined once at the end — avoids the O(n²) cost
-        # of repeated ``str + str`` on a growing buffer for long responses.
-        chunks: dict[str, list[str]] = {}
-        last_id: str = ""
+        last_text = ""
         for event in self.stream(message, thread_id=thread_id, **kwargs):
             if event.type == "messages-tuple" and event.data.get("type") == "ai":
-                msg_id = event.data.get("id") or ""
-                delta = event.data.get("content", "")
-                if delta:
-                    chunks.setdefault(msg_id, []).append(delta)
-                    last_id = msg_id
-        return "".join(chunks.get(last_id, ()))
+                content = event.data.get("content", "")
+                if content:
+                    last_text = content
+        return last_text
 
     # ------------------------------------------------------------------
     # Public API — configuration queries
@@ -746,10 +480,6 @@ class DeerFlowClient:
             Dict with "models" key containing list of model info dicts,
             matching the Gateway API ``ModelsListResponse`` schema.
         """
-        token_usage_enabled = getattr(getattr(self._app_config, "token_usage", None), "enabled", False)
-        if not isinstance(token_usage_enabled, bool):
-            token_usage_enabled = False
-
         return {
             "models": [
                 {
@@ -761,8 +491,7 @@ class DeerFlowClient:
                     "supports_reasoning_effort": getattr(model, "supports_reasoning_effort", False),
                 }
                 for model in self._app_config.models
-            ],
-            "token_usage": {"enabled": token_usage_enabled},
+            ]
         }
 
     def list_skills(self, enabled_only: bool = False) -> dict:
@@ -786,7 +515,7 @@ class DeerFlowClient:
                     "category": s.category,
                     "enabled": s.enabled,
                 }
-                for s in load_skills(self._app_config, enabled_only=enabled_only)
+                for s in load_skills(enabled_only=enabled_only)
             ]
         }
 
@@ -798,19 +527,19 @@ class DeerFlowClient:
         """
         from deerflow.agents.memory.updater import get_memory_data
 
-        return get_memory_data(self._app_config.memory, user_id=get_effective_user_id())
+        return get_memory_data()
 
     def export_memory(self) -> dict:
         """Export current memory data for backup or transfer."""
         from deerflow.agents.memory.updater import get_memory_data
 
-        return get_memory_data(self._app_config.memory, user_id=get_effective_user_id())
+        return get_memory_data()
 
     def import_memory(self, memory_data: dict) -> dict:
         """Import and persist full memory data."""
         from deerflow.agents.memory.updater import import_memory_data
 
-        return import_memory_data(self._app_config.memory, memory_data, user_id=get_effective_user_id())
+        return import_memory_data(memory_data)
 
     def get_model(self, name: str) -> dict | None:
         """Get a specific model's configuration by name.
@@ -845,8 +574,8 @@ class DeerFlowClient:
             Dict with "mcp_servers" key mapping server name to config,
             matching the Gateway API ``McpConfigResponse`` schema.
         """
-        ext = self._app_config.extensions
-        return {"mcp_servers": {name: server.model_dump() for name, server in ext.mcp_servers.items()}}
+        config = get_extensions_config()
+        return {"mcp_servers": {name: server.model_dump() for name, server in config.mcp_servers.items()}}
 
     def update_mcp_config(self, mcp_servers: dict[str, dict]) -> dict:
         """Update MCP server configurations.
@@ -868,19 +597,18 @@ class DeerFlowClient:
         if config_path is None:
             raise FileNotFoundError("Cannot locate extensions_config.json. Set DEER_FLOW_EXTENSIONS_CONFIG_PATH or ensure it exists in the project root.")
 
-        current_ext = self._app_config.extensions
+        current_config = get_extensions_config()
 
         config_data = {
             "mcpServers": mcp_servers,
-            "skills": {name: {"enabled": skill.enabled} for name, skill in current_ext.skills.items()},
+            "skills": {name: {"enabled": skill.enabled} for name, skill in current_config.skills.items()},
         }
 
         self._atomic_write_json(config_path, config_data)
 
         self._agent = None
         self._agent_config_key = None
-        self._reload_config()
-        reloaded = self._app_config.extensions
+        reloaded = reload_extensions_config()
         return {"mcp_servers": {name: server.model_dump() for name, server in reloaded.mcp_servers.items()}}
 
     # ------------------------------------------------------------------
@@ -898,7 +626,7 @@ class DeerFlowClient:
         """
         from deerflow.skills.loader import load_skills
 
-        skill = next((s for s in load_skills(self._app_config, enabled_only=False) if s.name == name), None)
+        skill = next((s for s in load_skills(enabled_only=False) if s.name == name), None)
         if skill is None:
             return None
         return {
@@ -925,7 +653,7 @@ class DeerFlowClient:
         """
         from deerflow.skills.loader import load_skills
 
-        skills = load_skills(self._app_config, enabled_only=False)
+        skills = load_skills(enabled_only=False)
         skill = next((s for s in skills if s.name == name), None)
         if skill is None:
             raise ValueError(f"Skill '{name}' not found")
@@ -934,25 +662,21 @@ class DeerFlowClient:
         if config_path is None:
             raise FileNotFoundError("Cannot locate extensions_config.json. Set DEER_FLOW_EXTENSIONS_CONFIG_PATH or ensure it exists in the project root.")
 
-        # Do not mutate self._app_config (frozen value). Compose the new
-        # skills state in a fresh dict, write it to disk, and let _reload_config()
-        # below rebuild AppConfig from the updated file.
-        ext = self._app_config.extensions
-        new_skills = {n: {"enabled": sc.enabled} for n, sc in ext.skills.items()}
-        new_skills[name] = {"enabled": enabled}
+        extensions_config = get_extensions_config()
+        extensions_config.skills[name] = SkillStateConfig(enabled=enabled)
 
         config_data = {
-            "mcpServers": {n: s.model_dump() for n, s in ext.mcp_servers.items()},
-            "skills": new_skills,
+            "mcpServers": {n: s.model_dump() for n, s in extensions_config.mcp_servers.items()},
+            "skills": {n: {"enabled": sc.enabled} for n, sc in extensions_config.skills.items()},
         }
 
         self._atomic_write_json(config_path, config_data)
 
         self._agent = None
         self._agent_config_key = None
-        self._reload_config()
+        reload_extensions_config()
 
-        updated = next((s for s in load_skills(self._app_config, enabled_only=False) if s.name == name), None)
+        updated = next((s for s in load_skills(enabled_only=False) if s.name == name), None)
         if updated is None:
             raise RuntimeError(f"Skill '{name}' disappeared after update")
         return {
@@ -990,25 +714,25 @@ class DeerFlowClient:
         """
         from deerflow.agents.memory.updater import reload_memory_data
 
-        return reload_memory_data(self._app_config.memory, user_id=get_effective_user_id())
+        return reload_memory_data()
 
     def clear_memory(self) -> dict:
         """Clear all persisted memory data."""
         from deerflow.agents.memory.updater import clear_memory_data
 
-        return clear_memory_data(self._app_config.memory, user_id=get_effective_user_id())
+        return clear_memory_data()
 
     def create_memory_fact(self, content: str, category: str = "context", confidence: float = 0.5) -> dict:
         """Create a single fact manually."""
         from deerflow.agents.memory.updater import create_memory_fact
 
-        return create_memory_fact(self._app_config.memory, content=content, category=category, confidence=confidence)
+        return create_memory_fact(content=content, category=category, confidence=confidence)
 
     def delete_memory_fact(self, fact_id: str) -> dict:
         """Delete a single fact from memory by fact id."""
         from deerflow.agents.memory.updater import delete_memory_fact
 
-        return delete_memory_fact(self._app_config.memory, fact_id)
+        return delete_memory_fact(fact_id)
 
     def update_memory_fact(
         self,
@@ -1021,7 +745,6 @@ class DeerFlowClient:
         from deerflow.agents.memory.updater import update_memory_fact
 
         return update_memory_fact(
-            self._app_config.memory,
             fact_id=fact_id,
             content=content,
             category=category,
@@ -1034,7 +757,9 @@ class DeerFlowClient:
         Returns:
             Memory config dict.
         """
-        config = self._app_config.memory
+        from deerflow.config.memory_config import get_memory_config
+
+        config = get_memory_config()
         return {
             "enabled": config.enabled,
             "storage_path": config.storage_path,
@@ -1212,7 +937,7 @@ class DeerFlowClient:
             ValueError: If the path is invalid.
         """
         try:
-            actual = get_paths().resolve_virtual_path(thread_id, path, user_id=get_effective_user_id())
+            actual = get_paths().resolve_virtual_path(thread_id, path)
         except ValueError as exc:
             if "traversal" in str(exc):
                 from deerflow.uploads.manager import PathTraversalError

backend/packages/harness/deerflow/community/aio_sandbox/aio_sandbox_provider.py

@@ -25,9 +25,8 @@ except ImportError:  # pragma: no cover - Windows fallback
     fcntl = None  # type: ignore[assignment]
     import msvcrt
 
-from deerflow.config.app_config import AppConfig
+from deerflow.config import get_app_config
 from deerflow.config.paths import VIRTUAL_PATH_PREFIX, get_paths
-from deerflow.runtime.user_context import get_effective_user_id
 from deerflow.sandbox.sandbox import Sandbox
 from deerflow.sandbox.sandbox_provider import SandboxProvider
 
@@ -90,8 +89,7 @@ class AioSandboxProvider(SandboxProvider):
           API_KEY: $MY_API_KEY
     """
 
-    def __init__(self, app_config: "AppConfig"):
-        self._app_config = app_config
+    def __init__(self):
         self._lock = threading.Lock()
         self._sandboxes: dict[str, AioSandbox] = {}  # sandbox_id -> AioSandbox instance
         self._sandbox_infos: dict[str, SandboxInfo] = {}  # sandbox_id -> SandboxInfo (for destroy)
@@ -114,23 +112,10 @@ class AioSandboxProvider(SandboxProvider):
         atexit.register(self.shutdown)
         self._register_signal_handlers()
 
-        # Reconcile orphaned containers from previous process lifecycles
-        self._reconcile_orphans()
-
         # Start idle checker if enabled
         if self._config.get("idle_timeout", DEFAULT_IDLE_TIMEOUT) > 0:
             self._start_idle_checker()
 
-    @property
-    def uses_thread_data_mounts(self) -> bool:
-        """Whether thread workspace/uploads/outputs are visible via mounts.
-
-        Local container backends bind-mount the thread data directories, so files
-        written by the gateway are already visible when the sandbox starts.
-        Remote backends may require explicit file sync.
-        """
-        return isinstance(self._backend, LocalContainerBackend)
-
     # ── Factory methods ──────────────────────────────────────────────────
 
     def _create_backend(self) -> SandboxBackend:
@@ -160,7 +145,8 @@ class AioSandboxProvider(SandboxProvider):
 
     def _load_config(self) -> dict:
         """Load sandbox configuration from app config."""
-        sandbox_config = self._app_config.sandbox
+        config = get_app_config()
+        sandbox_config = config.sandbox
 
         idle_timeout = getattr(sandbox_config, "idle_timeout", None)
         replicas = getattr(sandbox_config, "replicas", None)
@@ -189,51 +175,6 @@ class AioSandboxProvider(SandboxProvider):
                 resolved[key] = str(value)
         return resolved
 
-    # ── Startup reconciliation ────────────────────────────────────────────
-
-    def _reconcile_orphans(self) -> None:
-        """Reconcile orphaned containers left by previous process lifecycles.
-
-        On startup, enumerate all running containers matching our prefix
-        and adopt them all into the warm pool.  The idle checker will reclaim
-        containers that nobody re-acquires within ``idle_timeout``.
-
-        All containers are adopted unconditionally because we cannot
-        distinguish "orphaned" from "actively used by another process"
-        based on age alone — ``idle_timeout`` represents inactivity, not
-        uptime.  Adopting into the warm pool and letting the idle checker
-        decide avoids destroying containers that a concurrent process may
-        still be using.
-
-        This closes the fundamental gap where in-memory state loss (process
-        restart, crash, SIGKILL) leaves Docker containers running forever.
-        """
-        try:
-            running = self._backend.list_running()
-        except Exception as e:
-            logger.warning(f"Failed to enumerate running containers during startup reconciliation: {e}")
-            return
-
-        if not running:
-            return
-
-        current_time = time.time()
-        adopted = 0
-
-        for info in running:
-            age = current_time - info.created_at if info.created_at > 0 else float("inf")
-            # Single lock acquisition per container: atomic check-and-insert.
-            # Avoids a TOCTOU window between the "already tracked?" check and
-            # the warm-pool insert.
-            with self._lock:
-                if info.sandbox_id in self._sandboxes or info.sandbox_id in self._warm_pool:
-                    continue
-                self._warm_pool[info.sandbox_id] = (info, current_time)
-            adopted += 1
-            logger.info(f"Adopted container {info.sandbox_id} into warm pool (age: {age:.0f}s)")
-
-        logger.info(f"Startup reconciliation complete: {adopted} adopted into warm pool, {len(running)} total found")
-
     # ── Deterministic ID ─────────────────────────────────────────────────
 
     @staticmethod
@@ -271,27 +212,28 @@ class AioSandboxProvider(SandboxProvider):
         mounted Docker socket (DooD), the host Docker daemon can resolve the paths.
         """
         paths = get_paths()
-        user_id = get_effective_user_id()
-        paths.ensure_thread_dirs(thread_id, user_id=user_id)
+        paths.ensure_thread_dirs(thread_id)
 
         return [
-            (paths.host_sandbox_work_dir(thread_id, user_id=user_id), f"{VIRTUAL_PATH_PREFIX}/workspace", False),
-            (paths.host_sandbox_uploads_dir(thread_id, user_id=user_id), f"{VIRTUAL_PATH_PREFIX}/uploads", False),
-            (paths.host_sandbox_outputs_dir(thread_id, user_id=user_id), f"{VIRTUAL_PATH_PREFIX}/outputs", False),
+            (paths.host_sandbox_work_dir(thread_id), f"{VIRTUAL_PATH_PREFIX}/workspace", False),
+            (paths.host_sandbox_uploads_dir(thread_id), f"{VIRTUAL_PATH_PREFIX}/uploads", False),
+            (paths.host_sandbox_outputs_dir(thread_id), f"{VIRTUAL_PATH_PREFIX}/outputs", False),
             # ACP workspace: read-only inside the sandbox (lead agent reads results;
             # the ACP subprocess writes from the host side, not from within the container).
-            (paths.host_acp_workspace_dir(thread_id, user_id=user_id), "/mnt/acp-workspace", True),
+            (paths.host_acp_workspace_dir(thread_id), "/mnt/acp-workspace", True),
         ]
 
-    def _get_skills_mount(self) -> tuple[str, str, bool] | None:
+    @staticmethod
+    def _get_skills_mount() -> tuple[str, str, bool] | None:
         """Get the skills directory mount configuration.
 
         Mount source uses DEER_FLOW_HOST_SKILLS_PATH when running inside Docker (DooD)
         so the host Docker daemon can resolve the path.
         """
         try:
-            skills_path = self._app_config.skills.get_skills_path()
-            container_path = self._app_config.skills.container_path
+            config = get_app_config()
+            skills_path = config.skills.get_skills_path()
+            container_path = config.skills.container_path
 
             if skills_path.exists():
                 # When running inside Docker with DooD, use host-side skills path.
@@ -374,23 +316,13 @@ class AioSandboxProvider(SandboxProvider):
     # ── Signal handling ──────────────────────────────────────────────────
 
     def _register_signal_handlers(self) -> None:
-        """Register signal handlers for graceful shutdown.
-
-        Handles SIGTERM, SIGINT, and SIGHUP (terminal close) to ensure
-        sandbox containers are cleaned up even when the user closes the terminal.
-        """
+        """Register signal handlers for graceful shutdown."""
         self._original_sigterm = signal.getsignal(signal.SIGTERM)
         self._original_sigint = signal.getsignal(signal.SIGINT)
-        self._original_sighup = signal.getsignal(signal.SIGHUP) if hasattr(signal, "SIGHUP") else None
 
         def signal_handler(signum, frame):
             self.shutdown()
-            if signum == signal.SIGTERM:
-                original = self._original_sigterm
-            elif hasattr(signal, "SIGHUP") and signum == signal.SIGHUP:
-                original = self._original_sighup
-            else:
-                original = self._original_sigint
+            original = self._original_sigterm if signum == signal.SIGTERM else self._original_sigint
             if callable(original):
                 original(signum, frame)
             elif original == signal.SIG_DFL:
@@ -400,8 +332,6 @@ class AioSandboxProvider(SandboxProvider):
         try:
             signal.signal(signal.SIGTERM, signal_handler)
             signal.signal(signal.SIGINT, signal_handler)
-            if hasattr(signal, "SIGHUP"):
-                signal.signal(signal.SIGHUP, signal_handler)
         except ValueError:
             logger.debug("Could not register signal handlers (not main thread)")
 
@@ -490,9 +420,8 @@ class AioSandboxProvider(SandboxProvider):
         across multiple processes, preventing container-name conflicts.
         """
         paths = get_paths()
-        user_id = get_effective_user_id()
-        paths.ensure_thread_dirs(thread_id, user_id=user_id)
-        lock_path = paths.thread_dir(thread_id, user_id=user_id) / f"{sandbox_id}.lock"
+        paths.ensure_thread_dirs(thread_id)
+        lock_path = paths.thread_dir(thread_id) / f"{sandbox_id}.lock"
 
         with open(lock_path, "a", encoding="utf-8") as lock_file:
             locked = False

backend/packages/harness/deerflow/community/aio_sandbox/backend.py

@@ -96,19 +96,3 @@ class SandboxBackend(ABC):
             SandboxInfo if found and healthy, None otherwise.
         """
         ...
-
-    def list_running(self) -> list[SandboxInfo]:
-        """Enumerate all running sandboxes managed by this backend.
-
-        Used for startup reconciliation: when the process restarts, it needs
-        to discover containers started by previous processes so they can be
-        adopted into the warm pool or destroyed if idle too long.
-
-        The default implementation returns an empty list, which is correct
-        for backends that don't manage local containers (e.g., RemoteSandboxBackend
-        delegates lifecycle to the provisioner which handles its own cleanup).
-
-        Returns:
-            A list of SandboxInfo for all currently running sandboxes.
-        """
-        return []

backend/packages/harness/deerflow/community/aio_sandbox/local_backend.py

@@ -6,11 +6,9 @@ Handles container lifecycle, port allocation, and cross-process container discov
 
 from __future__ import annotations
 
-import json
 import logging
 import os
 import subprocess
-from datetime import datetime
 
 from deerflow.utils.network import get_free_port, release_port
 
@@ -20,52 +18,6 @@ from .sandbox_info import SandboxInfo
 logger = logging.getLogger(__name__)
 
 
-def _parse_docker_timestamp(raw: str) -> float:
-    """Parse Docker's ISO 8601 timestamp into a Unix epoch float.
-
-    Docker returns timestamps with nanosecond precision and a trailing ``Z``
-    (e.g. ``2026-04-08T01:22:50.123456789Z``).  Python's ``fromisoformat``
-    accepts at most microseconds and (pre-3.11) does not accept ``Z``, so the
-    string is normalized before parsing.  Returns ``0.0`` on empty input or
-    parse failure so callers can use ``0.0`` as a sentinel for "unknown age".
-    """
-    if not raw:
-        return 0.0
-    try:
-        s = raw.strip()
-        if "." in s:
-            dot_pos = s.index(".")
-            tz_start = dot_pos + 1
-            while tz_start < len(s) and s[tz_start].isdigit():
-                tz_start += 1
-            frac = s[dot_pos + 1 : tz_start][:6]  # truncate to microseconds
-            tz_suffix = s[tz_start:]
-            s = s[: dot_pos + 1] + frac + tz_suffix
-        if s.endswith("Z"):
-            s = s[:-1] + "+00:00"
-        return datetime.fromisoformat(s).timestamp()
-    except (ValueError, TypeError) as e:
-        logger.debug(f"Could not parse docker timestamp {raw!r}: {e}")
-        return 0.0
-
-
-def _extract_host_port(inspect_entry: dict, container_port: int) -> int | None:
-    """Extract the host port mapped to ``container_port/tcp`` from a docker inspect entry.
-
-    Returns None if the container has no port mapping for that port.
-    """
-    try:
-        ports = (inspect_entry.get("NetworkSettings") or {}).get("Ports") or {}
-        bindings = ports.get(f"{container_port}/tcp") or []
-        if bindings:
-            host_port = bindings[0].get("HostPort")
-            if host_port:
-                return int(host_port)
-    except (ValueError, TypeError, AttributeError):
-        pass
-    return None
-
-
 def _format_container_mount(runtime: str, host_path: str, container_path: str, read_only: bool) -> list[str]:
     """Format a bind-mount argument for the selected runtime.
 
@@ -220,12 +172,8 @@ class LocalContainerBackend(SandboxBackend):
 
     def destroy(self, info: SandboxInfo) -> None:
         """Stop the container and release its port."""
-        # Prefer container_id, fall back to container_name (both accepted by docker stop).
-        # This ensures containers discovered via list_running() (which only has the name)
-        # can also be stopped.
-        stop_target = info.container_id or info.container_name
-        if stop_target:
-            self._stop_container(stop_target)
+        if info.container_id:
+            self._stop_container(info.container_id)
         # Extract port from sandbox_url for release
         try:
             from urllib.parse import urlparse
@@ -274,129 +222,6 @@ class LocalContainerBackend(SandboxBackend):
             container_name=container_name,
         )
 
-    def list_running(self) -> list[SandboxInfo]:
-        """Enumerate all running containers matching the configured prefix.
-
-        Uses a single ``docker ps`` call to list container names, then a
-        single batched ``docker inspect`` call to retrieve creation timestamp
-        and port mapping for all containers at once.  Total subprocess calls:
-        2 (down from 2N+1 in the naive per-container approach).
-
-        Note: Docker's ``--filter name=`` performs *substring* matching,
-        so a secondary ``startswith`` check is applied to ensure only
-        containers with the exact prefix are included.
-
-        Containers without port mappings are still included (with empty
-        sandbox_url) so that startup reconciliation can adopt orphans
-        regardless of their port state.
-        """
-        # Step 1: enumerate container names via docker ps
-        try:
-            result = subprocess.run(
-                [
-                    self._runtime,
-                    "ps",
-                    "--filter",
-                    f"name={self._container_prefix}-",
-                    "--format",
-                    "{{.Names}}",
-                ],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            if result.returncode != 0:
-                stderr = (result.stderr or "").strip()
-                logger.warning(
-                    "Failed to list running containers with %s ps (returncode=%s, stderr=%s)",
-                    self._runtime,
-                    result.returncode,
-                    stderr or "<empty>",
-                )
-                return []
-            if not result.stdout.strip():
-                return []
-        except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError, OSError) as e:
-            logger.warning(f"Failed to list running containers: {e}")
-            return []
-
-        # Filter to names matching our exact prefix (docker filter is substring-based)
-        container_names = [name.strip() for name in result.stdout.strip().splitlines() if name.strip().startswith(self._container_prefix + "-")]
-        if not container_names:
-            return []
-
-        # Step 2: batched docker inspect — single subprocess call for all containers
-        inspections = self._batch_inspect(container_names)
-
-        infos: list[SandboxInfo] = []
-        sandbox_host = os.environ.get("DEER_FLOW_SANDBOX_HOST", "localhost")
-        for container_name in container_names:
-            data = inspections.get(container_name)
-            if data is None:
-                # Container disappeared between ps and inspect, or inspect failed
-                continue
-            created_at, host_port = data
-            sandbox_id = container_name[len(self._container_prefix) + 1 :]
-            sandbox_url = f"http://{sandbox_host}:{host_port}" if host_port else ""
-
-            infos.append(
-                SandboxInfo(
-                    sandbox_id=sandbox_id,
-                    sandbox_url=sandbox_url,
-                    container_name=container_name,
-                    created_at=created_at,
-                )
-            )
-
-        logger.info(f"Found {len(infos)} running sandbox container(s)")
-        return infos
-
-    def _batch_inspect(self, container_names: list[str]) -> dict[str, tuple[float, int | None]]:
-        """Batch-inspect containers in a single subprocess call.
-
-        Returns a mapping of ``container_name -> (created_at, host_port)``.
-        Missing containers or parse failures are silently dropped from the result.
-        """
-        if not container_names:
-            return {}
-        try:
-            result = subprocess.run(
-                [self._runtime, "inspect", *container_names],
-                capture_output=True,
-                text=True,
-                timeout=15,
-            )
-        except (subprocess.CalledProcessError, subprocess.TimeoutExpired, FileNotFoundError, OSError) as e:
-            logger.warning(f"Failed to batch-inspect containers: {e}")
-            return {}
-
-        if result.returncode != 0:
-            stderr = (result.stderr or "").strip()
-            logger.warning(
-                "Failed to batch-inspect containers with %s inspect (returncode=%s, stderr=%s)",
-                self._runtime,
-                result.returncode,
-                stderr or "<empty>",
-            )
-            return {}
-
-        try:
-            payload = json.loads(result.stdout or "[]")
-        except json.JSONDecodeError as e:
-            logger.warning(f"Failed to parse docker inspect output as JSON: {e}")
-            return {}
-
-        out: dict[str, tuple[float, int | None]] = {}
-        for entry in payload:
-            # ``Name`` is prefixed with ``/`` in the docker inspect response
-            name = (entry.get("Name") or "").lstrip("/")
-            if not name:
-                continue
-            created_at = _parse_docker_timestamp(entry.get("Created", ""))
-            host_port = _extract_host_port(entry, 8080)
-            out[name] = (created_at, host_port)
-        return out
-
     # ── Container operations ─────────────────────────────────────────────
 
     def _start_container(

backend/packages/harness/deerflow/community/ddg_search/tools.py

@@ -5,9 +5,9 @@ Web Search Tool - Search the web using DuckDuckGo (no API key required).
 import json
 import logging
 
-from langchain.tools import ToolRuntime, tool
+from langchain.tools import tool
 
-from deerflow.config.deer_flow_context import resolve_context
+from deerflow.config import get_app_config
 
 logger = logging.getLogger(__name__)
 
@@ -55,7 +55,6 @@ def _search_text(
 @tool("web_search", parse_docstring=True)
 def web_search_tool(
     query: str,
-    runtime: ToolRuntime,
     max_results: int = 5,
 ) -> str:
     """Search the web for information. Use this tool to find current information, news, articles, and facts from the internet.
@@ -64,11 +63,11 @@ def web_search_tool(
         query: Search keywords describing what you want to find. Be specific for better results.
         max_results: Maximum number of results to return. Default is 5.
     """
-    tool_config = resolve_context(runtime).app_config.get_tool_config("web_search")
+    config = get_app_config().get_tool_config("web_search")
 
     # Override max_results from config if set
-    if tool_config is not None and "max_results" in tool_config.model_extra:
-        max_results = tool_config.model_extra.get("max_results", max_results)
+    if config is not None and "max_results" in config.model_extra:
+        max_results = config.model_extra.get("max_results", max_results)
 
     results = _search_text(
         query=query,

backend/packages/harness/deerflow/community/exa/tools.py

@@ -1,81 +0,0 @@
-import json
-
-from exa_py import Exa
-from langchain.tools import ToolRuntime, tool
-
-from deerflow.config.app_config import AppConfig
-from deerflow.config.deer_flow_context import resolve_context
-
-
-def _get_exa_client(app_config: AppConfig, tool_name: str = "web_search") -> Exa:
-    tool_config = app_config.get_tool_config(tool_name)
-    api_key = None
-    if tool_config is not None and "api_key" in tool_config.model_extra:
-        api_key = tool_config.model_extra.get("api_key")
-    return Exa(api_key=api_key)
-
-
-@tool("web_search", parse_docstring=True)
-def web_search_tool(query: str, runtime: ToolRuntime) -> str:
-    """Search the web.
-
-    Args:
-        query: The query to search for.
-    """
-    try:
-        app_config = resolve_context(runtime).app_config
-        tool_config = app_config.get_tool_config("web_search")
-        max_results = 5
-        search_type = "auto"
-        contents_max_characters = 1000
-        if tool_config is not None:
-            max_results = tool_config.model_extra.get("max_results", max_results)
-            search_type = tool_config.model_extra.get("search_type", search_type)
-            contents_max_characters = tool_config.model_extra.get("contents_max_characters", contents_max_characters)
-
-        client = _get_exa_client(app_config)
-        res = client.search(
-            query,
-            type=search_type,
-            num_results=max_results,
-            contents={"highlights": {"max_characters": contents_max_characters}},
-        )
-
-        normalized_results = [
-            {
-                "title": result.title or "",
-                "url": result.url or "",
-                "snippet": "\n".join(result.highlights) if result.highlights else "",
-            }
-            for result in res.results
-        ]
-        json_results = json.dumps(normalized_results, indent=2, ensure_ascii=False)
-        return json_results
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-
-@tool("web_fetch", parse_docstring=True)
-def web_fetch_tool(url: str, runtime: ToolRuntime) -> str:
-    """Fetch the contents of a web page at a given URL.
-    Only fetch EXACT URLs that have been provided directly by the user or have been returned in results from the web_search and web_fetch tools.
-    This tool can NOT access content that requires authentication, such as private Google Docs or pages behind login walls.
-    Do NOT add www. to URLs that do NOT have them.
-    URLs must include the schema: https://example.com is a valid URL while example.com is an invalid URL.
-
-    Args:
-        url: The URL to fetch the contents of.
-    """
-    try:
-        client = _get_exa_client(resolve_context(runtime).app_config, "web_fetch")
-        res = client.get_contents([url], text={"max_characters": 4096})
-
-        if res.results:
-            result = res.results[0]
-            title = result.title or "Untitled"
-            text = result.text or ""
-            return f"# {title}\n\n{text[:4096]}"
-        else:
-            return "Error: No results found"
-    except Exception as e:
-        return f"Error: {str(e)}"