codemini-cli 0.4.4 → 0.4.6

package/src/core/chat-runtime.js

@@ -1,10 +1,11 @@
 import { parseInput } from './input-parser.js';
-import { loadCommandsAndSkills, renderCommandPrompt } from './command-loader.js';
+import { formatLocalDate, loadCommandsAndSkills, renderCommandPrompt } from './command-loader.js';
 import { runAgentLoop } from './agent-loop.js';
 import { setResultDir, clearResultStore } from './tool-result-store.js';
 import { trimInline, normalizePath } from './string-utils.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import {
   createChatCompletion,
   createChatCompletionStream
@@ -38,6 +39,8 @@ import {
 } from './reflect-skill.js';
 
 const STREAM_SAVE_DEBOUNCE_MS = 120;
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_REQUIREMENTS_TEMPLATE = path.resolve(MODULE_DIR, '..', '..', 'templates', 'project-requirements', 'report-shell.html');
 
 function toOpenAIMessages(sessionMessages) {
   const mapped = [];
@@ -312,12 +315,25 @@ export const ROLE_TOOL_POLICY = {
   coder: ['read', 'grep', 'list', 'edit', 'write', 'delete', 'run', 'ast_query', 'read_ast_node', 'glob', 'tool_search', 'web_fetch', 'web_search', 'update_todos', 'read_plan', 'update_plan'],
   reviewer: ['read', 'grep', 'list', 'glob', 'tool_search', 'ast_query', 'read_ast_node', 'read_plan'],
   tester: ['read', 'grep', 'list', 'run', 'glob', 'tool_search', 'read_plan'],
-  summarizer: ['read_plan']
+  summarizer: ['read', 'read_plan']
 };
 const SUB_AGENT_CONTEXT_MAX_MESSAGES = 4;
 const SUB_AGENT_CONTEXT_MAX_CHARS = 1200;
 const SUB_AGENT_EVIDENCE_MAX_ITEMS = 3;
 const SUB_AGENT_HANDOFF_MAX_ITEMS = 6;
+const PROJECT_REQUIREMENTS_SECTION_MARKERS = [
+  { key: 'summary', marker: 'REQUIREMENTS_SUMMARY', labels: ['1', 'summary', 'overview', 'project overview', 'executive summary', '项目概述', '项目总览', '概述'] },
+  { key: 'architecture', marker: 'REQUIREMENTS_ARCHITECTURE', labels: ['2', 'architecture', 'system architecture', 'system map', '架构', '系统架构图', '系统架构', '架构图'] },
+  { key: 'interfaces', marker: 'REQUIREMENTS_INTERFACE_INVENTORY', labels: ['3', 'interface inventory', 'interfaces', 'api inventory', '接口清单', '接口', 'api清单'] },
+  { key: 'requirements', marker: 'REQUIREMENTS_API_CARDS', labels: ['4', 'requirement cards', 'api cards', 'interface requirements', '接口需求卡片', '需求卡片'] },
+  { key: 'flows', marker: 'REQUIREMENTS_FLOWS', labels: ['5', 'flows', 'user flows', 'core flows', '核心用户流程', '用户流程', '流程'] },
+  { key: 'domain', marker: 'REQUIREMENTS_DOMAIN_MODEL', labels: ['6', 'domain model', 'data ownership', 'domain', '领域模型', '数据归属', '领域模型与数据归属'] },
+  { key: 'security', marker: 'REQUIREMENTS_SECURITY', labels: ['7', 'security', 'permissions', 'compliance', '权限', '安全', '合规', '权限、安全与合规'] },
+  { key: 'errors', marker: 'REQUIREMENTS_ERROR_HANDLING', labels: ['8', 'errors', 'edge cases', 'error handling', '异常处理', '边界情况', '异常处理与边界情况'] },
+  { key: 'nonfunctional', marker: 'REQUIREMENTS_NONFUNCTIONAL', labels: ['9', 'non-functional', 'nonfunctional', 'nfr', '非功能性需求', '非功能'] },
+  { key: 'questions', marker: 'REQUIREMENTS_OPEN_QUESTIONS', labels: ['10', 'open questions', 'unknowns', '待确认问题', '待确认', '问题'] },
+  { key: 'evidence', marker: 'REQUIREMENTS_EVIDENCE_INDEX', labels: ['11', 'evidence', 'source evidence', 'source evidence index', '源码证据索引', '证据索引', '源码证据'] }
+];
 const PLAN_MEMORY_MARKERS = {
   findings: ['<!-- plan-findings-start -->', '<!-- plan-findings-end -->'],
   progress: ['<!-- plan-progress-start -->', '<!-- plan-progress-end -->']
@@ -395,6 +411,7 @@ export function getSubAgentRolePrompt(role) {
       'You are the summarizer in a multi-step agent pipeline.',
       'Your job is to synthesize the results of all prior steps into a concise, actionable final summary.',
       'Do NOT re-analyze the codebase or make new tool calls unless the handed-off evidence is clearly insufficient.',
+      'You may read handed-off artifact files, such as generated reports, when needed to summarize or verify their existence.',
       'Instead, read the accumulated step results in the plan file context provided to you.',
       'Output format — keep it short and direct:',
       'Summary:',
@@ -2708,6 +2725,16 @@ async function executePlanWithSubAgents({
     const step = steps[i];
     if (signal?.aborted) break;
 
+    emitPlanEvent({
+      type: 'plan:progress',
+      planFile: planFilePath,
+      step: i + 1,
+      total: steps.length,
+      role: step.role,
+      title: step.title,
+      status: 'running'
+    });
+
     emitPlanEvent({
       type: 'assistant:delta',
       text: `\n[plan] Step ${i + 1}/${steps.length} -> ${step.role}: ${step.title}\n`
@@ -2771,6 +2798,17 @@ async function executePlanWithSubAgents({
       );
     }
 
+    emitPlanEvent({
+      type: 'plan:progress',
+      planFile: planFilePath,
+      step: i + 1,
+      total: steps.length,
+      role: step.role,
+      title: step.title,
+      status: stepRecord.failed ? 'failed' : 'done',
+      summary: stepRecord.failed ? stepRecord.failureReason : trimInline(stepRecord.output, 160)
+    });
+
     if (stepRecord.failed && i < steps.length - 1) {
       const summarizerIndex = steps.findIndex((candidate, index) => index > i && candidate.role === 'summarizer');
       if (summarizerIndex > i) {
@@ -2968,6 +3006,386 @@ function renderAutoPlanMarkdown({
   return lines.join('\n');
 }
 
+function parseProjectRequirementsOptions(args = []) {
+  const raw = args.join(' ').trim();
+  const normalized = raw.toLowerCase();
+  const hasIgnoreIntent = /(忽略|跳过|不生成|不要|无需|排除|exclude|skip|omit|without|no\s+)/i.test(raw);
+  if (!hasIgnoreIntent) return { raw, ignoredSections: [] };
+
+  const ignored = [];
+  for (const section of PROJECT_REQUIREMENTS_SECTION_MARKERS) {
+    const matched = section.labels.some((label) => {
+      const value = String(label).toLowerCase();
+      if (/^\d+$/.test(value)) {
+        return new RegExp(`(^|[^0-9])${value}([^0-9]|$)`).test(normalized);
+      }
+      return normalized.includes(value);
+    });
+    if (matched) ignored.push(section);
+  }
+  return { raw, ignoredSections: ignored };
+}
+
+function renderProjectRequirementsSectionContract(ignoredSections = []) {
+  const ignored = new Set(ignoredSections.map((section) => section.marker));
+  const required = PROJECT_REQUIREMENTS_SECTION_MARKERS
+    .filter((section) => !ignored.has(section.marker))
+    .map((section) => section.marker);
+  const lines = [`Required marker sections: ${required.join(', ')}.`];
+  if (ignoredSections.length > 0) {
+    lines.push(`User-requested omitted sections: ${ignoredSections.map((section) => `${section.key} (${section.marker})`).join(', ')}.`);
+    lines.push('For omitted sections, leave the shell section visibly marked as omitted and do not spend analysis or writing budget filling it.');
+  }
+  return lines.join('\n');
+}
+
+function buildProjectRequirementsSteps(renderedSkillPrompt, args = []) {
+  const options = parseProjectRequirementsOptions(args);
+  const userArgs = args.join(' ').trim();
+  const requestedFocus = userArgs ? `User request/focus: ${userArgs}` : 'User request/focus: full workspace requirements report.';
+  const reportDate = formatLocalDate();
+  const reportPath = `docs/requirements/${reportDate}-project-requirements.html`;
+  const companionPath = `docs/requirements/${reportDate}-project-requirements.md`;
+  const reportContract = [
+    requestedFocus,
+    `Primary report path: ${reportPath}`,
+    `Optional companion Markdown path: ${companionPath}`,
+    'A pre-created HTML shell already exists at the primary report path.',
+    'Fill or replace only the named marker sections in that shell instead of rewriting the whole document.',
+    renderProjectRequirementsSectionContract(options.ignoredSections),
+    'For diagrams, write polished inline HTML/CSS or SVG directly in the report. Do not use Mermaid unless the user explicitly asks for Mermaid source.',
+    'Use a light blue, white, and cool gray banking/financial visual style: conservative, dense, readable, and enterprise-grade.',
+    'Prioritize API/interface-level business requirements. Every major interface should map to business capability, actor, trigger, inputs, outputs, rules, permissions, data reads/writes, errors, acceptance criteria, and evidence.',
+    'Use EXTRACTED, INFERRED, and UNKNOWN labels. Preserve source evidence paths.',
+    'Do not invent dates; use the report paths above.'
+  ].join('\n');
+
+  return [
+    {
+      title: '🧭 Map entry points and evidence sources',
+      role: 'planner',
+      task: [
+        'Map project entry points and evidence sources before any report writing.',
+        reportContract,
+        'Inspect top-level docs, package manifests, route/command entry points, tests, and obvious interface files.',
+        'Produce a concise evidence map grouped by docs, routes/commands, handlers, schemas, tests, configuration, storage, and operations.',
+        'Include evidence paths and open questions. Do not write the final report.'
+      ].join('\n')
+    },
+    {
+      title: '📚 Build API and interface inventory',
+      role: 'planner',
+      task: [
+        'Build the canonical API/interface inventory using the evidence map.',
+        reportContract,
+        'Enumerate every major HTTP endpoint, CLI command, tool call, MCP/RPC handler, queue/scheduled job, exported SDK function, and user-facing workflow entry point.',
+        'For each item include type, route/command/function, owner module, evidence path, likely actor, and whether it is EXTRACTED, INFERRED, or UNKNOWN.',
+        'Do not write the final report.'
+      ].join('\n')
+    },
+    {
+      title: '🧩 Decompose business requirements per API',
+      role: 'advisor',
+      task: [
+        'Decompose business requirements for each major API/interface from the inventory.',
+        reportContract,
+        'For each interface capture business capability, actor, user goal, trigger, inputs, outputs, preconditions, main flow, alternate flows, business rules, acceptance criteria, and open questions.',
+        'Keep findings API-centered rather than module-centered. Do not write the final report.'
+      ].join('\n')
+    },
+    {
+      title: '🔐 Analyze validation, permissions, and compliance',
+      role: 'advisor',
+      task: [
+        'Analyze validation, authorization, security, audit, and compliance implications per API/interface.',
+        reportContract,
+        'For each relevant interface identify validation rules, permission checks, sensitive data, audit/traceability needs, policy constraints, retry/rollback behavior, and UNKNOWN compliance gaps.',
+        'Return requirement-ready findings with evidence paths. Do not write the final report.'
+      ].join('\n')
+    },
+    {
+      title: '💾 Map data ownership and state changes',
+      role: 'advisor',
+      task: [
+        'Map data ownership, storage paths, state transitions, and side effects per API/interface.',
+        reportContract,
+        'Identify data reads, data writes, config/session/memory/file/database ownership, lifecycle states, cache/index behavior, external dependencies, and operational side effects.',
+        'Return requirement-ready findings with evidence paths. Do not write the final report.'
+      ].join('\n')
+    },
+    {
+      title: '🔄 Connect user flows to API dependencies',
+      role: 'advisor',
+      task: [
+        'Connect user-facing flows to the API/interface inventory and implementation dependencies.',
+        reportContract,
+        'Create flow-ready findings for core journeys, API dependency maps, sequence summaries, error paths, and cross-interface handoffs.',
+        'Favor clear business process decomposition over broad architecture prose. Do not write the final report.'
+      ].join('\n')
+    },
+    {
+      title: '🎨 Write banking-style requirements HTML report',
+      role: 'coder',
+      task: [
+        'Create the final project requirements report from the accumulated plan context.',
+        reportContract,
+        'Follow the project-requirements skill instructions below exactly, including chunked HTML writing for medium/large reports.',
+        'Use the blue/white/gray banking-style shell and produce polished inline HTML/CSS/SVG diagrams. Keep the report professional, light, and conservative.',
+        'Organize the main requirements section primarily by API/interface business requirement cards.',
+        'The final HTML must be self-contained and directly openable from disk.',
+        'Write the primary report to the exact primary report path above. Create the companion Markdown only if useful.',
+        'Skill instructions:',
+        renderedSkillPrompt
+      ].join('\n\n')
+    },
+    {
+      title: '🔎 Review API coverage and traceability',
+      role: 'reviewer',
+      task: [
+        'Review the generated requirements report against the project-requirements contract and accumulated evidence.',
+        reportContract,
+        'Check that major APIs/interfaces are represented, business requirements are decomposed per API, evidence paths are present, inferred/unknown content is labeled, diagrams are visible as inline HTML/CSS/SVG without external rendering libraries, and the report path matches the required local date.',
+        'Check that the visual style is light blue/white/gray and suitable for banking/financial review.',
+        'Report concrete gaps and risks only. Do not rewrite the whole report.'
+      ].join('\n')
+    },
+    {
+      title: '🧾 Summarize final report and unresolved questions',
+      role: 'summarizer',
+      task: [
+        'Synthesize the project requirements pipeline results into a concise final status for the user.',
+        reportContract,
+        'Mention the generated report path, API/interface coverage, strongest business requirement findings, unresolved questions, what was not verified, and the best next action.',
+        'Do not re-analyze the codebase unless the accumulated evidence is clearly insufficient.'
+      ].join('\n')
+    }
+  ];
+}
+
+function renderProjectRequirementsPlanMarkdown({ goal, steps, reportPath, companionPath }) {
+  const autoPlan = {
+    summary: 'Dedicated sub-agent pipeline for project requirements discovery and HTML report generation.',
+    steps
+  };
+  const progressLines = steps
+    .map((step, index) => `- [ ] Step ${index + 1} [${step.role}] ${step.title}`)
+    .join('\n');
+  return [
+    `# Project Requirements Pipeline: ${goal}`,
+    '',
+    `Primary Report: ${reportPath}`,
+    `Optional Companion: ${companionPath}`,
+    '',
+    renderAutoPlanMarkdown({
+      goal,
+      autoPlan,
+      finalSummary: 'Project requirements pipeline created and will execute immediately.',
+      approvalText: 'No approval required. Triggered explicitly by /project-requirements.',
+      progressLine: progressLines
+    })
+  ].join('\n');
+}
+
+function replaceTemplateVariables(template, variables) {
+  let out = String(template || '');
+  for (const [key, value] of Object.entries(variables || {})) {
+    out = out.replaceAll(`{{${key}}}`, String(value ?? ''));
+  }
+  return out;
+}
+
+async function createProjectRequirementsShell({
+  reportPath,
+  companionPath,
+  manifestPath,
+  planFile,
+  goal,
+  steps
+}) {
+  const workspaceRoot = process.cwd();
+  const absoluteReportPath = path.resolve(workspaceRoot, reportPath);
+  const absoluteManifestPath = path.resolve(workspaceRoot, manifestPath);
+  await fs.mkdir(path.dirname(absoluteReportPath), { recursive: true });
+  const template = await fs.readFile(PROJECT_REQUIREMENTS_TEMPLATE, 'utf8');
+  const now = new Date().toISOString();
+  const html = replaceTemplateVariables(template, {
+    title: 'Project Requirements Report',
+    workspace_name: path.basename(workspaceRoot) || workspaceRoot,
+    date: formatLocalDate(),
+    generated_at: now
+  });
+  await fs.writeFile(absoluteReportPath, html, 'utf8');
+
+  const sectionNames = [
+    'summary',
+    'architecture',
+    'interfaces',
+    'requirements',
+    'flows',
+    'domain',
+    'security',
+    'errors',
+    'nonfunctional',
+    'questions',
+    'evidence'
+  ];
+  const manifest = {
+    status: 'running',
+    goal,
+    html: reportPath,
+    markdown: companionPath,
+    manifest: manifestPath,
+    plan: planFile,
+    createdAt: now,
+    updatedAt: now,
+    sections: Object.fromEntries(sectionNames.map((name) => [name, 'pending'])),
+    steps: steps.map((step, index) => ({
+      step: index + 1,
+      role: step.role,
+      title: step.title,
+      status: 'pending'
+    }))
+  };
+  await fs.writeFile(absoluteManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+  return manifest;
+}
+
+async function updateProjectRequirementsManifest(manifestPath, updates = {}) {
+  if (!manifestPath) return;
+  try {
+    const absoluteManifestPath = path.resolve(process.cwd(), manifestPath);
+    const current = JSON.parse(await fs.readFile(absoluteManifestPath, 'utf8'));
+    const next = {
+      ...current,
+      ...updates,
+      updatedAt: new Date().toISOString()
+    };
+    await fs.writeFile(absoluteManifestPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+  } catch {
+    // Manifest is best-effort; plan file and events remain the source of truth.
+  }
+}
+
+async function runProjectRequirementsPipeline({
+  custom,
+  parsedInput,
+  currentSession,
+  config,
+  model,
+  systemPrompt,
+  onAgentEvent,
+  signal,
+  onSubSessionActive
+}) {
+  const renderedSkillPrompt = await expandFileMentions(renderCommandPrompt(custom, parsedInput.args), process.cwd());
+  const userFocus = parsedInput.args.join(' ').trim();
+  const goal = userFocus ? `project requirements report: ${userFocus}` : 'project requirements report';
+  const reportDate = formatLocalDate();
+  const reportPath = `docs/requirements/${reportDate}-project-requirements.html`;
+  const companionPath = `docs/requirements/${reportDate}-project-requirements.md`;
+  const manifestPath = `docs/requirements/${reportDate}-project-requirements.manifest.json`;
+  const steps = buildProjectRequirementsSteps(renderedSkillPrompt, parsedInput.args);
+  const planFile = await writeMarkdownInProjectDir(
+    'plans',
+    'project-requirements-pipeline',
+    renderProjectRequirementsPlanMarkdown({ goal, steps, reportPath, companionPath }),
+    'project-requirements',
+    currentSession.id
+  );
+  await createProjectRequirementsShell({
+    reportPath,
+    companionPath,
+    manifestPath,
+    planFile,
+    goal,
+    steps
+  });
+  const planState = {
+    status: 'approved',
+    source: 'project-requirements',
+    goal,
+    filePath: planFile,
+    summary: 'Dedicated sub-agent pipeline for project requirements report generation.',
+    finalSummary: 'Executing project requirements pipeline.',
+    steps
+  };
+  if (onAgentEvent) {
+    onAgentEvent({ type: 'skill:start', name: custom.name });
+    onAgentEvent({
+      type: 'plan:progress',
+      planFile,
+      reportPath,
+      manifestPath,
+      step: 0,
+      total: steps.length,
+      status: 'created',
+      summary: 'Project requirements pipeline created'
+    });
+  }
+  let execution;
+  try {
+    execution = await executePlanWithSubAgents({
+      planState,
+      parentSession: currentSession,
+      config,
+      model,
+      systemPrompt,
+      onAgentEvent,
+      signal,
+      onSubSessionActive
+    });
+  } catch (error) {
+    if (onAgentEvent) {
+      onAgentEvent({
+        type: 'skill:error',
+        name: custom.name,
+        summary: error instanceof Error ? error.message : String(error)
+      });
+    }
+    throw error;
+  }
+  if (onAgentEvent) {
+    onAgentEvent({
+      type: 'plan:progress',
+      planFile,
+      reportPath,
+      manifestPath,
+      step: steps.length,
+      total: steps.length,
+      status: execution.aborted ? 'aborted' : 'done',
+      summary: 'Project requirements pipeline finished'
+    });
+    onAgentEvent({ type: 'skill:end', name: custom.name });
+  }
+  const failedCount = Array.isArray(execution.results)
+    ? execution.results.filter((item) => item.failed).length
+    : 0;
+  await updateProjectRequirementsManifest(manifestPath, {
+    status: execution.aborted ? 'aborted' : failedCount > 0 ? 'failed' : 'completed',
+    failedCount
+  });
+  const text = [
+    execution.text || '',
+    '',
+    'Project requirements pipeline completed.',
+    `Plan File: ${planFile}`,
+    `Report Path: ${reportPath}`,
+    `Manifest: ${manifestPath}`,
+    `Steps: ${steps.length} total`,
+    `Failed: ${failedCount}`
+  ]
+    .filter(Boolean)
+    .join('\n');
+  return {
+    type: 'assistant',
+    text,
+    planFile,
+    reportPath,
+    manifestPath,
+    aborted: !!execution.aborted
+  };
+}
+
 async function revisePendingPlanWithModel({
   planState,
   feedback,
@@ -4541,6 +4959,23 @@ export async function createChatRuntime({
       if (custom.metadata.type === 'skill' && !isSkillEnabled(config, custom.name, custom)) {
         return { type: 'system', text: `Skill is disabled: ${custom.name}` };
       }
+      if (custom.metadata.type === 'skill' && custom.name === 'project-requirements') {
+        try {
+          return await runProjectRequirementsPipeline({
+            custom,
+            parsedInput,
+            currentSession,
+            config,
+            model,
+            systemPrompt: activeReplySystemPrompt,
+            onAgentEvent,
+            signal,
+            onSubSessionActive: (sub) => { activeSubSession = sub; }
+          });
+        } finally {
+          activeSubSession = null;
+        }
+      }
 
       const customPrompt =
         custom.name === 'brainstorm'

package/src/core/command-loader.js

@@ -178,6 +178,14 @@ function loadInstalledSkillsFromRegistry(baseDir, registry, out) {
   }
 }
 
+export function formatLocalDate(date = new Date()) {
+  const value = date instanceof Date ? date : new Date(date);
+  const year = value.getFullYear();
+  const month = String(value.getMonth() + 1).padStart(2, '0');
+  const day = String(value.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
 function substituteVariables(text, args = []) {
   let out = text;
   args.forEach((arg, index) => {
@@ -185,6 +193,7 @@ function substituteVariables(text, args = []) {
   });
   out = out.replaceAll('{{args}}', args.join(' '));
   out = out.replaceAll('{{cwd}}', process.cwd());
+  out = out.replaceAll('{{date}}', formatLocalDate());
   return out;
 }
 

package/src/core/fff-adapter.js

@@ -111,7 +111,7 @@ class FffMcpClient {
       capabilities: {},
       clientInfo: {
         name: 'codemini-cli',
-        version: '0.4.4'
+        version: '0.4.6'
       }
     });
     this.sendNotification('notifications/initialized', {});

package/src/tui/chat-app.js

@@ -1386,6 +1386,7 @@ export function shouldRefreshRuntimeStateForEvent(event) {
     type === 'assistant:delta' ||
     type === 'assistant:response' ||
     type === 'tool:result' ||
+    type === 'plan:progress' ||
     type === 'compact:auto' ||
     type === 'dream:auto' ||
     type === 'dream:complete'
@@ -4182,13 +4183,6 @@ export function ChatApp({ runtime, sessionId, model, sdkProvider = 'openai-compa
           setRuntimeStatus(makeStatus(copy.runtime.toolBlocked, detail, 'redBright'));
           setInputStage('thinking');
           setActiveAssistantMeta({ loading: true, phase: 'thinking', liveStatus: copy.toolActivity.waitingModelAdjust(detail) });
-          setPlanState((prev) => ({
-            ...prev,
-            failed: prev.total > 0,
-            steps: (prev.steps || []).map((step) =>
-              step.index === prev.current ? { ...step, status: 'failed' } : step
-            )
-          }));
           updateActivityStatusOnActiveAssistant({
             type: 'tool',
             id: event.id,
@@ -4202,13 +4196,6 @@ export function ChatApp({ runtime, sessionId, model, sdkProvider = 'openai-compa
           setRuntimeStatus(makeStatus(copy.runtime.toolFailed, event.summary || detail, 'redBright'));
           setInputStage('thinking');
           setActiveAssistantMeta({ loading: true, phase: 'thinking', liveStatus: copy.toolActivity.waitingModelAdjust(detail) });
-          setPlanState((prev) => ({
-            ...prev,
-            failed: prev.total > 0,
-            steps: (prev.steps || []).map((step) =>
-              step.index === prev.current ? { ...step, status: 'failed' } : step
-            )
-          }));
           updateActivityStatusOnActiveAssistant({
             type: 'tool',
             id: event.id,
@@ -4286,6 +4273,52 @@ export function ChatApp({ runtime, sessionId, model, sdkProvider = 'openai-compa
             }));
           }
         }
+        if (event?.type === 'plan:progress') {
+          const current = Number(event.step || 0);
+          const total = Number(event.total || 0);
+          const status = String(event.status || '').trim().toLowerCase();
+          if (current > 0 && total > 0) {
+            const role = String(event.role || '').trim().toLowerCase();
+            const normalizedRole = PLAN_AGENT_ROLES.has(role) ? role : 'coder';
+            const title = String(event.title || '').trim();
+            setPlanState((prev) => {
+              const existingSteps = Array.isArray(prev.steps) ? prev.steps : [];
+              const merged = existingSteps.some((step) => step.index === current)
+                ? existingSteps.map((step) =>
+                    step.index === current
+                      ? {
+                          ...step,
+                          total,
+                          role: event.role || step.role || normalizedRole,
+                          title: title || step.title || '',
+                          status: status === 'failed' ? 'failed' : status === 'done' ? 'done' : status === 'running' ? 'active' : step.status
+                        }
+                      : step
+                  )
+                : [
+                    ...existingSteps,
+                    {
+                      index: current,
+                      total,
+                      role: event.role || normalizedRole,
+                      title,
+                      status: status === 'failed' ? 'failed' : status === 'done' ? 'done' : 'active'
+                    }
+                  ];
+              return {
+                ...prev,
+                current,
+                total,
+                role: event.role || prev.role || normalizedRole,
+                title: title || prev.title || '',
+                failed: status === 'failed' ? true : prev.failed,
+                completed: status === 'done' && current === total && !prev.failed,
+                pendingApproval: false,
+                steps: merged.sort((a, b) => a.index - b.index)
+              };
+            });
+          }
+        }
         if (event?.type === 'skill:start') {
           ensureActiveAssistant();
           const detail = describeSkillActivity(event.name, copy);