@tea-agent/loop-agent 0.43.0-next.2 → 0.43.0-next.4

package/CHANGELOG.md

@@ -2,23 +2,26 @@
 
 ## [Unreleased]
 
+### 新增
+
+- Operator Chat 在具备 Aimax 凭据资格时，向对话进程注入 `$AIMAX_AUTH_TOKEN`（明文或 `sm4:v1:` 解密后的 ticket），供 skills 读取；文件缺失、无法解析或解密失败时不注入该变量。
+- Operator Chat 终端管理（DSH 风格）：模型获得 `terminal` 持久 PTY 工具（跨平台 shell 目录——Windows 提供 powershell/bash，macOS/Linux 提供 bash/zsh，pwsh 7 装了即用；cwd/环境变量/后台任务跨调用保留，完成标记协议 + 超时与截断保护，枚举与默认值按平台动态生成）；Console 右侧辅助栏新增「终端」面板（xterm.js 渲染，实时查看/接管模型的 shell，按平台动态展示可创建的 shell，支持发送输入、Ctrl+C、终止并关闭）；模型 shell 与用户面板共用同一会话注册表并开在工作区仓库根目录，命名区分来源。
+
 ### 改进
 
-- 前端 DAG 保留完整需求并按作用域/执行组分批，工具提交改为先校验和耐久保存再回执；支持按组共享覆盖、逐端点/逐 finding 提交和缺项恢复。小任务走短流程，容量耗尽直接缩小剩余工作；模型窗口不再硬编码为 100K/16K。独立 AC、来源保真与 writer/verify 门禁保持有效。
-- 观测台阅读与口径修补：失败节点的产出页把「错误输出」提到正文之前，未登记文件关系时不再展示空文件卡；检查器 Tab 条放不下时两端渐隐提示并保证选中 Tab 可见，每页顶部说明卡可收起。异常 Task 的分类与建议跟进显示中文业务术语（未知 token 原样透传并可悬停看原始值），资源池「合计」改为口径明确的「已建 Task」并附悬停说明，数据更新文案改为「数据更新于 … · 仅提示」。DAG 详情面包屑使用可读运行标题（缺失回退运行 ID、窄屏截断），「记录保存位置」移入「诊断信息」折叠区，页面刷新按钮与标题同行靠右。
-- 观测台保留检查器 Tab 导航，日志分类收进下拉框，辅助操作改为带提示的图标；所有执行记录区域（检查器执行记录/产出、运行页最新输出）统一配备对话式「回到底部」悬浮按钮：内容可滚动且视口离开底部即出现，贴底或内容不足一屏时隐藏，点击回到底部；活跃运行同时恢复跟随并提示未读条数，终态运行同样可用。执行分次仅在相关页面固定显示，上翻暂停跟随，并记住分次阅读位置。补充日志搜索、错误过滤、图定位和完整脱敏文本下载。
-- 实际上下文改为中文材料目录优先、技术信息折叠；修复历史轮次混读当前上下文和旧请求覆盖新尝试的问题。保留仅看错误与原始协议事件，原始协议使用直接可达的图标开关，移除单项更多菜单和日志 HTML 导出；交接包明确固定来源并支持刷新。
-- 检查器隐藏无内容或明确不适用的入口：单次执行不显示尝试对比，Shell/静态节点不显示实际上下文，静态节点不显示执行记录；切换节点与新增尝试时自动更新，保留用户当前的比较选择。
-- 资源池筛选覆盖任务标题和全部任务区域，返回列表及历史分页保留阅读状态；重跑草稿和影响预览可恢复，结果不确定时原样重试已确认的请求，避免重复创建运行。
-- 执行记录默认跟随最新内容；上翻自动暂停并出现对话式「回到底部」按钮，点击回到底部；历史记录保留阅读位置，终态运行同样可用。
-- DAG 节点检查器仅对最新且仍运行的执行默认跟随；右下角显示阅读状态、新记录提示和“回到最新”，上翻即暂停。
+- 优化 Operator Chat 长会话的流式渲染：完成回合、消息行、工具卡和用户输入锚点建立稳定的 memo 边界，流式文本更新不再重复渲染整段历史或重装锚点测量监听；缓存会在历史消息或工具实际更新时正确失效；无新增折叠回合时不再提交空状态及重复写入本地存储，工具参数与结果格式化按真实输入变化缓存。
+- 对话页「过程折叠」对齐 DSH 细节：折叠后的内容仍保留在页面中，浏览器 Ctrl+F 可直接命中并自动展开；折叠行展开时不再多出底部空隙；箭头改为 16px、颜色更淡的固定图标（靠旋转而非换图标），并补齐系统「减少动态效果」偏好；汇总文案新增「N 个 subagent」，内置 Explore 子代理不再计入普通工具调用。
 
 ### 修复
 
-- 执行记录搜索直接高亮命中文字，标识当前跳转记录；未搜索或无匹配时禁用上下箭头，清空搜索恢复原文。
-
-- 恢复运行在导入节点缺少明确读取范围时阻断工作区漂移，避免复用受变更影响的旧结果；读取范围明确且不受影响时仍可按路径复用。
-- 前端验证将子目录执行的 Vitest 报告统一为仓库相对路径，并对齐实际目录别名，避免已通过测试被误判为未执行；被筛除或失败的目标仍阻断。
+- 修复对话页存在运行活动时，收起状态的右侧辅助栏展开按钮覆盖「运行活动 N」及数字徽标的问题；中大尺寸布局现在保留 8px 操作间距，窄屏布局不变。
+- 修复 Operator Chat 消息流的六处实际使用问题：
+  - **回复被吞**：断线/重连（含每 25 秒的 SSE 事件窗口轮转）后，保留事件里已经生成的正文会在事件流恢复时重新应用到对应回合，不再被静默丢弃；仅当该回合已有更新内容时才跳过，避免重复气泡。
+  - **用户输入消失或重复**：服务端确认后，提交回滚（排队抢占、被拒绝、连接失败）不再删掉已确认的消息；确认帧到达时按请求 ID 或持久消息 ID 原地合并乐观气泡与会话快照，retained replay 不再追加同一条用户消息。
+  - **回复重复**：上下文溢出自动压缩并重新生成后，被打断的旧回复会被取代，不再与重新生成的回复同时显示。
+  - **只有思考没有正文**：模型回复以工具调用或思考结尾时，正文会作为回答显示，不再被折叠进「过程」区。
+  - **空气泡误删**：只包含思考或工具内容、正文为空的回合不再被清理掉。
+  - **停止语义**：被停止中断的工具调用显示「已停止」，不再显示为「出错」并强制展开、计入「N 次出错」。
 
 ## [0.42.0] - 2026-09-07
 

package/dist/application/dag/run-dag.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { DAG_ABSOLUTE_MAX_WALL_CLOCK_MS } from "../../shared/timeout-policy.js";
 import { createDagEventObserver } from "../../workflows/dag/event-observer.js";
 import { composeDagRunObservers } from "../../workflows/dag/observer-compose.js";
 import { createDagCanvasObserver, resolveCanvasPath, } from "../../workflows/dag/canvas-observer.js";
@@ -47,6 +48,9 @@ export async function buildDefaultFrontendRecoveryDeps(repoRoot) {
     });
     const client = new LoopAgentClient({
         loopAgentBin: resolveSiblingLoopAgentBin(),
+        // rerun-task awaits the entire continuation, not just task preparation.
+        // Use the same hard ceiling as the DAG runner and Console entry point.
+        defaultTimeoutMs: DAG_ABSOLUTE_MAX_WALL_CLOCK_MS,
         artifactRoot: path.join(appData.root, "client-artifacts", appData.fingerprint),
         resolveIdentity: true,
     });
@@ -54,6 +58,7 @@ export async function buildDefaultFrontendRecoveryDeps(repoRoot) {
         store,
         operationRunnerDeps: {
             store,
+            defaultTimeoutMs: DAG_ABSOLUTE_MAX_WALL_CLOCK_MS,
             events,
             client,
             repoRoot,

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.43.0-next.2",
-  "gitSha": "d9e11f1ac55b0bfff4b42fd43616810cf15bb575",
-  "builtAt": "2026-09-07T07:08:47.369Z"
+  "version": "0.43.0-next.4",
+  "gitSha": "a40dde963afaa57ff95e0e49aa33e051b5580827",
+  "builtAt": "2026-09-08T23:28:40.065Z"
 }

package/dist/executors/dag-pi-executor.js

@@ -1,6 +1,8 @@
 import { collectFrontendExecutionGroups, frontendExecutionSchema } from "../workflows/dag/frontend-execution-groups.js";
 import { FRONTEND_SCOPE_TARGET_BYTES, packFrontendInputUnits, parseFrontendInputBlock, projectFrontendContractPrompt, projectFrontendInputScope } from "../workflows/dag/frontend-input-projection.js";
 import { createDurableFrontendTools } from "../workflows/dag/frontend-durable-tools.js";
+import { sha256OfCanonicalJson } from "../task/contract/hash.js";
+import { z } from "zod";
 import { createFrontendReviewScopeProtocol, loadFrontendReviewScopes } from "../workflows/dag/frontend-review-scopes.js";
 import { observeFrontendSession } from "../workflows/dag/frontend-session-budget.js";
 import path from "node:path";
@@ -3908,18 +3910,30 @@ const FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY = 4;
 const FRONTEND_PLAN_BATCH_MAX_SESSIONS = 128;
 const FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS = 8;
 const FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS = 24;
-async function mapWithConcurrency(items, limit, worker) {
+async function mapWithConcurrency(items, limit, worker, shouldReduceConcurrency) {
     const results = new Array(items.length);
     let nextIndex = 0;
-    const workerCount = Math.min(Math.max(1, limit), items.length);
-    await Promise.all(Array.from({ length: workerCount }, async () => {
-        while (true) {
-            const index = nextIndex++;
-            if (index >= items.length)
-                return;
-            results[index] = await worker(items[index], index);
+    let concurrency = Math.max(1, limit);
+    const running = new Map();
+    try {
+        while (nextIndex < items.length || running.size > 0) {
+            while (nextIndex < items.length && running.size < concurrency) {
+                const index = nextIndex++;
+                running.set(index, worker(items[index], index).then(result => ({ index, result })));
+            }
+            const { index, result } = await Promise.race(running.values());
+            running.delete(index);
+            results[index] = result;
+            // Drain existing work; only pending shards use the reduced cap.
+            // Failed shards remain failed and receive no extra retry allowance.
+            if (shouldReduceConcurrency(result))
+                concurrency = Math.max(1, Math.floor(concurrency / 2));
         }
-    }));
+    }
+    catch (error) {
+        await Promise.allSettled(running.values());
+        throw error;
+    }
     return results;
 }
 function compactPromptString(value, _maxChars) {
@@ -4522,6 +4536,110 @@ export async function runFrontendContractSegmentedSessions(input) {
         input.tools.setActiveRequirementScope(null);
     }
 }
+/** One workload view for both the outer parallel map and inner session queue.
+ * A declared execution group is an indivisible unit during initial packing. */
+function buildFrontendPlanWorkload(input) {
+    const allRequirementIds = input.requirementIds;
+    const compiledInput = parseFrontendInputBlock(input.basePrompt, "plan")?.payload;
+    const fullUnits = new Map(compiledInput?.requirements.map(r => [r.id, r]) ?? []);
+    const declaredGroups = Array.isArray(compiledInput?.executionGroups)
+        ? compiledInput.executionGroups.filter(isRecordObject) : [];
+    const workGroups = declaredGroups.map(g => ({
+        id: String(g.id), kind: String(g.kind),
+        requirementIds: Array.isArray(g.requirementIds)
+            ? g.requirementIds.filter((id) => typeof id === "string" && allRequirementIds.includes(id)) : [],
+    })).filter(g => g.requirementIds.length);
+    const groupedIds = new Set(workGroups.flatMap(g => g.requirementIds));
+    for (const id of allRequirementIds) {
+        if (!groupedIds.has(id))
+            workGroups.push({ id, kind: "unclassified", requirementIds: [id] });
+    }
+    const workCost = (ids) => 1 + ids.reduce((total, id) => total + Math.max(1, (input.requirementCosts?.get(id) ?? 2) - 1), 0);
+    const policy = input.sessionOptions.frontendExecutionPolicy;
+    const targetBytes = policy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES;
+    const userMessageBytes = Buffer.byteLength(input.sessionOptions.userMessage ?? "");
+    const buildWorkBatches = (ids) => {
+        const work = workGroups.flatMap((g, index) => {
+            const members = g.requirementIds.filter(id => ids.includes(id));
+            return members.length ? [{ id: `${index}:${g.id}`, requirementIds: members,
+                    requirements: members.map(id => fullUnits.get(id) ?? { id }), estimatedCalls: workCost(members) }] : [];
+        });
+        const scaffoldBytes = Buffer.byteLength(input.basePrompt.replace(/<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/, JSON.stringify({ ...compiledInput, requirements: [] }))) + userMessageBytes + Buffer.byteLength(JSON.stringify(input.coverageTools));
+        return packFrontendInputUnits(work, {
+            targetBytes: Math.max(1, targetBytes - scaffoldBytes),
+            maxUnits: policy?.maxScopeUnits ?? 4,
+            maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS, cost: g => g.estimatedCalls,
+        }).map(batch => batch.flatMap(g => g.requirementIds));
+    };
+    // This renderer also carries the Plan's evolving UX checkpoint on resume.
+    // Only the Contract/Scout-derived input participates in ownership binding.
+    const { committedUx: _committedUx, ...frozenInput } = compiledInput ?? {};
+    return {
+        frozenInput, workGroups, buildWorkBatches,
+        compactEligible: input.requirementCosts !== undefined &&
+            workGroups.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
+            Buffer.byteLength(input.basePrompt) + userMessageBytes + Buffer.byteLength(JSON.stringify(input.allTools)) <= targetBytes * 2 &&
+            workGroups.reduce((total, group) => total + workCost(group.requirementIds), 0) <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
+            countFrontendPlanTargetSurfaces(input.basePrompt) === 1,
+    };
+}
+const frontendPlanCoverageLayoutSchema = z.object({
+    schemaVersion: z.literal(1),
+    bindingSha256: z.string(),
+    coverageBatches: z.array(z.array(z.string().min(1)).min(1)).min(1),
+    layoutSha256: z.string(),
+}).strict();
+/** Freeze ledger ownership before any provider call. Session packing remains
+ * adaptive inside each owner, but retry instructions cannot rename its scope. */
+async function loadOrCreateFrontendPlanCoverageLayout(input) {
+    const fileName = "coverage-layout.json";
+    const file = path.join(input.runDir, input.nodeId, fileName);
+    const bindingSha256 = sha256OfCanonicalJson(input.binding);
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    let layout;
+    if (raw !== undefined) {
+        layout = frontendPlanCoverageLayoutSchema.parse(JSON.parse(raw));
+    }
+    else {
+        // Losing the ownership receipt must never repartition acknowledged facts.
+        for (const relative of ["plan-typed-facts.jsonl", "parallel"]) {
+            const existing = await stat(path.join(input.runDir, input.nodeId, relative)).catch(error => {
+                if (error.code !== "ENOENT")
+                    throw error;
+                return undefined;
+            });
+            if (existing && (existing.isDirectory() || existing.size > 0)) {
+                throw Error("FRONTEND_PLAN_LAYOUT_MISSING: preserve the existing ledger and restart its owning phase");
+            }
+        }
+        const descriptor = {
+            schemaVersion: 1, bindingSha256,
+            coverageBatches: input.workload.compactEligible ? [input.requirementIds] : input.workload.buildWorkBatches(input.requirementIds),
+        };
+        layout = { ...descriptor, layoutSha256: sha256OfCanonicalJson(descriptor) };
+    }
+    const { layoutSha256, ...descriptor } = layout;
+    if (layout.bindingSha256 !== bindingSha256 || layoutSha256 !== sha256OfCanonicalJson(descriptor)) {
+        throw Error("FRONTEND_PLAN_LAYOUT_MISMATCH: frozen coverage ownership or input binding changed");
+    }
+    const members = layout.coverageBatches.flat();
+    const owners = new Map(layout.coverageBatches.flatMap((batch, index) => batch.map(id => [id, index])));
+    if (members.length !== owners.size || members.length !== input.requirementIds.length ||
+        input.requirementIds.some(id => !owners.has(id)) ||
+        input.workload.workGroups.some(group => new Set(group.requirementIds.map(id => owners.get(id))).size !== 1)) {
+        throw Error("FRONTEND_PLAN_LAYOUT_INVALID: coverage must partition complete execution groups exactly once");
+    }
+    if (raw === undefined)
+        await writeDagNodeJsonArtifact(input.runDir, input.nodeId, fileName, layout);
+    return layout.coverageBatches;
+}
 export async function runFrontendPlanSegmentedSessions(input) {
     const queue = [];
     const coverageSegment = FRONTEND_PLAN_SEGMENTS.find((segment) => segment.id === "coverage");
@@ -4709,25 +4827,12 @@ export async function runFrontendPlanSegmentedSessions(input) {
             tokensUsed: 0,
         };
     }
-    const compiledInput = parseFrontendInputBlock(input.basePrompt, "plan")?.payload;
-    const fullUnits = new Map(compiledInput?.requirements.map(r => [r.id, r]) ?? []);
-    const declaredGroups = Array.isArray(compiledInput?.executionGroups) ? compiledInput.executionGroups.filter(isRecordObject) : [];
-    const workGroups = declaredGroups.length ? declaredGroups.map(g => ({ id: String(g.id), kind: String(g.kind), requirementIds: Array.isArray(g.requirementIds) ? g.requirementIds.filter((id) => typeof id === "string" && allRequirementIds.includes(id)) : [] })).filter(g => g.requirementIds.length) : allRequirementIds.map(id => ({ id, kind: "unclassified", requirementIds: [id] }));
-    const groupedIds = new Set(workGroups.flatMap(g => g.requirementIds));
-    for (const id of allRequirementIds)
-        if (!groupedIds.has(id))
-            workGroups.push({ id, kind: "unclassified", requirementIds: [id] });
-    const workCost = (ids) => 1 + ids.reduce((total, id) => total + Math.max(1, (input.requirementCosts?.get(id) ?? 2) - 1), 0);
-    const buildWorkBatches = (ids) => {
-        const work = workGroups.flatMap((g, index) => {
-            const members = g.requirementIds.filter(id => ids.includes(id));
-            return members.length ? [{ id: `${index}:${g.id}`, requirementIds: members, requirements: members.map(id => fullUnits.get(id) ?? { id }), estimatedCalls: workCost(members) }] : [];
-        });
-        const scaffoldBytes = Buffer.byteLength(input.basePrompt.replace(/<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/, JSON.stringify({ ...compiledInput, requirements: [] }))) + Buffer.byteLength(JSON.stringify(input.segmentCustomTools(coverageSegment.toolNames)));
-        return packFrontendInputUnits(work, { targetBytes: Math.max(1, (input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES) - scaffoldBytes), maxUnits: input.sessionOptions.frontendExecutionPolicy?.maxScopeUnits ?? 4, maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS, cost: g => g.estimatedCalls }).map(batch => batch.flatMap(g => g.requirementIds));
-    };
-    const estimatedCalls = workGroups.reduce((total, group) => total + workCost(group.requirementIds), 0);
-    const targetSurfaceCount = countFrontendPlanTargetSurfaces(input.basePrompt);
+    const { workGroups, buildWorkBatches, compactEligible } = buildFrontendPlanWorkload({
+        basePrompt: input.basePrompt, requirementIds: allRequirementIds,
+        requirementCosts: input.requirementCosts, sessionOptions: input.sessionOptions,
+        coverageTools: input.segmentCustomTools(coverageSegment.toolNames),
+        allTools: input.segmentCustomTools(null),
+    });
     // Small, single-surface requests do not benefit from six isolated Pi
     // sessions. Keep the typed ledger as the authority, but let one local
     // session establish requirement/UX facts and one final session establish
@@ -4735,11 +4840,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
     // for larger plans and for the unscoped compatibility path.
     const useCompactSmallPlan = requirementIdsProvided &&
         input.compactSmallPlan === true &&
-        input.requirementCosts !== undefined &&
-        workGroups.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
-        Buffer.byteLength(input.basePrompt) + Buffer.byteLength(JSON.stringify(input.segmentCustomTools(null))) <= (input.sessionOptions.frontendExecutionPolicy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES) * 2 &&
-        estimatedCalls <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
-        targetSurfaceCount === 1;
+        compactEligible;
     if (useCompactSmallPlan) {
         const compactLocalTools = new Set([
             "record_plan_requirement",
@@ -5954,160 +6055,161 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 flushLedger: () => options.ledgerTools.flush(),
             });
             if (planRequirementIds.length > 1) {
-                const estimatedPlanCalls = planRequirementIds.reduce((total, id) => total + Math.max(1, planRequirementCosts.get(id) ?? 2), 0);
-                const compactEligibleBeforeSharding = planRequirementIds.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
-                    estimatedPlanCalls > 12 &&
-                    estimatedPlanCalls <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
-                    countFrontendPlanTargetSurfaces(input.prompt) === 1;
-                if (compactEligibleBeforeSharding) {
-                    // Decide the small-plan topology before creating coverage shards.
-                    // Sharding first would make the compact two-session path unreachable.
-                    result = await runPlanSessions({
-                        ledgerTools: planLedgerTools,
-                        sessionOptions: piSessionOptions,
-                        compactSmallPlan: true,
+                const coverageTools = FRONTEND_PLAN_SEGMENTS.find(segment => segment.id === "coverage").toolNames;
+                const workload = buildFrontendPlanWorkload({
+                    basePrompt: input.prompt, requirementIds: planRequirementIds,
+                    requirementCosts: planRequirementCosts, sessionOptions: piSessionOptions,
+                    allTools: planLedgerTools.customTools,
+                    coverageTools: planLedgerTools.customTools.filter(tool => isRecordObject(tool) && coverageTools.has(String(tool.name))),
+                });
+                let coverageBatches;
+                try {
+                    coverageBatches = await loadOrCreateFrontendPlanCoverageLayout({
+                        runDir: meta.runDir, nodeId: input.task.id, workload, requirementIds: planRequirementIds,
+                        binding: {
+                            runId: meta.runId, nodeId: input.task.id, sourceBinding: meta.spec.sourceBinding,
+                            skeleton: input.task.structuredContractOutput?.skeleton, writeSet: input.task.writeSet,
+                            policy: meta.spec.frontendExecutionPolicy, requirements: [...planRequirementCosts],
+                            compiledInput: workload.frozenInput, workGroups: workload.workGroups,
+                        },
                     });
                 }
-                else {
-                    const coverageBatches = batchFrontendPlanRequirements({
-                        requirementIds: planRequirementIds,
-                        maxEstimatedRecordCalls: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS,
-                        maxRequirements: 4,
-                        requirementCosts: planRequirementCosts,
-                    });
-                    if (coverageBatches.length > 1) {
-                        const shardResults = await mapWithConcurrency(coverageBatches, FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, async (slice, index) => {
-                            let shardTools;
-                            let shardResult;
-                            try {
-                                const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
-                                shardTools = await createFrontendPlanLedgerTools({
-                                    attemptId: `${meta.runId}:${input.task.id}:parallel:${index + 1}`,
-                                    store: createTypedEventStore(),
+                catch (error) {
+                    return { ok: false, stdout: "", durationMs: Date.now() - started, failureCategory: "tool-policy",
+                        stderr: `frontend plan coverage layout unavailable: ${error instanceof Error ? error.message : String(error)}` };
+                }
+                if (coverageBatches.length > 1) {
+                    const shardResults = await mapWithConcurrency(coverageBatches, piSessionOptions.frontendExecutionPolicy?.maxCoverageConcurrency ?? FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, async (slice, index) => {
+                        let shardTools;
+                        let shardResult;
+                        try {
+                            const { createTypedEventStore } = await import("../workflows/dag/frontend-typed-event-store.js");
+                            shardTools = await createFrontendPlanLedgerTools({
+                                attemptId: `${meta.runId}:${input.task.id}:parallel:${index + 1}`,
+                                store: createTypedEventStore(),
+                                runDir: meta.runDir,
+                                nodeId: `${input.task.id}/parallel/coverage-${index + 1}`,
+                                skeleton: input.task.structuredContractOutput?.skeleton,
+                                sourceBinding: meta.spec.sourceBinding,
+                                requirementIds: slice,
+                                writeSetPatterns: input.task.writeSet,
+                                canonicalVerificationTargetIds: await resolveFrontendCanonicalVerificationTargetIds({
                                     runDir: meta.runDir,
-                                    nodeId: `${input.task.id}/parallel/coverage-${index + 1}`,
-                                    skeleton: input.task.structuredContractOutput?.skeleton,
+                                }),
+                                componentNewSourceReferences: await resolveFrontendPlanNewComponentSourceReferences({
+                                    cwd: input.cwd,
                                     sourceBinding: meta.spec.sourceBinding,
-                                    requirementIds: slice,
-                                    writeSetPatterns: input.task.writeSet,
-                                    canonicalVerificationTargetIds: await resolveFrontendCanonicalVerificationTargetIds({
-                                        runDir: meta.runDir,
-                                    }),
-                                    componentNewSourceReferences: await resolveFrontendPlanNewComponentSourceReferences({
-                                        cwd: input.cwd,
-                                        sourceBinding: meta.spec.sourceBinding,
-                                    }),
-                                });
-                                const shardSessionOptions = {
-                                    ...piSessionOptions,
-                                    sessionEventsPath: path.join(meta.runDir, input.task.id, "parallel", `coverage-${index + 1}`, "session-events.jsonl"),
-                                };
-                                shardResult = await runPlanSessions({
-                                    ledgerTools: shardTools,
-                                    sessionOptions: shardSessionOptions,
-                                    requirementIds: slice,
-                                    basePrompt: `${input.prompt}\n\nPARALLEL COVERAGE SHARD ${index + 1}: use the frozen canonical behavior verification-target ids listed in the record_plan_verification_target tool description — do not prefix ids with a shard namespace or invent variant ids; identical cross-shard targets are deduped, divergent ones fail the merge.`,
-                                    parallelCoverageOnly: true,
-                                    observation: {
-                                        artifactPath: path.join(meta.runDir, input.task.id, "parallel", `coverage-${index + 1}`, "session-budget", `attempt-${input.attempt ?? 1}`),
-                                        runId: meta.runId,
-                                        nodeId: `${input.task.id}/parallel/coverage-${index + 1}`,
-                                        taskId: meta.spec?.sourceBinding?.taskId,
-                                        attempt: input.attempt ?? 1,
-                                        model: input.model,
-                                        sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined,
-                                        contractDigest: meta.spec?.taskContractBinding?.canonicalHash,
-                                    },
-                                });
-                                await shardTools.flush();
-                                return { index, result: shardResult, tools: shardTools };
-                            }
-                            catch (error) {
-                                const crashMessage = `frontend plan coverage shard ${index + 1} crashed: ${error instanceof Error ? error.message : String(error)}`;
-                                return {
-                                    index,
-                                    tools: shardTools,
-                                    result: shardResult
-                                        ? {
-                                            ...shardResult,
-                                            ok: false,
-                                            failureCategory: shardResult.ok
-                                                ? "invalid-output"
-                                                : shardResult.failureCategory,
-                                            stderr: [shardResult.stderr, crashMessage]
-                                                .filter(Boolean)
-                                                .join("\n"),
-                                        }
-                                        : {
-                                            ok: false,
-                                            assistantText: "",
-                                            command: [],
-                                            durationMs: 0,
-                                            exitCode: null,
-                                            failureCategory: "tool-policy",
-                                            modelDisplay: "unknown",
-                                            parsedEvents: 0,
-                                            stderr: crashMessage,
-                                            stdout: "",
-                                            timedOut: false,
-                                            attemptedModels: [],
-                                            fallbackUsed: false,
-                                            tokensUsed: 0,
-                                        },
-                                };
-                            }
-                        });
-                        const coverageResult = aggregateParallelPiResults(shardResults.map((shard) => shard.result));
-                        let mergeFailure;
-                        try {
-                            // Flatten every shard's facts FIRST, then pre-reduce: shards
-                            // partition requirements but a frozen verification target can
-                            // span shards, so same-id targets must merge across shards
-                            // before adoption, not per shard.
-                            await planLedgerTools.adoptCommittedFacts(reduceParallelCoverageShardRecords(shardResults
-                                .filter((item) => item.result.ok && item.tools)
-                                .flatMap((shard) => normalizeParallelCoverageShardRecords(shard.tools.committedFacts(), shard.index + 1))));
-                        }
-                        catch (error) {
-                            mergeFailure = error;
-                        }
-                        const failedShard = shardResults.find((shard) => !shard.result.ok);
-                        if (mergeFailure) {
-                            result = {
-                                ...coverageResult,
-                                ok: false,
-                                failureCategory: "invalid-output",
-                                stderr: [
-                                    coverageResult.stderr,
-                                    `frontend plan coverage shard merge failed: ${mergeFailure instanceof Error ? mergeFailure.message : String(mergeFailure)}`,
-                                ]
-                                    .filter(Boolean)
-                                    .join("\n"),
+                                }),
+                            });
+                            const shardSessionOptions = {
+                                ...piSessionOptions,
+                                sessionEventsPath: path.join(meta.runDir, input.task.id, "parallel", `coverage-${index + 1}`, "session-events.jsonl"),
                             };
+                            shardResult = await runPlanSessions({
+                                ledgerTools: shardTools,
+                                sessionOptions: shardSessionOptions,
+                                requirementIds: slice,
+                                basePrompt: `${input.prompt}\n\nPARALLEL COVERAGE SHARD ${index + 1}: use the frozen canonical behavior verification-target ids listed in the record_plan_verification_target tool description — do not prefix ids with a shard namespace or invent variant ids; identical cross-shard targets are deduped, divergent ones fail the merge.`,
+                                parallelCoverageOnly: true,
+                                observation: {
+                                    artifactPath: path.join(meta.runDir, input.task.id, "parallel", `coverage-${index + 1}`, "session-budget", `attempt-${input.attempt ?? 1}`),
+                                    runId: meta.runId,
+                                    nodeId: `${input.task.id}/parallel/coverage-${index + 1}`,
+                                    taskId: meta.spec?.sourceBinding?.taskId,
+                                    attempt: input.attempt ?? 1,
+                                    model: input.model,
+                                    sourceDigest: meta.spec?.sourceBinding?.schemaVersion === 2 ? meta.spec.sourceBinding.inputDigest : undefined,
+                                    contractDigest: meta.spec?.taskContractBinding?.canonicalHash,
+                                },
+                            });
+                            await shardTools.flush();
+                            return { index, result: shardResult, tools: shardTools };
                         }
-                        else if (failedShard) {
-                            result = {
-                                ...coverageResult,
-                                ok: false,
-                                stderr: `${coverageResult.stderr}\nfrontend plan coverage shard ${failedShard.index + 1} failed before reduce`.trim(),
+                        catch (error) {
+                            const crashMessage = `frontend plan coverage shard ${index + 1} crashed: ${error instanceof Error ? error.message : String(error)}`;
+                            return {
+                                index,
+                                tools: shardTools,
+                                result: shardResult
+                                    ? {
+                                        ...shardResult,
+                                        ok: false,
+                                        failureCategory: shardResult.ok
+                                            ? "invalid-output"
+                                            : shardResult.failureCategory,
+                                        stderr: [shardResult.stderr, crashMessage]
+                                            .filter(Boolean)
+                                            .join("\n"),
+                                    }
+                                    : {
+                                        ok: false,
+                                        assistantText: "",
+                                        command: [],
+                                        durationMs: 0,
+                                        exitCode: null,
+                                        failureCategory: "tool-policy",
+                                        modelDisplay: "unknown",
+                                        parsedEvents: 0,
+                                        stderr: crashMessage,
+                                        stdout: "",
+                                        timedOut: false,
+                                        attemptedModels: [],
+                                        fallbackUsed: false,
+                                        tokensUsed: 0,
+                                    },
                             };
                         }
-                        else {
-                            const reducerResult = await runPlanSessions({
-                                ledgerTools: planLedgerTools,
-                                sessionOptions: piSessionOptions,
-                            });
-                            result = combineSequentialPiResults(coverageResult, reducerResult);
-                        }
+                    }, shard => shard.result.failureCategory === "rate-limit");
+                    const coverageResult = aggregateParallelPiResults(shardResults.map((shard) => shard.result));
+                    let mergeFailure;
+                    try {
+                        // Flatten every shard's facts FIRST, then pre-reduce: shards
+                        // partition requirements but a frozen verification target can
+                        // span shards, so same-id targets must merge across shards
+                        // before adoption, not per shard.
+                        await planLedgerTools.adoptCommittedFacts(reduceParallelCoverageShardRecords(shardResults
+                            .filter((item) => item.result.ok && item.tools)
+                            .flatMap((shard) => normalizeParallelCoverageShardRecords(shard.tools.committedFacts(), shard.index + 1))));
+                    }
+                    catch (error) {
+                        mergeFailure = error;
+                    }
+                    const failedShard = shardResults.find((shard) => !shard.result.ok);
+                    if (mergeFailure) {
+                        result = {
+                            ...coverageResult,
+                            ok: false,
+                            failureCategory: "invalid-output",
+                            stderr: [
+                                coverageResult.stderr,
+                                `frontend plan coverage shard merge failed: ${mergeFailure instanceof Error ? mergeFailure.message : String(mergeFailure)}`,
+                            ]
+                                .filter(Boolean)
+                                .join("\n"),
+                        };
+                    }
+                    else if (failedShard) {
+                        result = {
+                            ...coverageResult,
+                            ok: false,
+                            stderr: `${coverageResult.stderr}\nfrontend plan coverage shard ${failedShard.index + 1} failed before reduce`.trim(),
+                        };
                     }
                     else {
-                        result = await runPlanSessions({
+                        const reducerResult = await runPlanSessions({
                             ledgerTools: planLedgerTools,
                             sessionOptions: piSessionOptions,
-                            compactSmallPlan: true,
                         });
+                        result = combineSequentialPiResults(coverageResult, reducerResult);
                     }
                 }
+                else {
+                    result = await runPlanSessions({
+                        ledgerTools: planLedgerTools,
+                        sessionOptions: piSessionOptions,
+                        compactSmallPlan: true,
+                    });
+                }
             }
             else {
                 result = await runPlanSessions({

package/dist/shared/frontend-execution-policy.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 export const frontendExecutionPolicySchema = z.object({
     scopeTargetBytes: z.number().int().positive().default(24_000),
     maxScopeUnits: z.number().int().positive().default(4),
+    maxCoverageConcurrency: z.number().int().min(1).max(4).default(4),
     outputReserveTokens: z.number().int().positive().default(4096),
     readGrowthReserveTokens: z.number().int().nonnegative().default(2048),
     safetyRatio: z.number().min(0).max(0.5).default(0.15),

package/dist/worker/console/chat/assistant-content.js

@@ -115,9 +115,30 @@ export function splitFinalAssistantBlocks(blocks, options = {}) {
     if (lastProcessIndex === -1) {
         return { answerBlocks: displayable, processBlocks: [] };
     }
+    const trailing = displayable.slice(lastProcessIndex + 1);
+    if (trailing.length > 0) {
+        return {
+            answerBlocks: trailing,
+            processBlocks: displayable.slice(0, lastProcessIndex + 1),
+        };
+    }
+    // The stage ends on a non-text block (a tool call after the prose, or a final
+    // thinking block). Returning an empty answer here hid the whole reply inside
+    // the collapsed process subtree; keep the last prose block as the visible
+    // answer instead (2026-09-08).
+    let lastTextIndex = -1;
+    for (let i = displayable.length - 1; i >= 0; i--) {
+        if (isFinalAnswerBlock(displayable[i])) {
+            lastTextIndex = i;
+            break;
+        }
+    }
+    if (lastTextIndex === -1) {
+        return { answerBlocks: [], processBlocks: displayable };
+    }
     return {
-        answerBlocks: displayable.slice(lastProcessIndex + 1),
-        processBlocks: displayable.slice(0, lastProcessIndex + 1),
+        answerBlocks: [displayable[lastTextIndex]],
+        processBlocks: displayable.filter((_block, index) => index !== lastTextIndex),
     };
 }
 export function joinAssistantText(blocks) {