codemini-cli 0.3.1 → 0.3.3

package/OPERATIONS.md

@@ -127,6 +127,10 @@ Use this when you want to separate:
 /retry
 ```
 
+Note:
+- The old manual `/tasks` board has been removed.
+- For complex single-task work, the assistant now maintains an internal session todo checklist automatically and shows it in the TUI.
+
 Available sub-agent roles:
 
 ```text

package/README.md

@@ -5,41 +5,72 @@
 
 ## English
 
-CodeMini CLI is a coding assistant CLI optimized for small-model workflows, with a strong focus on Windows and PowerShell.
+CodeMini CLI is a terminal coding assistant built for teams that want a smaller, sharper, and more controllable agent experience.
 
-It is designed for teams that want a coding assistant that feels practical, controllable, and fast in real development environments, especially when smaller internal models are part of the workflow.
+It is designed around a deliberate idea: most coding workflows do not need a huge default tool surface or unrestricted shell behavior. Instead, CodeMini starts with a compact core, loads advanced tools on demand, and keeps the agent grounded in structured code operations, session todos, lightweight project indexing, and shell-aware safety rules.
 
 ### Why CodeMini CLI
 
-- Optimized for small-model workflows rather than assuming frontier-scale reasoning
-- Built with Windows and PowerShell as first-class environments
-- Keeps the default tool surface intentionally small and easier to control
-- Uses shell-aware execution policy instead of exposing unrestricted system access
-- Supports sub-agent workflows without forcing full-history context sharing
-
-### Highlights
-
-- Minimal default tools: `run`, `read`, `write`
-- 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: `grep`, `read`, `edit`
-- Tree-sitter AST tools for small models: `ast_query`, `read_ast_node`, node-scoped `edit`
-- More conservative `plan auto` acceptance checks with reviewer/tester goal checklists
-- Tone presets through `soul`, without changing plans or code behavior
-- Example soul presets include `professional`, `playful`, `anime`, `pirate`, `caveman`, and `ceo`
-- Sub-agents for planning, coding, review, and testing
+- Built for practical coding workflows, especially when smaller or internal models are part of the stack
+- Keeps the default tool list intentionally small, with additional tools discoverable through `tool_search`
+- Treats Windows and PowerShell as first-class environments instead of Linux-only afterthoughts
+- Prefers structured file and code tools over noisy shell fallbacks
+- Supports planning, execution, todo tracking, and sub-agent workflows without forcing a bloated interface
+
+### What It Feels Like
+
+- A coding CLI that is fast to steer
+- A tool surface that is easier to audit and reason about
+- A TUI that makes execution visible instead of hiding agent state
+- A workflow that stays useful even when the model is not frontier-scale
+
+### Core Capabilities
+
+- Compact default tools for daily work:
+  - `read`
+  - `grep`
+  - `list`
+  - `query_project_index`
+  - `edit`
+  - `write`
+  - `update_todos`
+  - `run`
+  - `tool_search`
+- On-demand tools for advanced workflows:
+  - `glob`
+  - AST tools: `ast_query`, `read_ast_node`
+  - diff tools: `generate_diff`, `patch`
+  - background task management tools
+  - persistent memory tools
+- Session-scoped todo tracking through `update_todos`, rendered directly in the TUI
+- Unified shell execution model:
+  - one-shot commands through `run`
+  - long-running commands through `run` with `run_in_background=true`
+  - background task inspection through deferred tools when needed
+- Lightweight project index in `.codemini-project/` for repository-aware prompting
+- Tree-sitter-assisted structural editing for function/class/method scoped work
+- Sub-agent support for planning, coding, review, and testing workflows
+- Reply language control through `ui.reply_language`
+- Tone presets through `soul`, without changing planning or code behavior
+
+### Workflow Highlights
+
+- `update_todos` is used for complex single-task work and rendered as a native checklist in the TUI
+- `plan auto` is oriented toward task decomposition and execution sequencing
+- `task`-level execution tracking is separated from `plan` and handled through the internal todo checklist
+- The shell workflow is unified: the assistant no longer has to switch mental models between one-shot commands and long-running service tools
+- The prompt explicitly teaches the model that the visible default tools are not the full tool universe; it should use `tool_search` when it needs more capability
+- Slash completion includes prioritization, paging, and inline descriptions
+- Safe mode is enabled by default
 
 ### Quick Start
 
 ```bash
 codemini config set gateway.base_url http://your-internal-gateway/v1
 codemini config set gateway.api_key your_token
+codemini config set model.name your-30b-model
 codemini config set shell.default powershell
 codemini config set ui.reply_language zh
-codemini config set model.name your-30b-model
 codemini doctor
 codemini
 ```
@@ -50,7 +81,7 @@ For macOS or Linux:
 codemini config set shell.default bash
 ```
 
-### Command Overview
+### Commands
 
 ```text
 codemini [prompt]
@@ -61,112 +92,139 @@ codemini doctor
 codemini skill list|install|enable|disable|inspect|reindex
 ```
 
-### Notable Workflow Features
+### How The Tool Model Works
 
-- `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
-- Ambiguous feature requests can pause for lightweight brainstorming first, and `/brainstorm <question>` gives an explicit way to compare options before coding
-- `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 `grep/read -> edit`
-- Tree-sitter-aware code tools support `grep/read -> ast_query/read_ast_node -> edit(ast_target)` for function/class-level edits with explicit node range limits
-- Current Tree-sitter language support includes JavaScript/JSX, TypeScript/TSX, Python, Go, C, C++, Bash, Java, Rust, C#, PHP, and Ruby
+CodeMini CLI intentionally separates tools into two layers:
 
-### Skill Loading
+- Default tools:
+  always visible, optimized for the most common coding path
+- Deferred tools:
+  loaded only when needed through `tool_search`
 
-CodeMini CLI loads skills from these locations:
+This keeps the main interface smaller and makes the agent's first-choice behavior more predictable.
 
-- Bundled repo skills: `skills/<name>/SKILL.md`
-- Installed global skills: `<base-config-dir>/skills/<name>/SKILL.md`
-- Project-scoped skills: `.codemini/skills/<name>/SKILL.md`
+Typical flow:
 
-The base config directory is resolved in this order:
-
-- `CODEMINI_GLOBAL_DIR`
-- Windows: `%APPDATA%\\codemini-global\\`
-- macOS: `~/Library/Preferences/codemini-global`
-- Linux/XDG: `$XDG_CONFIG_HOME/codemini-global`
-- Fallback in restricted environments: `.codemini-global/`
+1. `query_project_index` or `list` to orient
+2. `read` and `grep` to inspect
+3. `edit` or `write` to change code
+4. `run` to verify
+5. `update_todos` to keep complex work legible
+6. `tool_search` only when a more specialized capability is needed
 
-### Brainstorming
-
-Use `/brainstorm <question>` when you want the assistant to stop before coding, compare 2-3 approaches, and choose one direction first.
-
-```text
-/brainstorm Should login retry stay local or become a shared helper?
-```
-
-### Documentation
-### Release Checklist
+### Project Index
 
-For information on how to perform a release, please see the [Release Checklist](RELEASE_CHECKLIST.md) document.
+CodeMini CLI maintains a lightweight project index inside `.codemini-project/`:
 
+- `project-map.json`
+  high-level repository facts such as languages, source roots, test roots, and entry candidates
+- `file-index.json`
+  per-file structure such as imports, exports, functions, classes, and lightweight symbol hints
 
-- Operator guide and common command patterns: [OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
-- Packaging and deployment guide: [deployment.md](/mnt/e/Git%20Projects/qurio-coder/deployment.md)
+The index is initialized when entering a project and refreshed incrementally after edits, writes, and patches. It is intended to be factual, compact, and cheap to keep current.
 
 ### Data Layout
 
-- Project-scoped workspace data: `.codemini/`
-- Global user data on Windows: `%APPDATA%\\codemini-global\\`
-- Restricted-environment fallback: `.codemini-global/`
+- Session and project workspace state: `.codemini/`
+- Lightweight project index: `.codemini-project/`
+- Bundled repo skills: `skills/<name>/SKILL.md`
+- Project-scoped skills: `.codemini/skills/<name>/SKILL.md`
+- Global installed skills: `<base-config-dir>/skills/<name>/SKILL.md`
+
+Base config directory resolution order:
 
-### Project Index
+- `CODEMINI_GLOBAL_DIR`
+- Windows: `%APPDATA%\codemini-global\`
+- macOS: `~/Library/Preferences/codemini-global`
+- Linux / XDG: `$XDG_CONFIG_HOME/codemini-global`
+- Restricted fallback: `.codemini-global/`
 
-CodeMini CLI now maintains a lightweight project index inside `.codemini-project/`:
+### Documentation
 
-- `project-map.json` for project skeleton metadata such as languages, important files, source roots, test roots, and entry candidates
-- `file-index.json` for per-file symbols, imports, exports, functions, classes, and basic call hints
+- Operator guide and workflow notes: [OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
+- Packaging and deployment: [deployment.md](/mnt/e/Git%20Projects/qurio-coder/deployment.md)
+- Release process: [RELEASE_CHECKLIST.md](/mnt/e/Git%20Projects/qurio-coder/RELEASE_CHECKLIST.md)
 
-The index is initialized once when entering a project and refreshed incrementally after code edits, writes, and patches. Session data stays in `.codemini/`; project structure lives in `.codemini-project/`. The index is intentionally lightweight and fact-based rather than an LLM-generated project report.
-At request time, CodeMini injects a short project-context summary from this index into the model prompt instead of dumping the full index.
+### Good Fit
 
-### Positioning
+CodeMini CLI is a strong fit if you want:
 
-CodeMini CLI is a better fit if you want:
 - a coding CLI that behaves well with smaller models
-- a Windows and PowerShell-friendly workflow
-- a more controlled execution surface
-- multi-agent execution with stronger review and verification steps
+- a controlled tool surface instead of an everything-is-exposed agent
+- Windows and PowerShell support that feels intentional
+- a TUI that shows plans, todos, tools, and progress clearly
+- a code assistant that prefers structured operations over shell noise
 
 ---
 
 ## 简体中文
 
-CodeMini CLI 是一个为小模型工作流优化过的代码助手 CLI，重点针对 Windows 和 PowerShell 做了打磨。
-
-它更适合那些希望代码助手在真实开发环境里更稳、更可控、更实用的团队，尤其是在内部小模型参与日常工作的场景下。
-
-### 为什么做这个
-
-- 面向小模型工作流优化，而不是默认假设超大模型能力
-- 把 Windows 和 PowerShell 当作一等公民
-- 默认工具面更小，更容易控制
-- 使用 shell-aware 的执行策略，而不是无边界暴露系统能力
-- 支持 sub-agent 协作，但不会强制共享整段上下文历史
-
-### 主要特点
-
-- 默认工具极简：`run`、`read`、`write`
-- 面向 Windows 的 PowerShell 默认配置
+CodeMini CLI 是一个面向真实开发环境的终端代码助手，目标不是“把所有能力都塞进默认界面”，而是做一个更克制、更清晰、更容易掌控的 coding agent CLI。
+
+它围绕一个很明确的原则来设计：默认工具面尽量小，常用路径尽量顺，复杂能力按需加载。这样既更适合小模型，也更适合团队在内部环境里做稳定、可控的日常开发协作。
+
+### 为什么是它
+
+- 面向小模型和内部模型工作流优化，而不是默认假设超大模型能力
+- 默认工具面刻意精简，需要更高级能力时再通过 `tool_search` 加载
+- 把 Windows 和 PowerShell 当作一等公民来支持
+- 优先走结构化代码工具，而不是让模型长期泡在嘈杂 shell 输出里
+- 同时支持规划、执行、待办追踪和 sub-agent 协作，但不把界面做得臃肿
+
+### 使用体验
+
+- 更容易 steer 的 coding CLI
+- 更容易审计和理解的工具面
+- 更强调执行可视化的 TUI
+- 即使模型不是 frontier 级别，也依然能稳定工作
+
+### 核心能力
+
+- 默认主工具保持在高频主路径：
+  - `read`
+  - `grep`
+  - `list`
+  - `query_project_index`
+  - `edit`
+  - `write`
+  - `update_todos`
+  - `run`
+  - `tool_search`
+- 更专业的能力按需加载：
+  - `glob`
+  - AST 工具：`ast_query`、`read_ast_node`
+  - diff 工具：`generate_diff`、`patch`
+  - 后台任务管理工具
+  - 持久 memory 工具
+- 通过 `update_todos` 维护复杂单任务的会话级待办清单，并直接渲染在 TUI 中
+- 统一的 shell 执行模型：
+  - 一次性命令直接 `run`
+  - 长运行命令通过 `run` + `run_in_background=true`
+  - 需要时再加载后台任务管理工具
+- 在 `.codemini-project/` 下维护轻量项目索引，帮助模型更快理解仓库
+- 基于 Tree-sitter 的结构化编辑能力，适合函数级、类级、方法级改动
+- 支持 planner、coder、reviewer、tester 等 sub-agent 协作
+- 支持通过 `ui.reply_language` 控制回复语言
+- `soul` 只影响语气和表达，不改变计划或代码行为
+
+### 工作流亮点
+
+- 复杂单任务会使用 `update_todos`，并在 TUI 里以原生 checklist 方式展示
+- `plan auto` 专注于任务拆解、顺序和执行编排
+- 单任务内部的执行推进则由 todo checklist 负责，不和 `plan` 混在一起
+- shell 模型已经统一，不再需要在“一次性命令”和“长运行服务工具”之间切换心智
+- prompt 会明确告诉模型：默认看到的工具不是全部工具，缺能力时先 `tool_search`
+- slash 补全支持优先级、分页和简短说明
 - safe mode 默认开启
-- 内置 lite skills，覆盖规划、执行和协作
-- 支持通过 `ui.reply_language` 配置回复语言，当前支持 `zh` / `en`
-- slash 补全支持优先级排序、右侧简短说明和左右分页
-- 为小模型补了结构化代码工具：`grep`、`read`、`edit`
-- 为小模型补了 Tree-sitter AST 工具：`ast_query`、`read_ast_node`，以及带 node 范围限制的 `edit`
-- `plan auto` 会基于原始目标生成验收清单，并更保守地处理 reviewer/tester 结果
-- `soul` 只影响语气，不影响计划和代码行为
-- 可用的 `soul` 示例包括 `professional`、`playful`、`anime`、`pirate`、`caveman`、`ceo`
-- 支持 planner、coder、reviewer、tester 多角色 sub-agent
 
 ### 快速开始
 
 ```bash
 codemini config set gateway.base_url http://your-internal-gateway/v1
 codemini config set gateway.api_key your_token
+codemini config set model.name your-30b-model
 codemini config set shell.default powershell
 codemini config set ui.reply_language zh
-codemini config set model.name your-30b-model
 codemini doctor
 codemini
 ```
@@ -188,57 +246,65 @@ codemini doctor
 codemini skill list|install|enable|disable|inspect|reindex
 ```
 
-### 近期工作流增强
+### 工具模型怎么设计
+
+CodeMini CLI 把工具分成两层：
+
+- 默认工具
+  永远可见，覆盖最常见的编码主路径
+- 延迟工具
+  只有在需要时才通过 `tool_search` 加载
+
+这样做的目标，是让主界面更小、更稳，也让模型在第一反应时更容易走对路径。
 
-- `ui.reply_language` 通过 prompt 层控制模型回复语言，也会尽量让生成文档和代码注释跟随该语言
-- slash 补全会优先展示更重要的命令和配置项，显示简短说明，并支持 `←/→` 翻页
-- 对于需求仍不明确的功能请求，CLI 会先偏向轻量 brainstorm；也可以显式使用 `/brainstorm <问题>` 先比较方案再决定是否编码
-- `plan auto` 会先把原始目标展开成验收清单；只有真正很小的任务才会走轻量链路；如果 reviewer 或 tester 标记了未满足或未验证的验收项，就不会按成功处理
-- 为了减少小模型被 shell 原始输出干扰，新增了 `grep/read -> edit` 这套结构化代码工具流
-- 现在也支持 `grep/read -> ast_query/read_ast_node -> edit(ast_target)` 这套 AST 工作流，适合函数级/类级精准编辑，并且能限制小模型只能修改显式选中的 node 范围
-- 当前内置的 Tree-sitter 语言支持包括 JavaScript/JSX、TypeScript/TSX、Python、Go、C、C++、Bash、Java、Rust、C#、PHP、Ruby
+典型流程通常是：
 
-### Skill 加载位置
+1. `query_project_index` 或 `list` 做定位
+2. `read` 和 `grep` 做理解
+3. `edit` 或 `write` 做改动
+4. `run` 做验证
+5. `update_todos` 追踪复杂任务
+6. 真的需要专门能力时，再 `tool_search`
 
-CodeMini CLI 会从这些位置读取 skill：
+### 项目索引
+
+CodeMini CLI 会在 `.codemini-project/` 下维护一份轻量项目索引：
+
+- `project-map.json`
+  记录仓库的高层结构事实，比如语言、源码目录、测试目录、入口候选
+- `file-index.json`
+  记录文件级结构信息，比如 imports、exports、functions、classes 和轻量 symbol 提示
+
+这份索引会在进入项目时初始化，在 `edit`、`write`、`patch` 后做增量刷新。它的目标是轻量、可靠、低噪声，而不是生成一份很长的 AI 报告。
+
+### 数据目录
 
+- 会话和项目工作区状态：`.codemini/`
+- 轻量项目索引：`.codemini-project/`
 - 仓库内置 skill：`skills/<name>/SKILL.md`
-- 全局已安装 skill：`<base-config-dir>/skills/<name>/SKILL.md`
 - 项目级 skill：`.codemini/skills/<name>/SKILL.md`
+- 全局已安装 skill：`<base-config-dir>/skills/<name>/SKILL.md`
 
-`base-config-dir` 的解析顺序是：
+`base-config-dir` 的解析顺序：
 
 - `CODEMINI_GLOBAL_DIR`
-- Windows：`%APPDATA%\\codemini-global\\`
+- Windows：`%APPDATA%\codemini-global\`
 - macOS：`~/Library/Preferences/codemini-global`
 - Linux / XDG：`$XDG_CONFIG_HOME/codemini-global`
 - 受限环境回退：`.codemini-global/`
 
-### Brainstorm 用法
-
-当你希望助手先收敛方向、不要立即写代码时，可以使用：
-
-```text
-/brainstorm Should login retry stay local or become a shared helper?
-```
-
 ### 文档入口
 
-- 操作手册与常见命令组合：[OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
-- 打包与部署手册：[deployment.md](/mnt/e/Git%20Projects/qurio-coder/deployment.md)
-
-### 数据目录
-
-- 项目工作区数据：`.codemini/`
-- Windows 全局用户数据：`%APPDATA%\\codemini-global\\`
-- 受限环境回退目录：`.codemini-global/`
-
-### 项目索引
+- 操作手册与工作流说明：[OPERATIONS.md](/mnt/e/Git%20Projects/qurio-coder/OPERATIONS.md)
+- 打包与部署文档：[deployment.md](/mnt/e/Git%20Projects/qurio-coder/deployment.md)
+- 发布流程：[RELEASE_CHECKLIST.md](/mnt/e/Git%20Projects/qurio-coder/RELEASE_CHECKLIST.md)
 
-CodeMini CLI 现在会在 `.codemini-project/` 下维护一份轻量项目索引：
+### 适合谁
 
-- `project-map.json`：记录项目骨架信息，例如语言、关键文件、源码目录、测试目录、入口候选
-- `file-index.json`：记录文件级结构信息，例如 symbols、imports、exports、functions、classes、基础 calls
+如果你想要的是下面这种工具，CodeMini CLI 会很合适：
 
-这份索引会在进入项目时初始化一次，在 `edit`、`write`、`patch` 后做增量刷新。`.codemini/` 继续保存会话态数据，`.codemini-project/` 保存项目结构索引。它是程序维护的轻量事实索引，不是模型生成的项目总结。
-在真正请求模型时，CodeMini 会从这份索引里裁一小段项目摘要注入 prompt，而不是把整份索引直接塞进去。
+- 能和小模型稳定协作的 coding CLI
+- 更克制、更可控的工具暴露方式
+- 真正重视 Windows / PowerShell 体验的终端工作流
+- 能把计划、待办、工具调用和执行状态展示清楚的 TUI
+- 更偏结构化操作、而不是大量 shell 噪声的代码助手

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemini-cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Coding CLI optimized for small-model workflows and Windows PowerShell",
   "keywords": [
     "cli",
@@ -47,6 +47,7 @@
   },
   "dependencies": {
     "@cursorless/tree-sitter-wasms": "^0.5.0",
+    "@anthropic-ai/sdk": "^0.82.0",
     "ink": "^6.3.1",
     "openai": "^6.33.0",
     "react": "^19.0.0",

package/src/commands/chat.js

@@ -98,6 +98,7 @@ export async function handleChat(args) {
       runtime,
       sessionId: session.id,
       model: parsed.model || config.model.name,
+      sdkProvider: config.sdk?.provider || 'openai-compatible',
       language: config.ui?.language || 'zh',
       shellName: config.shell?.default || 'powershell',
       safeMode: config.policy?.safe_mode !== false,

package/src/commands/run.js

@@ -1,9 +1,10 @@
 import { loadConfig } from '../core/config-store.js';
 import { buildDefaultSystemPrompt } from '../core/default-system-prompt.js';
 import { runAgentLoop } from '../core/agent-loop.js';
-import { createChatCompletion } from '../core/provider/openai-compatible.js';
+import { createChatCompletion } from '../core/provider/index.js';
 import { buildSystemPromptWithSoul } from '../core/soul.js';
 import { getBuiltinTools } from '../core/tools.js';
+import { buildMemorySnapshot } from '../core/memory-prompt.js';
 
 function parseRunArgs(args) {
   const parsed = {
@@ -39,7 +40,9 @@ export async function handleRun(args) {
     workspaceRoot: process.cwd(),
     config
   });
-  const systemPrompt = await buildSystemPromptWithSoul(buildDefaultSystemPrompt(config), config);
+  const soulPrompt = await buildSystemPromptWithSoul(buildDefaultSystemPrompt(config), config);
+  const memorySnapshot = await buildMemorySnapshot({ config, workspaceRoot: process.cwd() }).catch(() => '');
+  const systemPrompt = [soulPrompt, memorySnapshot].filter(Boolean).join('\n\n');
 
   const result = await runAgentLoop({
     systemPrompt,
@@ -52,6 +55,7 @@ export async function handleRun(args) {
     maxSteps: parsed.maxSteps,
     requestCompletion: async ({ messages, tools, model }) =>
       createChatCompletion({
+        sdkProvider: config.sdk?.provider,
         baseUrl: config.gateway.base_url,
         apiKey: config.gateway.api_key,
         model,

package/src/core/agent-loop.js

@@ -194,6 +194,9 @@ function compactToolResult(result, toolName, args, maxChars = 12000) {
   if ('tasks' in obj && Array.isArray(obj.tasks)) {
     return `${obj.tasks.length} task(s)`;
   }
+  if ('newTodos' in obj && Array.isArray(obj.newTodos)) {
+    return obj.newTodos.length > 0 ? `updated ${obj.newTodos.length} todo item(s)` : 'cleared todo list';
+  }
 
   // Fallback: clip with reduced limit
   return clipToolResult(obj, Math.min(maxChars, 4000));
@@ -305,7 +308,7 @@ export function checkReadDedup(filePath, startLine, endLine, mtimeMs) {
 const READ_ONLY_TOOLS = new Set([
   'read', 'grep', 'glob', 'list',
   'ast_query', 'read_ast_node', 'generate_diff',
-  'list_services', 'get_service_status', 'get_service_logs'
+  'list_background_tasks', 'get_background_task'
 ]);
 
 // ─── Exported helpers ────────────────────────────────────────────────
@@ -370,19 +373,15 @@ export function summarizeToolResult(result) {
       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}` : ''}`;
+      const outputFile = trimInline(obj.output_file || '', 72);
+      const output = Array.isArray(obj.recent_output) ? trimInline(obj.recent_output.slice(-1)[0] || '', 96) : '';
+      return `${taskId || 'task'} ${status}${source ? ` (${source})` : ''}${outputFile ? ` -> ${outputFile}` : ''}${output ? `\n${output}` : ''}`;
     }
-    if ('services' in obj && Array.isArray(obj.services)) {
-      const count = obj.services.length;
-      const first = obj.services[0];
+    if ('tasks' in obj && Array.isArray(obj.tasks)) {
+      const count = obj.tasks.length;
+      const first = obj.tasks[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}` : ''}`;
+      return `tasks(${count})${lead ? `\n${lead}` : ''}`;
     }
     if ('files' in obj && Array.isArray(obj.files)) {
       return `patched ${obj.files.length} file(s)`;
@@ -397,6 +396,9 @@ export function summarizeToolResult(result) {
     if ('tasks' in obj && Array.isArray(obj.tasks)) {
       return `${obj.tasks.length} task(s)`;
     }
+    if ('newTodos' in obj && Array.isArray(obj.newTodos)) {
+      return obj.newTodos.length > 0 ? `updated ${obj.newTodos.length} todo item(s)` : 'cleared todo list';
+    }
     const keys = Object.keys(obj);
     return keys.length > 0 ? `keys: ${keys.slice(0, 5).join(',')}` : 'object';
   }
@@ -601,18 +603,17 @@ function formatToolDisplayName(name, args) {
     const target = trimInline(args?.path || args?.file || '.', 96) || '.';
     return `edit(${target})`;
   }
+  if (name === 'update_todos') {
+    return 'update_todos';
+  }
   if (name === 'patch') {
     const target = trimInline(args?.path || args?.file || args?.patch || '', 96) || '.';
     return `patch(${target})`;
   }
-  if (name === 'start_service') {
-    const command = trimInline(args?.command || args?.cmd || '', 96);
-    return command ? `${name}(${command})` : name;
-  }
-  if (name === 'list_services') {
+  if (name === 'list_background_tasks') {
     return name;
   }
-  if (name === 'get_service_status' || name === 'get_service_logs' || name === 'stop_service') {
+  if (name === 'get_background_task' || name === 'stop_background_task') {
     const taskId = trimInline(args?.task_id || args?.taskId || '', 96);
     return taskId ? `${name}(${taskId})` : name;
   }
@@ -691,7 +692,7 @@ export async function runAgentLoop({
     const assistantText = completion.text || '';
     lastAssistantText = assistantText || lastAssistantText;
 
-    const assistantMessage = { role: 'assistant', content: assistantText };
+    const assistantMessage = { role: 'assistant', content: completion?.content ?? assistantText };
     if (toolCalls.length > 0) {
       assistantMessage.tool_calls = toolCalls.map((tc) => ({
         id: tc.id,