@geminilight/mindos 0.5.10 → 0.5.12

package/README.md

@@ -156,8 +156,8 @@ Or skip the wizard and edit `~/.mindos/config.json` manually (see Config Referen
 ```json
 {
   "mindRoot": "~/MindOS",
-  "port": 3000,
-  "mcpPort": 8787,
+  "port": 3456,
+  "mcpPort": 8781,
   "authToken": "",
   "webPassword": "",
   "startMode": "daemon",
@@ -182,8 +182,8 @@ Or skip the wizard and edit `~/.mindos/config.json` manually (see Config Referen
 | Field | Default | Description |
 | :--- | :--- | :--- |
 | `mindRoot` | `~/MindOS` | **Required**. Absolute path to the knowledge base root. |
-| `port` | `3000` | Optional. Web app port. |
-| `mcpPort` | `8787` | Optional. MCP server port. |
+| `port` | `3456` | Optional. Web app port. |
+| `mcpPort` | `8781` | Optional. MCP server port. |
 | `authToken` | — | Optional. Protects App `/api/*` and MCP `/mcp` with bearer token auth. For Agent / MCP clients. Recommended when exposed to a network. |
 | `webPassword` | — | Optional. Protects the web UI with a login page. For browser access. Independent from `authToken`. |
 | `startMode` | `start` | Start mode: `daemon` (background service, auto-starts on boot), `start` (foreground), or `dev`. |
@@ -257,15 +257,15 @@ mindos mcp install -g -y
 Use `http` transport — MindOS must be running (`mindos start`) on the remote machine:
 
 ```bash
-mindos mcp install--transport http --url http://<server-ip>:8787/mcp --token your-token -g
+mindos mcp install--transport http --url http://<server-ip>:8781/mcp --token your-token -g
 ```
 
 > [!NOTE]
-> For remote access, ensure port `8787` is open in your firewall/security-group.
+> For remote access, ensure port `8781` is open in your firewall/security-group.
 
 > Add `-g` to install globally — MCP config is shared across all projects instead of the current directory only.
 
-> The MCP port defaults to `8787`. To use a different port, run `mindos onboard` and set `mcpPort`.
+> The MCP port defaults to `8781`. To use a different port, run `mindos onboard` and set `mcpPort`.
 
 <details>
 <summary>Manual config (JSON snippets)</summary>
@@ -291,7 +291,7 @@ mindos mcp install--transport http --url http://<server-ip>:8787/mcp --token you
 {
   "mcpServers": {
     "mindos": {
-      "url": "http://localhost:8787/mcp",
+      "url": "http://localhost:8781/mcp",
       "headers": { "Authorization": "Bearer your-token" }
     }
   }
@@ -304,7 +304,7 @@ mindos mcp install--transport http --url http://<server-ip>:8787/mcp --token you
 {
   "mcpServers": {
     "mindos": {
-      "url": "http://<server-ip>:8787/mcp",
+      "url": "http://<server-ip>:8781/mcp",
       "headers": { "Authorization": "Bearer your-token" }
     }
   }

package/README_zh.md

@@ -158,8 +158,8 @@ mindos onboard --install-daemon
 ```json
 {
   "mindRoot": "~/MindOS",
-  "port": 3000,
-  "mcpPort": 8787,
+  "port": 3456,
+  "mcpPort": 8781,
   "authToken": "",
   "webPassword": "",
   "startMode": "daemon",
@@ -184,8 +184,8 @@ mindos onboard --install-daemon
 | 字段 | 默认值 | 说明 |
 | :--- | :--- | :--- |
 | `mindRoot` | `~/MindOS` | **必填**。知识库根目录的绝对路径 |
-| `port` | `3000` | 可选。Web 服务端口 |
-| `mcpPort` | `8787` | 可选。MCP 服务端口 |
+| `port` | `3456` | 可选。Web 服务端口 |
+| `mcpPort` | `8781` | 可选。MCP 服务端口 |
 | `authToken` | — | 可选。保护 App `/api/*` 和 MCP `/mcp` 的 Bearer Token 认证。供 Agent / MCP 客户端使用，暴露到网络时建议设置 |
 | `webPassword` | — | 可选。为 Web UI 添加登录密码保护。供浏览器访问，与 `authToken` 相互独立 |
 | `startMode` | `start` | 启动模式：`daemon`（后台服务，开机自启）、`start`（前台）或 `dev` |
@@ -259,15 +259,15 @@ mindos mcp install -g -y
 使用 `http` transport — 远程机器上需先运行 `mindos start`：
 
 ```bash
-mindos mcp install --transport http --url http://<服务器IP>:8787/mcp --token your-token -g
+mindos mcp install --transport http --url http://<服务器IP>:8781/mcp --token your-token -g
 ```
 
 > [!NOTE]
-> 远程访问时，请确保端口 `8787` 已在防火墙/安全组中放行。
+> 远程访问时，请确保端口 `8781` 已在防火墙/安全组中放行。
 
 > 加 `-g` 表示全局安装 — MCP 配置写入用户级配置文件，所有项目共享，而非仅当前目录。
 
-> MCP 端口默认为 `8787`。如需修改，运行 `mindos onboard` 设置 `mcpPort`。
+> MCP 端口默认为 `8781`。如需修改，运行 `mindos onboard` 设置 `mcpPort`。
 
 <details>
 <summary>手动配置（JSON 片段）</summary>
@@ -293,7 +293,7 @@ mindos mcp install --transport http --url http://<服务器IP>:8787/mcp --token
 {
   "mcpServers": {
     "mindos": {
-      "url": "http://localhost:8787/mcp",
+      "url": "http://localhost:8781/mcp",
       "headers": { "Authorization": "Bearer your-token" }
     }
   }
@@ -306,7 +306,7 @@ mindos mcp install --transport http --url http://<服务器IP>:8787/mcp --token
 {
   "mcpServers": {
     "mindos": {
-      "url": "http://<服务器IP>:8787/mcp",
+      "url": "http://<服务器IP>:8781/mcp",
       "headers": { "Authorization": "Bearer your-token" }
     }
   }

package/app/README.md

@@ -20,7 +20,7 @@ MIND_ROOT=~/MindOS ANTHROPIC_API_KEY=sk-ant-... npm run dev
 # Or copy .env.local.example to app/.env.local and fill in values
 ```
 
-Open [http://localhost:3000](http://localhost:3000).
+Open [http://localhost:3456](http://localhost:3456).
 
 ## Features
 
@@ -47,7 +47,7 @@ Copy `.env.local.example` to `.env.local`:
 | Variable | Default | Description |
 |----------|---------|-------------|
 | `MIND_ROOT` | `./my-mind` | Path to your knowledge base directory |
-| `MINDOS_WEB_PORT` | `3000` | Dev/production server port |
+| `MINDOS_WEB_PORT` | `3456` | Dev/production server port |
 | `AI_PROVIDER` | `anthropic` | `anthropic` or `openai` |
 | `ANTHROPIC_API_KEY` | — | Required when `AI_PROVIDER=anthropic` |
 | `ANTHROPIC_MODEL` | `claude-sonnet-4-6` | Anthropic model ID |

package/app/app/api/ask/route.ts

@@ -5,6 +5,85 @@ import fs from 'fs';
 import path from 'path';
 import { getFileContent, getMindRoot } from '@/lib/fs';
 import { getModel, knowledgeBaseTools, truncate, AGENT_SYSTEM_PROMPT } from '@/lib/agent';
+import type { Message as FrontendMessage, ToolCallPart as FrontendToolCallPart } from '@/lib/types';
+
+/**
+ * Convert frontend Message[] (with parts containing tool calls + results)
+ * into AI SDK ModelMessage[] that streamText expects.
+ *
+ * Frontend format:
+ *   { role: 'assistant', content: '...', parts: [TextPart, ToolCallPart(with output/state)] }
+ *
+ * AI SDK format:
+ *   { role: 'assistant', content: [TextPart, ToolCallPart(no output)] }
+ *   { role: 'tool', content: [ToolResultPart] }  // one per completed tool call
+ */
+function convertToModelMessages(messages: FrontendMessage[]): ModelMessage[] {
+  const result: ModelMessage[] = [];
+
+  for (const msg of messages) {
+    if (msg.role === 'user') {
+      result.push({ role: 'user', content: msg.content });
+      continue;
+    }
+
+    // Skip error placeholder messages from frontend
+    if (msg.content.startsWith('__error__')) continue;
+
+    // Assistant message
+    if (!msg.parts || msg.parts.length === 0) {
+      // Plain text assistant message — no tool calls
+      if (msg.content) {
+        result.push({ role: 'assistant', content: msg.content });
+      }
+      continue;
+    }
+
+    // Build assistant message content array (text parts + tool call parts)
+    const assistantContent: Array<
+      { type: 'text'; text: string } |
+      { type: 'tool-call'; toolCallId: string; toolName: string; input: unknown }
+    > = [];
+    const completedToolCalls: FrontendToolCallPart[] = [];
+
+    for (const part of msg.parts) {
+      if (part.type === 'text') {
+        if (part.text) {
+          assistantContent.push({ type: 'text', text: part.text });
+        }
+      } else if (part.type === 'tool-call') {
+        assistantContent.push({
+          type: 'tool-call',
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          input: part.input,
+        });
+        if (part.state === 'done' || part.state === 'error') {
+          completedToolCalls.push(part);
+        }
+      }
+    }
+
+    if (assistantContent.length > 0) {
+      result.push({ role: 'assistant', content: assistantContent });
+    }
+
+    // Add tool result messages for completed tool calls
+    if (completedToolCalls.length > 0) {
+      result.push({
+        role: 'tool',
+        content: completedToolCalls.map(tc => ({
+          type: 'tool-result' as const,
+          toolCallId: tc.toolCallId,
+          toolName: tc.toolName,
+          output: { type: 'text' as const, value: tc.output ?? '' },
+        })),
+      });
+    }
+  }
+
+  return result;
+}
 
 function readKnowledgeFile(filePath: string): { ok: boolean; content: string; error?: string } {
   try {
@@ -33,7 +112,7 @@ function dirnameOf(filePath?: string): string | null {
 
 export async function POST(req: NextRequest) {
   let body: {
-    messages: ModelMessage[];
+    messages: FrontendMessage[];
     currentFile?: string;
     attachedFiles?: string[];
     uploadedFiles?: Array<{ name: string; content: string }>;
@@ -148,18 +227,62 @@ export async function POST(req: NextRequest) {
 
   try {
     const model = getModel();
+    const modelMessages = convertToModelMessages(messages);
+
+    // Phase 2: Step monitoring + loop detection
+    const stepHistory: Array<{ tool: string; input: string }> = [];
+    let loopDetected = false;
+    let loopCooldown = 0; // skip detection for N steps after warning
+
     const result = streamText({
       model,
       system: systemPrompt,
-      messages,
+      messages: modelMessages,
       tools: knowledgeBaseTools,
       stopWhen: stepCountIs(stepLimit),
+
+      onStepFinish: ({ toolCalls, usage }) => {
+        if (toolCalls) {
+          for (const tc of toolCalls) {
+            stepHistory.push({ tool: tc.toolName, input: JSON.stringify(tc.input) });
+          }
+        }
+        // Loop detection: same tool + same args 3 times in a row
+        // Skip detection during cooldown to avoid repeated warnings
+        if (loopCooldown > 0) {
+          loopCooldown--;
+        } else if (stepHistory.length >= 3) {
+          const last3 = stepHistory.slice(-3);
+          if (last3.every(s => s.tool === last3[0].tool && s.input === last3[0].input)) {
+            loopDetected = true;
+          }
+        }
+        console.log(`[ask] Step ${stepHistory.length}/${stepLimit}, tokens=${usage?.totalTokens ?? '?'}`);
+      },
+
+      prepareStep: ({ messages: stepMessages }) => {
+        if (loopDetected) {
+          loopDetected = false;
+          loopCooldown = 3; // suppress re-detection for 3 steps
+          return {
+            messages: [
+              ...stepMessages,
+              {
+                role: 'user' as const,
+                content: '[SYSTEM WARNING] You have called the same tool with identical arguments 3 times in a row. This appears to be a loop. Try a completely different approach or ask the user for clarification.',
+              },
+            ],
+          };
+        }
+        return {}; // no modification
+      },
+
       onError: ({ error }) => {
         console.error('[ask] Stream error:', error);
       },
     });
 
-    return result.toTextStreamResponse();
+    return result.toUIMessageStreamResponse();
   } catch (err) {
     console.error('[ask] Failed to initialize model:', err);
     return NextResponse.json(

package/app/app/api/mcp/install/route.ts

@@ -21,7 +21,7 @@ function buildEntry(transport: string, url?: string, token?: string) {
   if (transport === 'stdio') {
     return { type: 'stdio', command: 'mindos', args: ['mcp'], env: { MCP_TRANSPORT: 'stdio' } };
   }
-  const entry: Record<string, unknown> = { url: url || 'http://localhost:8787/mcp' };
+  const entry: Record<string, unknown> = { url: url || 'http://localhost:8781/mcp' };
   if (token) entry.headers = { Authorization: `Bearer ${token}` };
   return entry;
 }

package/app/app/api/mcp/status/route.ts

@@ -5,7 +5,7 @@ import { readSettings } from '@/lib/settings';
 export async function GET() {
   try {
     const settings = readSettings();
-    const port = settings.mcpPort ?? 8787;
+    const port = settings.mcpPort ?? 8781;
     const endpoint = `http://127.0.0.1:${port}/mcp`;
     const authConfigured = !!settings.authToken;
 

package/app/app/api/settings/route.ts

@@ -48,7 +48,7 @@ export async function GET() {
     mindRoot: settings.mindRoot,
     webPassword: settings.webPassword ? '***set***' : '',
     authToken: maskToken(settings.authToken),
-    mcpPort: settings.mcpPort ?? 8787,
+    mcpPort: settings.mcpPort ?? 8781,
     envOverrides: {
       AI_PROVIDER:       !!process.env.AI_PROVIDER,
       ANTHROPIC_API_KEY: !!process.env.ANTHROPIC_API_KEY,

package/app/app/api/settings/test-key/route.ts

@@ -0,0 +1,111 @@
+export const dynamic = 'force-dynamic';
+import { NextRequest, NextResponse } from 'next/server';
+import { effectiveAiConfig } from '@/lib/settings';
+
+const TIMEOUT = 10_000;
+
+type ErrorCode = 'auth_error' | 'model_not_found' | 'rate_limited' | 'network_error' | 'unknown';
+
+function classifyError(status: number, body: string): { code: ErrorCode; error: string } {
+  if (status === 401 || status === 403) return { code: 'auth_error', error: 'Invalid API key' };
+  if (status === 404) return { code: 'model_not_found', error: 'Model not found' };
+  if (status === 429) return { code: 'rate_limited', error: 'Rate limited' };
+  // Try to extract error message from response body
+  try {
+    const parsed = JSON.parse(body);
+    const msg = parsed?.error?.message || parsed?.error || '';
+    if (typeof msg === 'string' && msg.length > 0) return { code: 'unknown', error: msg.slice(0, 200) };
+  } catch { /* not JSON */ }
+  return { code: 'unknown', error: `HTTP ${status}` };
+}
+
+async function testAnthropic(apiKey: string, model: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
+  const start = Date.now();
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+  try {
+    const res = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+      signal: ctrl.signal,
+    });
+    const latency = Date.now() - start;
+    if (res.ok) return { ok: true, latency };
+    const body = await res.text();
+    return { ok: false, ...classifyError(res.status, body) };
+  } catch (e: unknown) {
+    if (e instanceof Error && e.name === 'AbortError') return { ok: false, code: 'network_error', error: 'Request timed out' };
+    return { ok: false, code: 'network_error', error: e instanceof Error ? e.message : 'Network error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function testOpenAI(apiKey: string, model: string, baseUrl: string): Promise<{ ok: boolean; latency?: number; code?: ErrorCode; error?: string }> {
+  const start = Date.now();
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+  const url = (baseUrl || 'https://api.openai.com/v1').replace(/\/+$/, '') + '/chat/completions';
+  try {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ model, max_tokens: 1, messages: [{ role: 'user', content: 'hi' }] }),
+      signal: ctrl.signal,
+    });
+    const latency = Date.now() - start;
+    if (res.ok) return { ok: true, latency };
+    const body = await res.text();
+    return { ok: false, ...classifyError(res.status, body) };
+  } catch (e: unknown) {
+    if (e instanceof Error && e.name === 'AbortError') return { ok: false, code: 'network_error', error: 'Request timed out' };
+    return { ok: false, code: 'network_error', error: e instanceof Error ? e.message : 'Network error' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { provider, apiKey, model, baseUrl } = body as {
+      provider?: string;
+      apiKey?: string;
+      model?: string;
+      baseUrl?: string;
+    };
+
+    if (provider !== 'anthropic' && provider !== 'openai') {
+      return NextResponse.json({ ok: false, code: 'unknown', error: 'Invalid provider' }, { status: 400 });
+    }
+
+    // Resolve actual API key: use provided key, fallback to config/env for masked or missing
+    const cfg = effectiveAiConfig();
+    let resolvedKey = apiKey || '';
+    if (!resolvedKey || resolvedKey === '***set***') {
+      resolvedKey = provider === 'anthropic' ? cfg.anthropicApiKey : cfg.openaiApiKey;
+    }
+
+    if (!resolvedKey) {
+      return NextResponse.json({ ok: false, code: 'auth_error', error: 'No API key configured' });
+    }
+
+    const resolvedModel = model || (provider === 'anthropic' ? cfg.anthropicModel : cfg.openaiModel);
+
+    const result = provider === 'anthropic'
+      ? await testAnthropic(resolvedKey, resolvedModel)
+      : await testOpenAI(resolvedKey, resolvedModel, baseUrl || cfg.openaiBaseUrl);
+
+    return NextResponse.json(result);
+  } catch (err) {
+    return NextResponse.json({ ok: false, code: 'unknown', error: String(err) }, { status: 500 });
+  }
+}

package/app/app/api/setup/route.ts

@@ -20,8 +20,8 @@ export async function GET() {
       mindRoot: defaultMindRoot,
       homeDir: home,
       platform: process.platform,
-      port: s.port ?? 3000,
-      mcpPort: s.mcpPort ?? 8787,
+      port: s.port ?? 3456,
+      mcpPort: s.mcpPort ?? 8781,
       authToken: s.authToken ?? '',
       webPassword: s.webPassword ?? '',
       provider: s.ai.provider,
@@ -58,8 +58,8 @@ export async function POST(req: NextRequest) {
     const resolvedRoot = expandHome(mindRoot.trim());
 
     // Validate ports
-    const webPort = typeof port === 'number' ? port : 3000;
-    const mcpPortNum = typeof mcpPort === 'number' ? mcpPort : 8787;
+    const webPort = typeof port === 'number' ? port : 3456;
+    const mcpPortNum = typeof mcpPort === 'number' ? mcpPort : 8781;
     if (webPort < 1024 || webPort > 65535) {
       return NextResponse.json({ error: `Invalid web port: ${webPort}` }, { status: 400 });
     }
@@ -78,7 +78,7 @@ export async function POST(req: NextRequest) {
 
     // Read current running port for portChanged detection
     const current = readSettings();
-    const currentPort = current.port ?? 3000;
+    const currentPort = current.port ?? 3456;
 
     // Use the same resolved values that will actually be written to config
     const resolvedAuthToken   = authToken   ?? current.authToken   ?? '';
@@ -87,8 +87,8 @@ export async function POST(req: NextRequest) {
     // Re-onboard only needs restart if port/path/auth/password actually changed.
     const isFirstTime = current.setupPending === true || !current.mindRoot;
     const needsRestart = isFirstTime || (
-      webPort              !== (current.port      ?? 3000) ||
-      mcpPortNum           !== (current.mcpPort   ?? 8787) ||
+      webPort              !== (current.port      ?? 3456) ||
+      mcpPortNum           !== (current.mcpPort   ?? 8781) ||
       resolvedRoot         !== (current.mindRoot  || '')    ||
       resolvedAuthToken    !== (current.authToken   ?? '') ||
       resolvedWebPassword  !== (current.webPassword ?? '')

package/app/app/api/sync/route.ts

@@ -1,6 +1,6 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
-import { execSync, execFile } from 'child_process';
+import { execSync, exec } from 'child_process';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { homedir } from 'os';
@@ -37,6 +37,24 @@ function isGitRepo(dir: string) {
   return existsSync(join(dir, '.git'));
 }
 
+/** Resolve path to bin/cli.js at runtime. */
+function getCliPath() {
+  return resolve(process.cwd(), '..', 'bin', 'cli' + '.js');
+}
+
+/** Run CLI command via shell string — avoids Turbopack static analysis of file paths */
+function runCli(args: string[], timeoutMs = 30000): Promise<void> {
+  const cliPath = getCliPath();
+  const escaped = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+  const cmd = `${process.execPath} ${cliPath} ${escaped}`;
+  return new Promise((res, rej) => {
+    exec(cmd, { timeout: timeoutMs }, (err, _stdout, stderr) => {
+      if (err) rej(new Error(stderr?.trim() || err.message));
+      else res();
+    });
+  });
+}
+
 export async function GET() {
   const config = loadConfig();
   const syncConfig = config.sync || {};
@@ -95,32 +113,13 @@ export async function POST(req: NextRequest) {
           return NextResponse.json({ error: 'Sync already configured' }, { status: 400 });
         }
 
-        // Build the effective remote URL (inject token for HTTPS)
-        let effectiveRemote = remote;
-        if (isHTTPS && body.token) {
-          try {
-            const urlObj = new URL(remote);
-            urlObj.username = 'oauth2';
-            urlObj.password = body.token;
-            effectiveRemote = urlObj.toString();
-          } catch {
-            return NextResponse.json({ error: 'Invalid remote URL' }, { status: 400 });
-          }
-        }
-
         const branch = body.branch?.trim() || 'main';
 
-        // Call CLI's sync init via execFile (avoids module resolution issues with Turbopack)
+        // Call CLI's sync init — pass clean remote + token separately (never embed token in URL)
         try {
-          const cliPath = resolve(process.cwd(), '..', 'bin', 'cli.js');
-          const args = ['sync', 'init', '--non-interactive', '--remote', effectiveRemote, '--branch', branch];
-
-          await new Promise<void>((res, rej) => {
-            execFile('node', [cliPath, ...args], { timeout: 30000 }, (err, stdout, stderr) => {
-              if (err) rej(new Error(stderr?.trim() || err.message));
-              else res();
-            });
-          });
+          const args = ['sync', 'init', '--non-interactive', '--remote', remote, '--branch', branch];
+          if (body.token) args.push('--token', body.token);
+          await runCli(args, 30000);
           return NextResponse.json({ success: true, message: 'Sync initialized' });
         } catch (err: unknown) {
           const errMsg = err instanceof Error ? err.message : String(err);
@@ -132,23 +131,14 @@ export async function POST(req: NextRequest) {
         if (!isGitRepo(mindRoot)) {
           return NextResponse.json({ error: 'Not a git repository' }, { status: 400 });
         }
-        // Pull
-        try { execSync('git pull --rebase --autostash', { cwd: mindRoot, stdio: 'pipe' }); } catch {
-          try { execSync('git rebase --abort', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-          try { execSync('git pull --no-rebase', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-        }
-        // Commit + push
-        execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
-        const status = execSync('git status --porcelain', { cwd: mindRoot, encoding: 'utf-8' }).trim();
-        if (status) {
-          const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
-          execSync(`git commit -m "auto-sync: ${timestamp}"`, { cwd: mindRoot, stdio: 'pipe' });
-          execSync('git push', { cwd: mindRoot, stdio: 'pipe' });
+        // Delegate to CLI for unified conflict handling
+        try {
+          await runCli(['sync', 'now'], 60000);
+          return NextResponse.json({ ok: true });
+        } catch (err: unknown) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          return NextResponse.json({ error: errMsg }, { status: 500 });
         }
-        const state = loadSyncState();
-        state.lastSync = new Date().toISOString();
-        writeFileSync(SYNC_STATE_PATH, JSON.stringify(state, null, 2) + '\n');
-        return NextResponse.json({ ok: true });
       }
 
       case 'on': {

package/app/components/AskModal.tsx

@@ -11,6 +11,7 @@ import MessageList from '@/components/ask/MessageList';
 import MentionPopover from '@/components/ask/MentionPopover';
 import SessionHistory from '@/components/ask/SessionHistory';
 import FileChip from '@/components/ask/FileChip';
+import { consumeUIMessageStream } from '@/lib/agent/stream-consumer';
 
 interface AskModalProps {
   open: boolean;
@@ -151,25 +152,22 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
 
       if (!res.body) throw new Error('No response body');
 
-      const reader = res.body.getReader();
-      const decoder = new TextDecoder();
-      let assistantContent = '';
       setLoadingPhase('thinking');
 
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        const chunk = decoder.decode(value, { stream: true });
-        if (chunk) setLoadingPhase('streaming');
-        assistantContent += chunk;
-        session.setMessages(prev => {
-          const updated = [...prev];
-          updated[updated.length - 1] = { role: 'assistant', content: assistantContent };
-          return updated;
-        });
-      }
+      const finalMessage = await consumeUIMessageStream(
+        res.body,
+        (msg) => {
+          setLoadingPhase('streaming');
+          session.setMessages(prev => {
+            const updated = [...prev];
+            updated[updated.length - 1] = msg;
+            return updated;
+          });
+        },
+        controller.signal,
+      );
 
-      if (!assistantContent.trim()) {
+      if (!finalMessage.content.trim() && (!finalMessage.parts || finalMessage.parts.length === 0)) {
         session.setMessages(prev => {
           const updated = [...prev];
           updated[updated.length - 1] = { role: 'assistant', content: `__error__${t.ask.errorNoResponse}` };
@@ -181,8 +179,12 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
         session.setMessages(prev => {
           const updated = [...prev];
           const lastIdx = updated.length - 1;
-          if (lastIdx >= 0 && updated[lastIdx].role === 'assistant' && !updated[lastIdx].content.trim()) {
-            updated[lastIdx] = { role: 'assistant', content: `__error__${t.ask.stopped}` };
+          if (lastIdx >= 0 && updated[lastIdx].role === 'assistant') {
+            const last = updated[lastIdx];
+            const hasContent = last.content.trim() || (last.parts && last.parts.length > 0);
+            if (!hasContent) {
+              updated[lastIdx] = { role: 'assistant', content: `__error__${t.ask.stopped}` };
+            }
           }
           return updated;
         });
@@ -191,9 +193,13 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
         session.setMessages(prev => {
           const updated = [...prev];
           const lastIdx = updated.length - 1;
-          if (lastIdx >= 0 && updated[lastIdx].role === 'assistant' && !updated[lastIdx].content.trim()) {
-            updated[lastIdx] = { role: 'assistant', content: `__error__${errMsg}` };
-            return updated;
+          if (lastIdx >= 0 && updated[lastIdx].role === 'assistant') {
+            const last = updated[lastIdx];
+            const hasContent = last.content.trim() || (last.parts && last.parts.length > 0);
+            if (!hasContent) {
+              updated[lastIdx] = { role: 'assistant', content: `__error__${errMsg}` };
+              return updated;
+            }
           }
           return [...updated, { role: 'assistant', content: `__error__${errMsg}` }];
         });
@@ -281,6 +287,7 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
           emptyPrompt={t.ask.emptyPrompt}
           suggestions={t.ask.suggestions}
           onSuggestionClick={setInput}
+          maxSteps={maxSteps}
           labels={{ connecting: t.ask.connecting, thinking: t.ask.thinking, generating: t.ask.generating }}
         />