@yeaft/webchat-agent 1.0.514 → 1.0.516

package/yeaft/tools/index.js

@@ -57,9 +57,7 @@ import listAgents from './list-agents.js';
 // --- P1 Routing tools (task-334d) ---
 import routeForward from './route-forward.js';
 
-// --- P1 Progress tracking ---
-import todoWrite from './todo-write.js';
-import startPlan from './start-plan.js';
+// --- P1 Durable work ---
 import createWorkItem from './create-work-item.js';
 
 // H2.f.4: user-facing thread tools (spawnThread/switchThread/listThreads/...)
@@ -69,9 +67,8 @@ import createWorkItem from './create-work-item.js';
 // Feature tools (FeatureCreate/Update/List/Get/Progress/Memory + Followup
 // + UpdatePlan + feature_summary_post) and the FeatureArc auto-creation
 // system were removed in 2026-05-13 — they were defined but never used in
-// production, contributing ~2900 lines of dead code. The TodoWrite tool
-// above replaces them as the actual progress-tracking surface the LLM
-// uses for multi-step tasks.
+// production, contributing ~2900 lines of dead code. Native checklist tools
+// are also retired; durable execution belongs to Work Center.
 
 // --- P2 Auxiliary tools ---
 // task-333b L1 delete: ToolSearch and WriteStdin removed — the function-call
@@ -127,9 +124,7 @@ export const allTools = [
   // P1 Routing (task-334d)
   routeForward,
 
-  // P1 Progress tracking
-  todoWrite,
-  startPlan,
+  // P1 Durable work
   createWorkItem,
 
   // P2 Auxiliary

package/yeaft/vp/vp-store.js

@@ -41,9 +41,8 @@ import { createHash } from 'crypto';
  * @property {'fast'|'primary'|undefined} modelHint
  * @property {string} persona         — markdown body (persona / system prompt seed)
  * @property {string} personaHash     — sha256(persona).slice(0,8); changes when persona body changes
- * @property {string} planInstruction — optional per-VP planning style (used by `StartPlan`
- *                                       tool); '' means "fall back to the default template".
- *                                       Frontmatter scalar key `planInstruction`.
+ * @property {string} planInstruction — legacy planning metadata, preserved verbatim for
+ *                                       compatibility; not consumed by native tools.
  * @property {string} dir             — absolute path to VP dir
  * @property {string} memoryDir       — absolute path to VP memory dir
  * @property {number} mtimeMs         — role.md mtime (for hot-reload)
@@ -187,10 +186,8 @@ export function loadVpFromDir(dir) {
     modelHint,
     persona: body,
     personaHash: personaHashValue,
-    // Optional per-VP planning style for the `StartPlan` tool. Stored as a
-    // raw scalar string in role.md frontmatter (`planInstruction: "..."`).
-    // Empty / missing → the tool falls back to the default template. Kept
-    // verbatim — the tool itself is responsible for any framing.
+    // Preserve legacy planning metadata without rewriting user-owned role.md.
+    // The retired native planning tools no longer consume this field.
     planInstruction: typeof meta.planInstruction === 'string' ? String(meta.planInstruction) : '',
     dir,
     memoryDir,

package/yeaft/web-bridge.js

@@ -760,25 +760,6 @@ function legacyProjectContext(yeaftDir, sessionId) {
   }, sessionId);
 }
 
-function buildProjectSharedBlock(projectContext, summaries = '') {
-  const context = normalizeProjectContext(projectContext, null);
-  const body = typeof summaries === 'string' ? summaries.trim() : '';
-  if (!context?.projectId && !body) return '';
-  const lines = ['[Project Shared Context]'];
-  if (context?.projectId) {
-    const label = context.projectName
-      ? `${context.projectName} (${context.projectId})`
-      : context.projectId;
-    lines.push(`Project: ${label}`);
-    lines.push('Sharing boundary: sibling Sessions in this Project on this Agent only.');
-  } else {
-    lines.push('Sharing boundary: sibling Sessions in the same Project on this Agent only.');
-  }
-  lines.push('Read-only memory summaries preserve each source Session identity.');
-  if (body) lines.push('', body);
-  return lines.join('\n');
-}
-
 function vpKey(sessionId, vpId) {
   return `${sessionId}::${vpId}`;
 }
@@ -5721,16 +5702,9 @@ async function runVpTurn({ prompt, promptParts = null, sessionId, vpId, threadId
           ? `${projectContext.projectName} (${projectContext.projectId})`
           : (projectContext?.projectId || '');
         queryOpts.projectInstruction = projectContext?.projectInstruction || '';
-        // Related Session summaries now enter through Engine's single AMS
-        // memory outlet. Keep this announcement limited to Project identity and
-        // sharing boundaries so parent VP prompts do not duplicate the same prose
-        // that sub-agents receive through memory.
-        const sharedBlock = buildProjectSharedBlock(projectContext);
-        if (sharedBlock) {
-          queryOpts.sessionAnnouncement = queryOpts.sessionAnnouncement
-            ? `${queryOpts.sessionAnnouncement}\n\n${sharedBlock}`
-            : sharedBlock;
-        }
+        // Project sibling identity remains available to Engine memory recall via
+        // projectSessionIds. Do not mirror internal sharing metadata into the
+        // user-authored Session announcement shown to the model.
       }
       let turnSessionMeta = null;
       try { turnSessionMeta = sessionCoordinator?.group?.getMeta?.() || null; } catch { turnSessionMeta = null; }
@@ -8238,7 +8212,6 @@ export function handleYeaftMcpReload(msg = {}) {
 export const __testHooks = {
   loadProjects,
   sharedProjectContext,
-  buildProjectSharedBlock,
   normalizeProjectContext,
   handleProjectContextSyncForTest(msg) {
     handleYeaftProjectContextSync(msg);

package/yeaft/templates/plan-instruction.md

@@ -1,45 +0,0 @@
-<!-- lang:en -->
-
-# Planning Mode
-
-You have just entered **planning mode** for the topic below. Your job is to think through the work, land a concrete plan via `TodoWrite`, and then continue executing the first step in the same turn. Do not stop after writing the plan unless the first step is genuinely blocked by user input.
-
-## How to think
-
-1. **Restate the problem in one sentence**: what success looks like, in plain language.
-2. **Surface the real constraints**: what is fixed, what is flexible, and where you would push back if the requirement is wrong.
-3. **Identify blocking unknowns**: list only the unknowns that materially affect the plan. If one blocks all progress, make the first step resolving it.
-4. **Choose an approach**: briefly compare it with one alternative and pick the simplest path that fits the scope.
-5. **Break the work into 3-7 ordered steps**. Each step should be one concrete unit of work.
-6. **Name the risks and validation**: what could go wrong, and what command, test, review, or inspection will prove the work is correct.
-
-## Required flow
-
-1. Write a short prose plan: problem, approach, risks.
-2. Call `TodoWrite` with the ordered steps. Mark exactly one item as `in_progress`.
-3. Emit `TodoWrite` with a first work-tool call in the same assistant response only when that call is already necessary and its arguments and safety do not depend on another result. Start with the smallest such call. If its result can change the next action, inspect it before issuing more calls; do not speculative-batch the investigation.
-
-If the first step is to ask the user a blocking question, ask it and stop. Otherwise keep moving.
-
-<!-- lang:zh -->
-
-# 规划模式
-
-你刚进入下面主题的**规划模式**。你的任务是先想清楚工作，使用 `TodoWrite` 写下可执行步骤，然后在同一轮继续执行第一步。不要只写完计划就停下，除非第一步确实需要用户输入才能继续。
-
-## 怎么思考
-
-1. **用一句话重述问题**：成功完成后应该是什么样子。
-2. **列出现实约束**：哪些固定、哪些可调整、哪些需求如果不合理需要明确指出。
-3. **识别阻塞未知**：只列真正影响计划的未知。如果某个未知阻塞全部进展，第一步就应该先解决它。
-4. **选择方案**：和一个备选方案简单比较，然后选择符合范围的最简单路径。
-5. **拆成 3-7 个有序步骤**：每一步都应该是一个具体工作单元。
-6. **说明风险和验证**：可能出什么问题，以及用什么命令、测试、review 或检查证明结果正确。
-
-## 必须执行的流程
-
-1. 写一段简短计划：问题、方案、风险。
-2. 调用 `TodoWrite` 写入有序步骤，并且只能把一个条目标记为 `in_progress`。
-3. 只有第一个工作工具调用已经确定有必要，且其参数和安全性都不依赖其他结果时，才在同一个 assistant response 中把它与 `TodoWrite` 一起发出。先执行满足条件的最小调用；如果它的结果可能改变下一动作，应先检查结果，不要推测性批量展开调查。
-
-如果第一步是向用户询问阻塞问题，那就提问并停下。否则继续推进。

package/yeaft/templates/tool-guidance.md

@@ -1,11 +0,0 @@
-<!-- lang:en -->
-
-## Active Tool Guidance
-
-{{guidance}}
-
-<!-- lang:zh -->
-
-## 当前工具指引
-
-{{guidance}}

package/yeaft/tools/start-plan.js

@@ -1,182 +0,0 @@
-/**
- * start-plan.js — StartPlan tool.
- *
- * Lightweight planning entry point inspired by Claude Code's plan mode.
- * Unlike Claude Code, we do NOT swap tools or change conversation state —
- * `StartPlan` is a regular tool. Its job is to push a planning instruction
- * back into the model's tool-result stream so the same turn produces a
- * short prose plan, a `TodoWrite` call to land the steps, and then keeps
- * going by starting the first step. The plan is the runway, not the
- * destination — the loop continues until the work is done (or until the
- * model legitimately needs the user, e.g. an unresolved unknown).
- *
- * Design:
- *   - Anyone can call it; the tool description tells the LLM when to.
- *   - The instruction text comes from one of two places, in order:
- *       1. The active VP's `planInstruction` frontmatter override
- *          (threaded through ctx.vpPersona.planInstruction by the
- *          engine; see engine.js #buildToolContext).
- *       2. The default template `templates/plan-instruction.md`
- *          loaded at module init by prompts.js.
- *   - The caller may pass guiding fields (stuckAt, userProblem,
- *     expectedScale, additionalContext) to help the model think — these
- *     are echoed back in the tool result so the planning turn can read
- *     them without re-asking the user.
- *   - Output is plain text (the instruction + the echo). No side effects,
- *     no persistence — the same turn that called StartPlan produces the
- *     plan, lands the steps via TodoWrite, and starts executing the first
- *     step (unless that first step is "ask the user", which is the one
- *     legitimate reason to stop here).
- *
- * The expected integration is TodoWrite: during the planning turn the LLM
- * issues a `TodoWrite` call enumerating the 1..N steps, then keeps going
- * and works the first step. The frontend already renders TodoWrite as a
- * checkbox-style list, so the user sees the plan materialize without any
- * new UI.
- */
-
-import { defineTool } from './types.js';
-import { getDefaultPlanInstruction } from '../prompts.js';
-
-export default defineTool({
-  name: 'StartPlan',
-  description: {
-    en: `Enter planning mode for a non-trivial task. Use BEFORE you start working when the request needs multiple steps, has unclear scope, or the user said "make a plan" / "think through this first".
-
-This tool returns a planning instruction. Use it to land a structured plan, then keep working in the same turn. The expected flow is:
-1. Produce a short prose plan (problem, approach, risks).
-2. Call \`TodoWrite\` with the ordered steps. Mark the first concrete step "in_progress", the rest "pending".
-3. Emit \`TodoWrite\` with a first work-tool call only when that call is already necessary and its arguments and safety do not depend on another result. Start with the smallest such call; inspect its result before issuing calls it could change or make unnecessary.
-
-WHEN TO USE:
-- Multi-step implementation (3+ steps), refactor, or open-ended investigation.
-- User explicitly asks for a plan, a TODO list, or to "think through" the work.
-- You're about to start a large change and want a checkpoint before diving in.
-
-WHEN NOT TO USE:
-- Single trivial change, single command run, lookup-style question.
-- Mid-execution — once you're past the first step, use TodoWrite directly.
-
-EXCEPTION — stop after the plan only if the first step is genuinely "ask the user" (an unresolved unknown that blocks every other step). Otherwise keep moving.
-
-The tool takes the topic plus optional guiding fields (stuckAt, userProblem, expectedScale, additionalContext) that help you think; they're echoed back verbatim, so don't repeat the full user request in \`topic\`.`,
-    zh: `进入规划模式，用于非平凡任务。在开始工作之前使用——当需求涉及多步骤、范围不明确，或用户说"先做个计划"/"先想清楚"时。
-
-此工具返回规划指令。用它产出一份结构化计划，然后在同一个 turn 中继续工作。预期流程是：
-1. 产出简短文字计划（问题、方法、风险）。
-2. 调用 TodoWrite 写出有序步骤。将第一个具体步骤标记为 "in_progress"，其余标记为 "pending"。
-3. 只有第一个工作工具调用已经确定有必要，且其参数和安全性都不依赖其他结果时，才在同一个 assistant response 中把它与 TodoWrite 一起发出。先执行满足条件的最小调用；如果结果可能改变或使后续调用不再必要，应先检查结果。
-
-何时使用：
-- 多步骤实现（3+ 步）、重构或开放式调查。
-- 用户明确要求计划、TODO 列表或"想清楚"再动手。
-- 你即将开始一个大型改动，想在动手前有个检查点。
-
-何时不使用：
-- 单个琐碎改动、单个命令执行、查询式问题。
-- 中途执行——一旦过了第一步，直接用 TodoWrite。
-
-例外——只有当第一步确实是"询问用户"（一个未解决的未知因素，阻塞所有其他步骤）时才在计划后停止。否则继续前进。
-
-此工具接收 topic 加上可选引导字段（stuckAt、userProblem、expectedScale、additionalContext）
-帮助你思考；它们会被原样回显，所以不要在 topic 中重复完整的用户请求。`
-  },
-  parameters: {
-    type: 'object',
-    properties: {
-      topic: {
-        type: 'string',
-        description: {
-          en: 'One-sentence statement of what is being planned (e.g. "Add dark-mode toggle to YeaftPage settings").',
-          zh: '用一句话说明要规划什么（如"为 YeaftPage 设置添加深色模式切换"）',
-        },
-      },
-      userProblem: {
-        type: 'string',
-        description: {
-          en: 'Optional. The underlying problem the user is trying to solve (often broader than the immediate ask).',
-          zh: '可选。用户试图解决的根本问题（通常比即时请求更宽泛）',
-        },
-      },
-      stuckAt: {
-        type: 'string',
-        description: {
-          en: 'Optional. If you are blocked or unsure, the specific decision or unknown that needs resolving first.',
-          zh: '可选。如果你被阻塞或不确定，需要首先解决的具体决策或未知点',
-        },
-      },
-      expectedScale: {
-        type: 'string',
-        description: {
-          en: 'Optional. Rough scope estimate — number of files touched, lines of code, time horizon, etc.',
-          zh: '可选。粗略范围估计 — 涉及文件数、代码行数、时间预期等',
-        },
-      },
-      additionalContext: {
-        type: 'string',
-        description: {
-          en: 'Optional. Any other facts that shape the plan (constraints, deadlines, related prior work).',
-          zh: '可选。影响计划的其他事实（约束、截止日期、相关先前工作）',
-        },
-      },
-    },
-    required: ['topic'],
-  },
-  isConcurrencySafe: () => true,
-  isReadOnly: () => true,
-  async execute(input, ctx) {
-    const topic = typeof input?.topic === 'string' ? input.topic.trim() : '';
-    if (!topic) {
-      // Plain-text error — same shape as the success path so the LLM
-      // doesn't need a JSON-vs-text branch to read this tool's output.
-      return 'Error: topic is required (one-sentence statement of what is being planned).';
-    }
-
-    // Resolve the planning instruction: per-VP override first, then default.
-    // `ctx.vpPersona.planInstruction` is wired by engine.js #buildToolContext;
-    // it's the empty string when the VP has no override, or when the call is
-    // not VP-scoped (test ctx, sub-agent ctx without persona). We tolerate
-    // both shapes and fall through to the default template silently.
-    const language = typeof ctx?.config?.language === 'string' ? ctx.config.language : 'en';
-    const vpOverride = typeof ctx?.vpPersona?.planInstruction === 'string'
-      ? ctx.vpPersona.planInstruction.trim()
-      : '';
-    const instruction = vpOverride || getDefaultPlanInstruction(language);
-
-    // Echo the optional guiding fields back so the planning turn has them
-    // without re-reading the user's original message. Skip empty strings.
-    const echoed = {};
-    for (const key of ['userProblem', 'stuckAt', 'expectedScale', 'additionalContext']) {
-      const v = typeof input?.[key] === 'string' ? input[key].trim() : '';
-      if (v) echoed[key] = v;
-    }
-
-    // Plain text is friendlier to the LLM than JSON for an instructional
-    // result. The shape: a tagged instruction block, then a compact
-    // YAML-ish echo of the guiding fields, then a one-line nudge to land
-    // the plan via TodoWrite.
-    const lines = [];
-    lines.push('<plan-instruction>');
-    lines.push(instruction);
-    lines.push('</plan-instruction>');
-    lines.push('');
-    lines.push('<topic>');
-    lines.push(topic);
-    lines.push('</topic>');
-    if (Object.keys(echoed).length > 0) {
-      lines.push('');
-      lines.push('<guiding-context>');
-      for (const [k, v] of Object.entries(echoed)) {
-        lines.push(`${k}: ${v}`);
-      }
-      lines.push('</guiding-context>');
-    }
-    lines.push('');
-    const nextInstruction = String(language).toLowerCase().startsWith('zh')
-      ? '下一步：产出计划并调用 `TodoWrite`。只有第一个工作工具调用已经确定有必要，且其参数和安全性都不依赖其他结果时，才在同一个 assistant response 中发出这个最小调用；如果结果可能改变后续调用，先检查结果。只有第一步必须询问用户时才在计划后停下。'
-      : 'Next: produce the plan and call `TodoWrite`. Emit only the smallest first work-tool call whose necessity, arguments, and safety do not depend on another result; inspect its result before calls it could change. Stop after the plan only when the first step must ask the user.';
-    lines.push(nextInstruction);
-
-    return lines.join('\n');
-  },
-});

package/yeaft/tools/todo-write.js

@@ -1,174 +0,0 @@
-/**
- * todo-write.js — TodoWrite tool: per-VP multi-step task tracking.
- *
- * Mirrors Claude Code's `TodoWrite` tool 1:1 in shape (name + `todos[]`
- * with `content` / `status` / `activeForm`) so the existing frontend
- * rendering pipeline (`MessageList.js:691` → `AssistantTurn.js:53-63`
- * → `ToolLine.js:150`) renders a checkmark-style list automatically
- * without any new UI code. The frontend reads the *input* of the
- * `tool_use` event — not the result — so this tool's persistence story
- * is "stamp into the LLM event stream and cache on ctx for replay."
- *
- * Per-thread isolation: each running VP thread keeps its own current todo
- * list. The web-bridge injects `ctx.getCurrentTodos()` /
- * `ctx.setCurrentTodos()` pointing at a per-(sessionId,vpId,threadId) slot so
- * two concurrent threads for the same VP cannot overwrite each other's
- * progress.
- *
- * Reference: plan §2 (2026-05-13 — Feature system retired, TodoWrite
- * added as the actual progress-tracking surface for the LLM).
- */
-
-import { defineTool } from './types.js';
-
-const VALID_STATUS = new Set(['pending', 'in_progress', 'completed']);
-
-export default defineTool({
-  name: 'TodoWrite',
-  description: {
-    en: `Track multi-step task progress with a checklist that the user can see ticked off in real time.
-
-WHEN TO USE:
-- The task has 3+ meaningful steps, or
-- The user gave you a list of things to do (numbered/comma-separated), or
-- You're about to start a non-trivial, multi-file change.
-
-FIRST CALL — PLAN WITHOUT AN EXTRA MODEL ROUND:
-- Write a short visible prose plan in the same assistant response: problem, approach, and risks.
-- Call TodoWrite directly; do not call a separate planning-mode tool first.
-- Emit TodoWrite beside the first work-tool call only when that call is already necessary and its arguments and safety do not depend on another result. Start with the smallest such call.
-
-HOW TO USE:
-- First call: enumerate all the todos with status "pending", set exactly one to "in_progress".
-- Each subsequent call: rewrite the FULL list — mark the just-finished item "completed", mark the next item "in_progress".
-- AT MOST one item may be "in_progress" at any time.
-- \`content\` is the imperative form ("Run tests"); \`activeForm\` is the present-continuous shown during execution ("Running tests").
-
-BATCH WITH WORK:
-- Avoid an intermediate TodoWrite-only model round only when the next work-tool call passes the necessity, argument-independence, and safety-independence test. Emit that minimal call beside TodoWrite.
-- Do not speculative-batch an investigation. Mark work completed only after evidence, and inspect a pending result before issuing any call it could change, invalidate, or make unnecessary.
-- A standalone TodoWrite remains valid when no work tool should follow, including final completion or a blocking user question.
-
-WHEN NOT TO USE:
-- Single trivial change, single command run, pure conversation/question.`,
-    zh: `用 checklist 跟踪多步骤任务进度，用户可以实时看到勾选。
-
-何时使用：
-- 任务有 3 步或以上有意义步骤，或
-- 用户给了你一份待办列表（编号/逗号分隔），或
-- 你即将开始一个非平凡的多文件改动。
-
-首次调用——不要浪费额外模型回合进入规划模式：
-- 在同一个 assistant response 中先写简短可见计划：问题、方案和风险。
-- 直接调用 TodoWrite，不要先调用单独的规划模式工具。
-- 只有第一个工作工具调用已经确定有必要，且其参数和安全性都不依赖其他结果时，才把它与 TodoWrite 在同一响应中发出；先执行满足条件的最小调用。
-
-如何使用：
-- 首次调用：枚举所有 todo，状态为 "pending"，将其中恰好一个设为 "in_progress"。
-- 每次后续调用：重写完整列表——将刚完成的项标记为 "completed"，将下一项标记为 "in_progress"。
-- 任何时候最多只能有一个 "in_progress"。
-- content 是祈使形式（如 "Run tests"）；activeForm 是执行时显示的进行时态（如 "Running tests"）。
-
-和工作工具合批：
-- 只有下一个工作工具调用通过必要性、参数独立性和安全独立性检查时，才避免让中间状态的 TodoWrite 单独占一个模型回合；把这个最小调用与 TodoWrite 一起发出。
-- 不要推测性批量展开调查。只有已有证据时才能把工作标记为完成；如果待返回结果可能改变、否定或使后续调用不再必要，应先检查该结果。
-- 没有工作工具应继续执行时（包括记录最终完成态或询问阻塞问题），TodoWrite 仍可单独调用。
-
-何时不使用：
-- 单个琐碎改动、单个命令执行、纯对话/提问。`
-  },
-  parameters: {
-    type: 'object',
-    properties: {
-      todos: {
-        type: 'array',
-        description: {
-          en: 'The full current todo list. Always send the entire list, not a diff.',
-          zh: '当前完整的待办清单。始终发送整个列表，而非增量。',
-        },
-        items: {
-          type: 'object',
-          properties: {
-            content: {
-              type: 'string',
-              description: {
-          en: 'Imperative description of the step (e.g. "Run tests").',
-          zh: '步骤的命令式描述（如 "Run tests"）。',
-        },
-            },
-            status: {
-              type: 'string',
-              enum: ['pending', 'in_progress', 'completed'],
-              description: {
-          en: 'Current state. At most one item may be "in_progress".',
-          zh: '当前状态。最多只能有一项为 "in_progress"。',
-        },
-            },
-            activeForm: {
-              type: 'string',
-              description: {
-          en: 'Present-continuous form shown while executing (e.g. "Running tests").',
-          zh: '执行中展示的进行时描述（如 "Running tests"）。',
-        },
-            },
-          },
-          required: ['content', 'status', 'activeForm'],
-        },
-      },
-    },
-    required: ['todos'],
-  },
-  isConcurrencySafe: () => false,
-  isReadOnly: () => true,
-  async execute(input, ctx) {
-    const todos = input && Array.isArray(input.todos) ? input.todos : null;
-    if (!todos || todos.length === 0) {
-      return JSON.stringify({ error: 'todos must be a non-empty array' });
-    }
-
-    let inProgressCount = 0;
-    for (let i = 0; i < todos.length; i++) {
-      const t = todos[i];
-      if (!t || typeof t !== 'object') {
-        return JSON.stringify({ error: `todos[${i}] must be an object` });
-      }
-      if (typeof t.content !== 'string' || !t.content.trim()) {
-        return JSON.stringify({ error: `todos[${i}].content must be a non-empty string` });
-      }
-      if (typeof t.activeForm !== 'string' || !t.activeForm.trim()) {
-        return JSON.stringify({ error: `todos[${i}].activeForm must be a non-empty string` });
-      }
-      if (!VALID_STATUS.has(t.status)) {
-        return JSON.stringify({
-          error: `todos[${i}].status must be one of: pending, in_progress, completed`,
-        });
-      }
-      if (t.status === 'in_progress') inProgressCount += 1;
-    }
-
-    if (inProgressCount > 1) {
-      return JSON.stringify({
-        error: `at most one todo may be in_progress at a time (found ${inProgressCount})`,
-      });
-    }
-
-    // Cache the current todo list onto the per-VP slot if the web-bridge
-    // provided one. Best-effort: this is the cache the frontend may pull
-    // on reconnect / VP-switch. Tools should not crash if the slot is
-    // missing — sub-agent ctx or test ctx may lack it.
-    if (ctx && typeof ctx.setCurrentTodos === 'function') {
-      try { ctx.setCurrentTodos(todos.slice()); } catch { /* swallow */ }
-    }
-
-    const counts = { pending: 0, in_progress: 0, completed: 0 };
-    for (const t of todos) counts[t.status] += 1;
-
-    return JSON.stringify({
-      success: true,
-      count: todos.length,
-      pending: counts.pending,
-      in_progress: counts.in_progress,
-      completed: counts.completed,
-    });
-  },
-});