codemini-cli 0.1.13 → 0.1.14

package/README.md

@@ -23,6 +23,10 @@ It is designed for teams that want a coding assistant that feels practical, cont
 - Windows-aware shell profile with PowerShell-focused defaults
 - Safe mode enabled by default
 - Built-in lite skills for planning, execution, and collaboration
+- Configurable reply language through `ui.reply_language` (`zh` / `en`)
+- Richer slash completion with priority sorting, inline descriptions, and left/right paging
+- Structured code tools for small models: `locate`, `open_target`, `edit_target`
+- More conservative `plan auto` acceptance checks with reviewer/tester goal checklists
 - Tone presets through `soul`, without changing plans or code behavior
 - Sub-agents for planning, coding, review, and testing
 
@@ -32,6 +36,7 @@ It is designed for teams that want a coding assistant that feels practical, cont
 codemini config set gateway.base_url http://your-internal-gateway/v1
 codemini config set gateway.api_key your_token
 codemini config set shell.default powershell
+codemini config set ui.reply_language zh
 codemini config set model.name your-30b-model
 codemini doctor
 codemini
@@ -54,6 +59,30 @@ codemini doctor
 codemini skill list|install|enable|disable|inspect|reindex
 ```
 
+### Notable Workflow Features
+
+- `ui.reply_language` controls the assistant reply language at the prompt layer and also nudges generated docs and code comments to match
+- Slash completion now prioritizes important commands and config keys, shows short descriptions, and supports `←/→` page switching
+- `plan auto` now turns the original goal into an acceptance checklist, uses a lighter chain only for truly tiny tasks, and treats unmet checklist items as failure signals
+- Structured code tools reduce shell-noise for small models by preferring `locate -> open_target -> edit_target`
+
+### Skill Loading
+
+CodeMini CLI loads skills from these locations:
+
+- Bundled repo skills: `skills/<name>/SKILL.md`
+- Installed global skills: `<base-config-dir>/skills/<name>/SKILL.md`
+- Project-scoped legacy skills: `.coder/skills/<name>/SKILL.md`
+
+The base config directory is resolved in this order:
+
+- `CODEMINI_CONFIG_DIR`
+- `COMPANY_CODER_CONFIG_DIR`
+- Windows: `%APPDATA%\\codemini-cli\\`
+- macOS: `~/Library/Preferences/codemini-cli`
+- Linux/XDG: `$XDG_CONFIG_HOME/codemini-cli`
+- Fallback in restricted environments: `.codemini-cli/`
+
 ### Documentation
 
 - Operator guide and common command patterns: [OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
@@ -95,6 +124,10 @@ CodeMini CLI 是一个为小模型工作流优化过的代码助手 CLI，重点
 - 面向 Windows 的 PowerShell 默认配置
 - safe mode 默认开启
 - 内置 lite skills，覆盖规划、执行和协作
+- 支持通过 `ui.reply_language` 配置回复语言，当前支持 `zh` / `en`
+- slash 补全支持优先级排序、右侧简短说明和左右分页
+- 为小模型补了结构化代码工具：`locate`、`open_target`、`edit_target`
+- `plan auto` 会基于原始目标生成验收清单，并更保守地处理 reviewer/tester 结果
 - `soul` 只影响语气，不影响计划和代码行为
 - 支持 planner、coder、reviewer、tester 多角色 sub-agent
 
@@ -104,6 +137,7 @@ CodeMini CLI 是一个为小模型工作流优化过的代码助手 CLI，重点
 codemini config set gateway.base_url http://your-internal-gateway/v1
 codemini config set gateway.api_key your_token
 codemini config set shell.default powershell
+codemini config set ui.reply_language zh
 codemini config set model.name your-30b-model
 codemini doctor
 codemini
@@ -126,6 +160,30 @@ codemini doctor
 codemini skill list|install|enable|disable|inspect|reindex
 ```
 
+### 近期工作流增强
+
+- `ui.reply_language` 通过 prompt 层控制模型回复语言，也会尽量让生成文档和代码注释跟随该语言
+- slash 补全会优先展示更重要的命令和配置项，显示简短说明，并支持 `←/→` 翻页
+- `plan auto` 会先把原始目标展开成验收清单；只有真正很小的任务才会走轻量链路；如果 reviewer 或 tester 标记了未满足或未验证的验收项，就不会按成功处理
+- 为了减少小模型被 shell 原始输出干扰，新增了 `locate -> open_target -> edit_target` 这套结构化代码工具流
+
+### Skill 加载位置
+
+CodeMini CLI 会从这些位置读取 skill：
+
+- 仓库内置 skill：`skills/<name>/SKILL.md`
+- 全局已安装 skill：`<base-config-dir>/skills/<name>/SKILL.md`
+- 项目级旧式 skill：`.coder/skills/<name>/SKILL.md`
+
+`base-config-dir` 的解析顺序是：
+
+- `CODEMINI_CONFIG_DIR`
+- `COMPANY_CODER_CONFIG_DIR`
+- Windows：`%APPDATA%\\codemini-cli\\`
+- macOS：`~/Library/Preferences/codemini-cli`
+- Linux / XDG：`$XDG_CONFIG_HOME/codemini-cli`
+- 受限环境回退：`.codemini-cli/`
+
 ### 文档入口
 
 - 操作手册与常见命令组合：[OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemini-cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "Coding CLI optimized for small-model workflows and Windows PowerShell",
   "keywords": [
     "cli",

package/src/core/agent-loop.js

@@ -61,6 +61,24 @@ function summarizeToolResult(result) {
       if (stderr) return `${lead}exit ${obj.code ?? 0}\nstderr: ${stderr}`;
       return `${lead}exit ${obj.code ?? 0}`;
     }
+    if ('task_id' in obj && 'startup_confirmed' in obj) {
+      const status = trimInline(obj.status || 'unknown', 32);
+      const taskId = trimInline(obj.task_id || '', 24);
+      const source = trimInline(obj.startup_source || '', 24);
+      const logs = Array.isArray(obj.recent_logs) ? trimInline(obj.recent_logs.slice(-1)[0] || '', 96) : '';
+      return `${taskId || 'service'} ${status}${source ? ` (${source})` : ''}${logs ? `\n${logs}` : ''}`;
+    }
+    if ('services' in obj && Array.isArray(obj.services)) {
+      const count = obj.services.length;
+      const first = obj.services[0];
+      const lead = first?.task_id ? `${trimInline(first.task_id, 24)} ${trimInline(first.status || 'unknown', 24)}` : '';
+      return `services(${count})${lead ? `\n${lead}` : ''}`;
+    }
+    if ('task_id' in obj && 'recent_logs' in obj) {
+      const taskId = trimInline(obj.task_id || '', 24);
+      const logs = Array.isArray(obj.recent_logs) ? trimInline(obj.recent_logs.slice(-1)[0] || '', 96) : '';
+      return `${taskId || 'service logs'}${logs ? `\n${logs}` : ''}`;
+    }
     if ('created' in obj && Array.isArray(obj.created)) {
       return `created ${obj.created.length} task(s)`;
     }
@@ -96,6 +114,17 @@ function formatToolDisplayName(name, args) {
     const command = trimInline(args?.command || '', 96);
     return command ? `${name}(${command})` : name;
   }
+  if (name === 'start_service') {
+    const command = trimInline(args?.command || args?.cmd || '', 96);
+    return command ? `${name}(${command})` : name;
+  }
+  if (name === 'list_services') {
+    return name;
+  }
+  if (name === 'get_service_status' || name === 'get_service_logs' || name === 'stop_service') {
+    const taskId = trimInline(args?.task_id || args?.taskId || '', 96);
+    return taskId ? `${name}(${taskId})` : name;
+  }
   if (
     name === 'locate' ||
     name === 'open_target' ||

package/src/core/config-store.js

@@ -46,6 +46,11 @@ const DEFAULT_CONFIG = {
       'insert_before',
       'insert_after',
       'generate_diff',
+      'start_service',
+      'list_services',
+      'get_service_status',
+      'get_service_logs',
+      'stop_service',
       'run_command',
       'read_file',
       'write_file'
@@ -141,6 +146,11 @@ function normalizePolicyLists(config) {
       'insert_before',
       'insert_after',
       'generate_diff',
+      'start_service',
+      'list_services',
+      'get_service_status',
+      'get_service_logs',
+      'stop_service',
       'run_command',
       'read_file',
       'write_file',

package/src/core/shell-profile.js

@@ -118,5 +118,5 @@ export function getEffectivePolicy(config) {
 
 export function getShellSystemPrompt(value) {
   const profile = getShellProfile(value);
-  return `You are CodeMini CLI working in a ${profile.label} shell environment. Prefer the high-level structured workflow first: use locate to find candidates, open_target to inspect the smallest useful block and receive edit metadata, and edit_target to apply minimal edits. When you need lower-level control, use search_code, read_block, read_symbol_context, validate_edit, replace_block, replace_text, insert_before, insert_after, and generate_diff. Use run_command only when those structured tools are not enough. Use read_file only when structured reads are not enough. Use write_file only for full-file writes and always provide a concrete file path, not a directory. Avoid unnecessary tool calls.`;
+  return `You are CodeMini CLI working in a ${profile.label} shell environment. Prefer the high-level structured workflow first: use locate to find candidates, open_target to inspect the smallest useful block and receive edit metadata, and edit_target to apply minimal edits. When you need lower-level control, use search_code, read_block, read_symbol_context, validate_edit, replace_block, replace_text, insert_before, insert_after, and generate_diff. Use start_service, list_services, get_service_status, get_service_logs, and stop_service for long-running servers or watchers. Use run_command only for one-shot commands that should exit on their own. Use read_file only when structured reads are not enough. Use write_file only for full-file writes and always provide a concrete file path, not a directory. Avoid unnecessary tool calls.`;
 }

package/src/core/shell.js

@@ -1,6 +1,79 @@
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 
-function resolveShell(defaultShell) {
+const LONG_RUNNING_COMMAND_RE =
+  /\b(npm\s+(?:run\s+)?(?:start|dev)\b|pnpm\s+(?:run\s+)?(?:start|dev)\b|yarn\s+(?:start|dev)\b|vite\b|next\s+dev\b|webpack\s+serve\b|python\s+-m\s+http\.server\b|serve\b|java\s+-jar\b|mvn(?:w)?\s+spring-boot:run\b|gradle(?:w)?\s+bootRun\b|gradle(?:w)?\s+run\b|java\b.*\bserver\b|dotnet\s+run\b|go\s+run\b.*\b(server|cmd\/server|main\.go)\b|air\b|cargo\s+run\b.*\b(server|api|web)\b|cargo\s+watch\s+-x\s+run\b)/i;
+const GENERIC_LONG_RUNNING_HINT_RE = /\b(start|serve|server|dev|preview|watch)\b/i;
+const READY_OUTPUT_PATTERNS = [
+  /\bready\b/i,
+  /\bcompiled successfully\b/i,
+  /\blocal:\s*https?:\/\//i,
+  /\blistening on\b/i,
+  /\bserver running\b/i,
+  /\brunning at\b/i,
+  /\bserving at\b/i,
+  /\bstarted\b.*\bin\b/i,
+  /\bstarted\s+[A-Za-z0-9_$.-]+\s+in\b/i,
+  /\btomcat started on port\(s\):/i,
+  /\bnetty started on port/i,
+  /\bnow listening on:\s*https?:\/\//i,
+  /\bapplication started\./i,
+  /\bserving http on\b/i,
+  /\bstarting development server at\b/i,
+  /\bactix web server running on\b/i,
+  /\bhttp:\/\/127\.0\.0\.1\b/i,
+  /\bhttp:\/\/localhost\b/i
+];
+const AUTO_STOP_GRACE_MS = 150;
+const LONG_RUNNING_STARTUP_WINDOW_MS = 1500;
+
+export function isLikelyLongRunningCommand(command) {
+  const value = String(command || '');
+  return LONG_RUNNING_COMMAND_RE.test(value) || GENERIC_LONG_RUNNING_HINT_RE.test(value);
+}
+
+export function hasReadyOutput(text) {
+  const value = String(text || '');
+  return READY_OUTPUT_PATTERNS.some((pattern) => pattern.test(value));
+}
+
+function collectDescendantPids(rootPid, seen = new Set()) {
+  const pid = Number(rootPid);
+  if (!Number.isInteger(pid) || pid <= 0 || seen.has(pid) || process.platform === 'win32') {
+    return [];
+  }
+  seen.add(pid);
+  const result = spawnSync('ps', ['-o', 'pid=', '--ppid', String(pid)], { encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout) return [];
+  const directChildren = result.stdout
+    .split('\n')
+    .map((value) => Number(String(value || '').trim()))
+    .filter((value) => Number.isInteger(value) && value > 0);
+  const descendants = [];
+  for (const childPid of directChildren) {
+    if (seen.has(childPid)) continue;
+    descendants.push(childPid);
+    descendants.push(...collectDescendantPids(childPid, seen));
+  }
+  return descendants;
+}
+
+export function terminateChild(child, signal = 'SIGTERM') {
+  if (!child) return;
+  const pid = Number(child.pid);
+  if (process.platform !== 'win32' && Number.isInteger(pid) && pid > 0) {
+    const descendants = collectDescendantPids(pid);
+    for (const targetPid of descendants.reverse()) {
+      try {
+        process.kill(targetPid, signal);
+      } catch {}
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {}
+}
+
+export function resolveShell(defaultShell) {
   if (process.platform === 'win32') {
     if (defaultShell === 'cmd') {
       return { command: 'cmd.exe', args: ['/d', '/s', '/c'] };
@@ -30,9 +103,13 @@ export function runShellCommand({
   timeoutMs = 120000
 }) {
   const shellSpec = resolveShell(shell);
+  const shellCommand =
+    process.platform !== 'win32' && /(?:^|\/)bash(?:\.exe)?$/i.test(shellSpec.command)
+      ? `exec ${command}`
+      : command;
 
   return new Promise((resolve, reject) => {
-    const child = spawn(shellSpec.command, [...shellSpec.args, command], {
+    const child = spawn(shellSpec.command, [...shellSpec.args, shellCommand], {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe']
     });
@@ -40,32 +117,81 @@ export function runShellCommand({
     let stdout = '';
     let stderr = '';
     let timedOut = false;
+    let autoStopped = false;
+    let stopReason = '';
+    let finalized = false;
+    const longRunningCommand = isLikelyLongRunningCommand(command);
+    const autoStopWindowMs = longRunningCommand
+      ? Math.min(LONG_RUNNING_STARTUP_WINDOW_MS, Math.max(350, Math.floor(timeoutMs * 0.6)))
+      : 0;
+
+    const finalizeResolve = (value) => {
+      if (finalized) return;
+      finalized = true;
+      clearTimeout(timer);
+      if (autoStopTimer) clearTimeout(autoStopTimer);
+      resolve(value);
+    };
+
+    const finalizeReject = (error) => {
+      if (finalized) return;
+      finalized = true;
+      clearTimeout(timer);
+      if (autoStopTimer) clearTimeout(autoStopTimer);
+      reject(error);
+    };
 
     const timer = setTimeout(() => {
       timedOut = true;
-      child.kill('SIGTERM');
+      terminateChild(child, 'SIGTERM');
     }, timeoutMs);
+    const autoStopTimer =
+      autoStopWindowMs > 0
+        ? setTimeout(() => {
+            finalizeAutoStop('startup_window');
+          }, autoStopWindowMs)
+        : null;
+
+    const finalizeAutoStop = (reason) => {
+      if (timedOut || autoStopped || finalized) return;
+      autoStopped = true;
+      stopReason = reason;
+      terminateChild(child, 'SIGTERM');
+      setTimeout(() => {
+        terminateChild(child, 'SIGKILL');
+      }, AUTO_STOP_GRACE_MS);
+      finalizeResolve({ code: 0, stdout, stderr, auto_stopped: true, stop_reason: stopReason });
+    };
 
     child.stdout.on('data', (chunk) => {
       stdout += chunk.toString();
+      if (longRunningCommand && hasReadyOutput(stdout)) {
+        finalizeAutoStop('ready_output');
+      }
     });
 
     child.stderr.on('data', (chunk) => {
       stderr += chunk.toString();
+      if (longRunningCommand && hasReadyOutput(stderr)) {
+        finalizeAutoStop('ready_output');
+      }
     });
 
     child.on('error', (err) => {
-      clearTimeout(timer);
-      reject(err);
+      finalizeReject(err);
     });
 
     child.on('close', (code) => {
-      clearTimeout(timer);
+      if (finalized) return;
       if (timedOut) {
-        reject(new Error(`Command timed out after ${timeoutMs}ms`));
+        finalizeReject(new Error(`Command timed out after ${timeoutMs}ms`));
+        return;
+      }
+      if (autoStopped) {
+        finalizeResolve({ code: 0, stdout, stderr, auto_stopped: true, stop_reason: stopReason });
         return;
       }
-      resolve({ code, stdout, stderr });
+      finalizeResolve({ code, stdout, stderr });
     });
   });
 }

package/src/core/tools.js

@@ -1,7 +1,16 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { isDangerousCommand, runShellCommand } from './shell.js';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
+import {
+  hasReadyOutput,
+  isDangerousCommand,
+  isLikelyLongRunningCommand,
+  resolveShell,
+  runShellCommand,
+  terminateChild
+} from './shell.js';
 import { evaluateCommandPolicy } from './command-policy.js';
 
 const SKIP_DIRS = new Set(['.git', 'node_modules', '.coder', '.codemini-cli', 'dist', 'coverage']);
@@ -46,6 +55,11 @@ const LANGUAGE_FILE_TYPES = {
   shell: ['sh', 'ps1'],
   yaml: ['yml', 'yaml']
 };
+const SERVICE_RECENT_LOG_LIMIT = 80;
+const SERVICE_STARTUP_POLL_MS = 150;
+const serviceRegistry = new Map();
+let serviceCounter = 0;
+let serviceLogCursorCounter = 0;
 
 function resolveInWorkspace(root, targetPath = '.') {
   const absRoot = path.resolve(root);
@@ -509,6 +523,9 @@ async function runCommand(root, config, args) {
   if (!command.trim()) {
     throw new Error('run_command requires command');
   }
+  if (isLikelyLongRunningCommand(command)) {
+    throw new Error('Command looks like a long-running service. Use start_service instead of run_command.');
+  }
   if (
     !config.policy.allow_dangerous_commands &&
     isDangerousCommand(command, config.policy.blocked_command_patterns)
@@ -532,6 +549,300 @@ async function runCommand(root, config, args) {
   return { ...result, command };
 }
 
+function nextServiceId() {
+  serviceCounter += 1;
+  return `svc_${String(serviceCounter).padStart(3, '0')}`;
+}
+
+function normalizeSuccessMatchers(items = []) {
+  if (!Array.isArray(items)) return [];
+  return items.map((item) => String(item || '').trim()).filter(Boolean);
+}
+
+function shellCommandForService(command, shellSpec) {
+  return process.platform !== 'win32' && /(?:^|\/)bash(?:\.exe)?$/i.test(shellSpec.command)
+    ? `exec ${command}`
+    : command;
+}
+
+function appendRecentLogs(service, chunk) {
+  const lines = String(chunk || '')
+    .split(/\r?\n/)
+    .map((line) => trimLinePreview(line, 220))
+    .filter(Boolean);
+  if (lines.length === 0) return;
+  for (const line of lines) {
+    serviceLogCursorCounter += 1;
+    service.recentLogs.push({ cursor: serviceLogCursorCounter, line });
+  }
+  if (service.recentLogs.length > SERVICE_RECENT_LOG_LIMIT) {
+    service.recentLogs.splice(0, service.recentLogs.length - SERVICE_RECENT_LOG_LIMIT);
+  }
+}
+
+function matchesServiceSuccess(service, text) {
+  const value = String(text || '');
+  if (!value) return false;
+  if (hasReadyOutput(value)) return true;
+  return service.successMatchers.some((matcher) => value.toLowerCase().includes(matcher.toLowerCase()));
+}
+
+function markServiceReady(service, source = 'output') {
+  if (service.startupConfirmed) return;
+  service.startupConfirmed = true;
+  service.startupSource = source;
+  service.status = 'running';
+}
+
+function serviceUrlForPort(port) {
+  const portNumber = Number(port);
+  return Number.isInteger(portNumber) && portNumber > 0 ? `http://127.0.0.1:${portNumber}` : '';
+}
+
+function normalizeHttpProbe(value) {
+  if (!value || typeof value !== 'object') return null;
+  const url = String(value.url || '').trim();
+  if (!url) return null;
+  const expectStatus = Number(value.expect_status ?? value.expectStatus ?? 200);
+  return {
+    url,
+    expect_status: Number.isInteger(expectStatus) ? expectStatus : 200
+  };
+}
+
+function snapshotService(service, tail = 12) {
+  const recentLogs = Array.isArray(service.recentLogs)
+    ? service.recentLogs.slice(-Math.max(1, tail)).map((item) => item.line)
+    : [];
+  const latestCursor =
+    Array.isArray(service.recentLogs) && service.recentLogs.length > 0
+      ? service.recentLogs[service.recentLogs.length - 1].cursor
+      : 0;
+  return {
+    task_id: service.taskId,
+    pid: service.child?.pid || null,
+    command: service.command,
+    cwd: service.cwd,
+    status: service.status,
+    startup_confirmed: service.startupConfirmed,
+    startup_source: service.startupSource || '',
+    http_probe: service.httpProbe || undefined,
+    url: serviceUrlForPort(service.portProbe) || undefined,
+    recent_logs: recentLogs,
+    log_cursor: latestCursor,
+    exit_code: service.exitCode ?? undefined,
+    signal: service.signal ?? undefined,
+    duration_ms: Date.now() - service.startedAt
+  };
+}
+
+function listServiceSnapshots() {
+  return Array.from(serviceRegistry.values()).map((service) => snapshotService(service, 4));
+}
+
+function probePortOnce(port, host = '127.0.0.1', timeoutMs = 250) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once('connect', () => finish(true));
+    socket.once('timeout', () => finish(false));
+    socket.once('error', () => finish(false));
+    socket.connect(Number(port), host);
+  });
+}
+
+async function probeHttpOnce(httpProbe, timeoutMs = 400) {
+  if (!httpProbe?.url) return false;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(httpProbe.url, {
+      method: 'GET',
+      signal: controller.signal
+    });
+    return response.status === Number(httpProbe.expect_status || 200);
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function startService(root, config, args) {
+  const command = String(args?.command || args?.cmd || '').trim();
+  if (!command) throw new Error('start_service requires command');
+  if (
+    !config.policy.allow_dangerous_commands &&
+    isDangerousCommand(command, config.policy.blocked_command_patterns)
+  ) {
+    throw new Error('Command blocked by policy');
+  }
+  const check = evaluateCommandPolicy(command, config, root);
+  if (!check.allowed) {
+    throw new Error(
+      `Command blocked by safe mode: ${check.reason}${check.suggestion ? ` | ${check.suggestion}` : ''}`
+    );
+  }
+
+  const shellSpec = resolveShell(config.shell.default);
+  const taskId = nextServiceId();
+  const startupTimeoutMs = Math.max(250, Number(args?.startup_timeout_ms || args?.startupTimeoutMs || 20000));
+  const successMatchers = normalizeSuccessMatchers(args?.success_matchers || args?.successMatchers);
+  const portProbe = Number(args?.port_probe || args?.portProbe || 0) || 0;
+  const httpProbe = normalizeHttpProbe(args?.http_probe || args?.httpProbe);
+  const service = {
+    taskId,
+    command,
+    cwd: root,
+    child: spawn(shellSpec.command, [...shellSpec.args, shellCommandForService(command, shellSpec)], {
+      cwd: root,
+      stdio: ['ignore', 'pipe', 'pipe']
+    }),
+    startedAt: Date.now(),
+    status: 'starting',
+    startupConfirmed: false,
+    startupSource: '',
+    successMatchers,
+    portProbe,
+    httpProbe,
+    recentLogs: [],
+    exitCode: null,
+    signal: null
+  };
+  serviceRegistry.set(taskId, service);
+
+  service.closePromise = new Promise((resolve) => {
+    service.child.on('close', (code, signal) => {
+      service.exitCode = code;
+      service.signal = signal;
+      service.status = service.status === 'stopped' ? 'stopped' : 'exited';
+      resolve();
+    });
+  });
+
+  const onOutput = (chunk) => {
+    appendRecentLogs(service, chunk);
+    if (matchesServiceSuccess(service, chunk)) {
+      markServiceReady(service, 'output');
+      if (service._finishStartup) service._finishStartup();
+    }
+  };
+  service.child.stdout.on('data', onOutput);
+  service.child.stderr.on('data', onOutput);
+  service.child.on('error', (error) => {
+    appendRecentLogs(service, error?.message || String(error));
+    service.status = 'exited';
+    if (service._finishStartup) service._finishStartup();
+  });
+
+  await new Promise((resolve) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutHandle);
+      clearInterval(portHandle);
+      clearInterval(httpHandle);
+      service._finishStartup = null;
+      resolve();
+    };
+    service._finishStartup = finish;
+    if (service.startupConfirmed || service.status === 'exited') {
+      finish();
+      return;
+    }
+    const timeoutHandle = setTimeout(() => {
+      if (service.status === 'starting') {
+        if (!service.startupConfirmed) {
+          markServiceReady(service, 'startup_window');
+        } else {
+          service.status = 'running';
+        }
+      }
+      finish();
+    }, startupTimeoutMs);
+    const portHandle =
+      portProbe > 0
+        ? setInterval(async () => {
+            const open = await probePortOnce(portProbe);
+            if (open) {
+              markServiceReady(service, 'port_probe');
+              finish();
+            }
+          }, SERVICE_STARTUP_POLL_MS)
+        : null;
+    const httpHandle =
+      httpProbe
+        ? setInterval(async () => {
+            const ok = await probeHttpOnce(httpProbe);
+            if (ok) {
+              markServiceReady(service, 'http_probe');
+              finish();
+            }
+          }, SERVICE_STARTUP_POLL_MS)
+        : null;
+    service.child.once('close', () => finish());
+  });
+
+  if (service.status === 'starting') {
+    service.status = 'running';
+  }
+  return snapshotService(service);
+}
+
+function getServiceOrThrow(taskId) {
+  const service = serviceRegistry.get(String(taskId || '').trim());
+  if (!service) throw new Error(`Unknown service task: ${taskId}`);
+  return service;
+}
+
+async function getServiceStatus(_root, args) {
+  const service = getServiceOrThrow(args?.task_id || args?.taskId);
+  return snapshotService(service);
+}
+
+async function listServices() {
+  return {
+    services: listServiceSnapshots()
+  };
+}
+
+async function getServiceLogs(_root, args) {
+  const service = getServiceOrThrow(args?.task_id || args?.taskId);
+  const tail = Math.max(1, Math.min(200, Number(args?.tail || 40)));
+  const afterCursor = Math.max(0, Number(args?.after_cursor || args?.afterCursor || 0));
+  const filtered = afterCursor > 0 ? service.recentLogs.filter((item) => item.cursor > afterCursor) : service.recentLogs;
+  const selected = filtered.slice(-tail);
+  return {
+    task_id: service.taskId,
+    status: service.status,
+    recent_logs: selected.map((item) => item.line),
+    next_cursor: selected.length > 0 ? selected[selected.length - 1].cursor : afterCursor
+  };
+}
+
+async function stopService(_root, args) {
+  const service = getServiceOrThrow(args?.task_id || args?.taskId);
+  if (service.status === 'stopped' || service.status === 'exited') {
+    return { ...snapshotService(service), stopped: true };
+  }
+  service.status = 'stopped';
+  terminateChild(service.child, 'SIGTERM');
+  setTimeout(() => terminateChild(service.child, 'SIGKILL'), 200);
+  await Promise.race([
+    service.closePromise,
+    new Promise((resolve) => setTimeout(resolve, 500))
+  ]);
+  return { ...snapshotService(service), stopped: true };
+}
+
 async function searchCode(root, args) {
   const query = String(args?.query || args?.symbol || '').trim();
   if (!query) throw new Error('search_code requires query');
@@ -1071,7 +1382,7 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
       type: 'function',
       function: {
         name: 'run_command',
-        description: 'Execute a shell command in workspace',
+        description: 'Execute a one-shot shell command in workspace. Do not use for long-running services.',
         parameters: {
           type: 'object',
           properties: {
@@ -1080,6 +1391,88 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
           required: ['command']
         }
       }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'start_service',
+        description: 'Start a long-running local service and return a compact service handle instead of blocking on process exit.',
+        parameters: {
+          type: 'object',
+          properties: {
+            command: { type: 'string' },
+            startup_timeout_ms: { type: 'number' },
+            success_matchers: {
+              type: 'array',
+              items: { type: 'string' }
+            },
+            port_probe: { type: 'number' },
+            http_probe: {
+              type: 'object',
+              properties: {
+                url: { type: 'string' },
+                expect_status: { type: 'number' }
+              }
+            }
+          },
+          required: ['command']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'list_services',
+        description: 'List all tracked local services and their compact current status.',
+        parameters: {
+          type: 'object',
+          properties: {}
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'get_service_status',
+        description: 'Get the current status of a previously started service.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string' }
+          },
+          required: ['task_id']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'get_service_logs',
+        description: 'Read recent logs from a previously started service.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string' },
+            tail: { type: 'number' },
+            after_cursor: { type: 'number' }
+          },
+          required: ['task_id']
+        }
+      }
+    },
+    {
+      type: 'function',
+      function: {
+        name: 'stop_service',
+        description: 'Stop a previously started service.',
+        parameters: {
+          type: 'object',
+          properties: {
+            task_id: { type: 'string' }
+          },
+          required: ['task_id']
+        }
+      }
     }
   ];
 
@@ -1096,6 +1489,11 @@ export function getBuiltinTools({ workspaceRoot = process.cwd(), config }) {
     insert_before: (args) => insertRelative(workspaceRoot, args, 'insert_before'),
     insert_after: (args) => insertRelative(workspaceRoot, args, 'insert_after'),
     generate_diff: (args) => generateDiff(workspaceRoot, args),
+    start_service: (args) => startService(workspaceRoot, config, args),
+    list_services: () => listServices(workspaceRoot),
+    get_service_status: (args) => getServiceStatus(workspaceRoot, args),
+    get_service_logs: (args) => getServiceLogs(workspaceRoot, args),
+    stop_service: (args) => stopService(workspaceRoot, args),
     read_file: (args) =>
       readFile(workspaceRoot, {
         ...args,

package/src/tui/chat-app.js

@@ -316,6 +316,11 @@ function getActivityDisplayParts(activity) {
     read_file: 'Read',
     write_file: 'Write',
     run_command: 'Command',
+    start_service: 'Service',
+    list_services: 'Service',
+    get_service_status: 'Service',
+    get_service_logs: 'Service',
+    stop_service: 'Service',
     list_files: 'Glob',
     create_task: 'Task',
     update_task: 'Task'
@@ -357,6 +362,13 @@ function describeToolActivity(name, copy, { done = false, blocked = false } = {}
         ? `${copy.toolActivity.doneCommand}: ${safeTarget || 'run_command'}`
         : `${copy.toolActivity.doingCommand}: ${safeTarget || 'run_command'}`;
   }
+  if (base === 'start_service' || base === 'list_services' || base === 'get_service_status' || base === 'get_service_logs' || base === 'stop_service') {
+    return blocked
+      ? `${copy.toolActivity.blocked}: ${safeTarget || base}`
+      : done
+        ? `${copy.toolActivity.doneGeneric}: ${safeTarget || base}`
+        : `${copy.toolActivity.doingGeneric}: ${safeTarget || base}`;
+  }
   if (base === 'create_task') {
     return blocked ? `${copy.toolActivity.blocked}: create_task` : done ? copy.toolActivity.doneCreateTask : copy.toolActivity.doingCreateTask;
   }
@@ -472,9 +484,13 @@ function PlanStrip({ planState, copy }) {
           ...planState.steps.slice(-4).map((step, idx) =>
             h(
               Box,
-              { key: `plan-step-${idx}` },
+              { key: `plan-step-${idx}`, marginTop: idx === 0 ? 0 : 1 },
               h(Text, { color: step.status === 'active' ? 'cyanBright' : step.status === 'failed' ? 'redBright' : 'gray' }, `${step.status === 'active' ? '>' : step.status === 'failed' ? 'x' : '·'} `),
-              h(Text, { color: step.status === 'active' ? 'white' : step.status === 'failed' ? 'redBright' : 'gray' }, `${step.index}/${step.total} ${step.role}: ${step.title}`)
+              h(Text, { color: step.status === 'active' ? 'yellowBright' : step.status === 'failed' ? 'redBright' : 'gray' }, `${step.index}/${step.total}`),
+              h(Text, { color: 'gray' }, '  '),
+              h(Text, { color: step.status === 'active' ? 'magentaBright' : step.status === 'failed' ? 'redBright' : 'gray' }, String(step.role || 'agent').toUpperCase()),
+              h(Text, { color: 'gray' }, '  '),
+              h(Text, { color: step.status === 'active' ? 'white' : step.status === 'failed' ? 'redBright' : 'gray' }, step.title)
             )
           )
         )
@@ -583,6 +599,39 @@ export function parseAutoPlanSummaryMessage(text) {
   return parsed;
 }
 
+export function parsePlanProgressLine(text) {
+  const raw = String(text || '').trim();
+  const match = raw.match(/^\[plan\]\s+Step\s+(\d+)\/(\d+)\s+->\s+([^:]+):\s+(.+)$/i);
+  if (!match) return null;
+  return {
+    current: Number(match[1]),
+    total: Number(match[2]),
+    role: String(match[3] || '').trim(),
+    title: String(match[4] || '').trim()
+  };
+}
+
+export function injectPlanStateMessage(messages, planState, activeUserMessageId, activeAssistantId) {
+  const source = Array.isArray(messages) ? messages : [];
+  if (!planState || !planState.total) return source;
+  const synthetic = {
+    id: `plan-state-${planState.current}-${planState.total}-${planState.role || 'agent'}`,
+    label: 'system',
+    planStrip: true,
+    planState
+  };
+  const withNoPlanStrip = source.filter((message) => !message?.planStrip);
+  const userIdx = withNoPlanStrip.findIndex((message) => message.id === activeUserMessageId);
+  if (userIdx !== -1) {
+    return [...withNoPlanStrip.slice(0, userIdx + 1), synthetic, ...withNoPlanStrip.slice(userIdx + 1)];
+  }
+  const assistantIdx = withNoPlanStrip.findIndex((message) => message.id === activeAssistantId);
+  if (assistantIdx !== -1) {
+    return [...withNoPlanStrip.slice(0, assistantIdx), synthetic, ...withNoPlanStrip.slice(assistantIdx)];
+  }
+  return [...withNoPlanStrip, synthetic];
+}
+
 function PlanSummaryBubble({ msg, copy }) {
   const theme = roleStyle(msg.label);
   const summary = msg.planSummary || parseAutoPlanSummaryMessage(msg.text);
@@ -760,6 +809,114 @@ function pushWrappedRow(rows, baseRow, contentWidth) {
   });
 }
 
+function isActivityRow(row) {
+  return row?.kind === 'activity' || row?.kind === 'activity-summary';
+}
+
+function isBlankTextRow(row) {
+  return row?.kind === 'text' && String(row?.text || '').trim() === '';
+}
+
+export function normalizeActivitySpacingRows(inputRows) {
+  const rows = Array.isArray(inputRows) ? inputRows : [];
+  const normalized = [];
+
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    const prev = normalized.at(-1);
+    const next = rows[index + 1];
+
+    if (isBlankTextRow(row)) {
+      let lookahead = index + 1;
+      while (lookahead < rows.length && isBlankTextRow(rows[lookahead])) {
+        lookahead += 1;
+      }
+      if (isActivityRow(rows[lookahead])) {
+        continue;
+      }
+    }
+
+    if (isBlankTextRow(row) && isActivityRow(next)) {
+      continue;
+    }
+
+    normalized.push(row);
+
+    if (isActivityRow(row) && !isActivityRow(next) && next) {
+      const last = normalized.at(-1);
+      if (!isBlankTextRow(last) && !(next.kind === 'status')) {
+        normalized.push({
+          kind: 'text',
+          text: ' ',
+          color: 'white'
+        });
+      }
+    }
+
+    if (isBlankTextRow(row) && isBlankTextRow(prev)) {
+      normalized.pop();
+    }
+  }
+
+  return normalized;
+}
+
+function isReadActivityName(name) {
+  const parsed = parseToolDisplayName(name);
+  return parsed.base === 'read_file' || parsed.base === 'Read';
+}
+
+function isIgnorableSegmentAfterRead(item, activityType, activityName) {
+  if (!item) return true;
+  if (item.type === 'text') {
+    return String(item.text || '').trim() === '';
+  }
+  return (item.type || 'tool') === activityType && item.name === activityName;
+}
+
+export function findActivityUpdateIndex(items, toolEvent) {
+  const source = Array.isArray(items) ? items : [];
+  const activityType = toolEvent?.type || 'tool';
+  const byId = toolEvent?.id
+    ? source.findIndex((item) => item.type === activityType && item.id && item.id === toolEvent.id)
+    : -1;
+  if (byId !== -1) return byId;
+
+  const byNameRunning = source.findIndex(
+    (item) => (item.type || 'tool') === activityType && item.name === toolEvent?.name && item.status !== 'done'
+  );
+  if (byNameRunning !== -1) return byNameRunning;
+
+  if (isReadActivityName(toolEvent?.name)) {
+    for (let index = source.length - 1; index >= 0; index -= 1) {
+      const item = source[index];
+      if ((item?.type || 'tool') !== activityType || item?.name !== toolEvent?.name) continue;
+      const trailing = source.slice(index + 1);
+      if (trailing.every((entry) => isIgnorableSegmentAfterRead(entry, activityType, toolEvent?.name))) {
+        return index;
+      }
+    }
+  }
+
+  return -1;
+}
+
+export function mergeActivitySummary(previousSummary, nextSummary, activityName) {
+  const prev = String(previousSummary || '').trim();
+  const next = String(nextSummary || '').trim();
+  if (!next) return prev;
+  if (!prev) return next;
+  if (!isReadActivityName(activityName) || prev === next) return next;
+
+  const lines = [];
+  for (const line of `${prev}\n${next}`.split('\n')) {
+    const trimmed = String(line || '').trim();
+    if (!trimmed) continue;
+    if (!lines.includes(trimmed)) lines.push(trimmed);
+  }
+  return lines.join('\n');
+}
+
 function buildMessageRows(msg, showToolDetails, contentWidth = 72) {
   const rows = [];
   const pushTextRows = (text) => {
@@ -767,6 +924,17 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72) {
     let codeFence = false;
     for (const line of lines) {
       const trimmed = line.trim();
+      const planProgress = parsePlanProgressLine(trimmed);
+      if (planProgress) {
+        rows.push({
+          kind: 'plan-progress',
+          current: planProgress.current,
+          total: planProgress.total,
+          role: planProgress.role,
+          title: trimText(planProgress.title, Math.max(12, contentWidth - 18))
+        });
+        continue;
+      }
       if (trimmed.startsWith('```')) {
         codeFence = !codeFence;
         continue;
@@ -843,7 +1011,7 @@ function buildMessageRows(msg, showToolDetails, contentWidth = 72) {
     );
   }
 
-  return rows;
+  return normalizeActivitySpacingRows(rows);
 }
 
 
@@ -945,6 +1113,13 @@ export function moveSuggestionSelection(currentIndex, itemCount, direction, page
 }
 
 function MessageBubble({ msg, loaderTick, showToolDetails, rowWindow = null, contentWidth = 72, copy }) {
+  if (msg?.planStrip) {
+    return h(
+      Box,
+      { marginBottom: 1 },
+      h(PlanStrip, { planState: msg.planState, copy })
+    );
+  }
   if (msg?.planSummary || parseAutoPlanSummaryMessage(msg?.text)) {
     return h(PlanSummaryBubble, { msg, copy });
   }
@@ -991,6 +1166,18 @@ function MessageBubble({ msg, loaderTick, showToolDetails, rowWindow = null, con
         h(Text, { color: 'gray' }, `└ ${row.text}`)
       );
     }
+    if (row.kind === 'plan-progress') {
+      return h(
+        Box,
+        { key: `row-plan-progress-${msg.id}-${idx}`, marginTop: 1, marginBottom: 1 },
+        h(Text, { color: 'cyanBright' }, '[plan] '),
+        h(Text, { color: 'yellowBright' }, `Step ${row.current}/${row.total}`),
+        h(Text, { color: 'gray' }, '  ->  '),
+        h(Text, { color: 'magentaBright' }, String(row.role || 'agent').toUpperCase()),
+        h(Text, { color: 'gray' }, ': '),
+        h(Text, { color: 'white' }, row.title)
+      );
+    }
     if (row.kind === 'status') {
       const dots = '.'.repeat((loaderTick % 3) + 1);
       const phase = msg.phase;
@@ -1456,13 +1643,7 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
         if (m.id !== targetId) return m;
         const toolCalls = Array.isArray(m.toolCalls) ? [...m.toolCalls] : [];
         const activityType = toolEvent.type || 'tool';
-        const byId = toolEvent.id
-          ? toolCalls.findIndex((t) => t.type === activityType && t.id && t.id === toolEvent.id)
-          : -1;
-        const byNameRunning = toolCalls.findIndex(
-          (t) => (t.type || 'tool') === activityType && t.name === toolEvent.name && t.status !== 'done'
-        );
-        const idx = byId !== -1 ? byId : byNameRunning;
+        const idx = findActivityUpdateIndex(toolCalls, toolEvent);
 
         if (idx === -1) {
           toolCalls.push({
@@ -1480,17 +1661,13 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
             id: toolEvent.id || toolCalls[idx].id,
             status: toolEvent.status,
             ...(toolEvent.durationMs !== undefined ? { durationMs: toolEvent.durationMs } : {}),
-            ...(toolEvent.summary ? { summary: toolEvent.summary } : {})
+            ...(toolEvent.summary
+              ? { summary: mergeActivitySummary(toolCalls[idx].summary, toolEvent.summary, toolEvent.name) }
+              : {})
           };
         }
         const segments = Array.isArray(m.segments) ? [...m.segments] : [];
-        const bySegmentId = toolEvent.id
-          ? segments.findIndex((segment) => segment.type === activityType && segment.id === toolEvent.id)
-          : -1;
-        const bySegmentName = segments.findIndex(
-          (segment) => segment.type === activityType && segment.name === toolEvent.name && segment.status !== 'done'
-        );
-        const segmentIdx = bySegmentId !== -1 ? bySegmentId : bySegmentName;
+        const segmentIdx = findActivityUpdateIndex(segments, toolEvent);
         const patch = {
           type: activityType,
           id: toolEvent.id || '',
@@ -1504,7 +1681,10 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
         } else {
           segments[segmentIdx] = {
             ...segments[segmentIdx],
-            ...patch
+            ...patch,
+            ...(toolEvent.summary
+              ? { summary: mergeActivitySummary(segments[segmentIdx].summary, toolEvent.summary, toolEvent.name) }
+              : {})
           };
         }
         return { ...m, toolCalls, segments };
@@ -2192,16 +2372,21 @@ export function ChatApp({ runtime, sessionId, model, language = 'zh', shellName
   const hasConversationStarted = messages.some((m) =>
     ['you', 'coder', 'pending', 'error'].includes(m.label)
   );
-  const visibleMessages = hasConversationStarted
+  const baseVisibleMessages = hasConversationStarted
     ? messages.filter((m) => !(m.label === 'system' && m.text === startupHint))
     : messages;
+  const visibleMessages = injectPlanStateMessage(
+    baseVisibleMessages,
+    planState,
+    activeUserMessageIdRef.current,
+    activeAssistantIdRef.current
+  );
 
   return h(
     Box,
     { flexDirection: 'column' },
     h(Header, { sessionId: displaySessionId, model: displayModel, shellName }),
     h(RuntimeStrip, { busy, runtimeStatus, loaderTick, copy }),
-    h(PlanStrip, { planState, copy }),
     h(MessageList, {
       messages: visibleMessages,
       loaderTick,