@tea-agent/loop-agent 0.44.0-next.3 → 0.44.0-next.4

package/CHANGELOG.md

@@ -3,7 +3,10 @@
 ## [Unreleased]
 
 - Console 新增低饱和的「暮色蓝」深色与「雾光白」浅色主题，保留默认暖纸色；柔和背景、轻量选中态与独立按钮配色减少视觉刺激。顶部仅显示带「主题」悬停提示的紧凑明暗图标按钮，点击后展开「默认 / 深色 / 浅色」，选完自动收起，支持点击外部或 Escape 关闭；初始使用默认主题；即时切换对话、操作与观测界面，刷新后记住选择，浏览器存储不可用时仍可在当前页面切换。
-- Operator Chat 在后台断线重连后不再丢消息：检测到中断会自动补齐缺口内容，也不会把正常的历史回放误判成丢事件而反复重连。
+- Operator Chat 消息流后续对齐：折叠摘要现在统计 retry/step/command/unknown 等 durable 过程节点，Trajectory 与 HTML 导出保留 DAG progress，并使用稳定过程身份避免直播插入导致 Thinking/工具行重挂载。
+- Operator Chat 统一主时间线、Trajectory 与导出使用同一 DSH flow projection：Thinking、工具、重试、命令和完成态节点按事件序交错，保留 completed-turn 折叠；request/unknown 详情改为有界结构化摘要，不再回显裸节点 JSON。
+- Operator Chat 的消息流对齐 DSH Conversation Node：模型步骤、重试、终止错误、输出上限、每次请求上下文、嵌套工具、`/sdd-bingo` 命令回执和未知事件均以稳定节点留痕；同一模型步骤的多次重试聚合为一条紧凑记录，Provider 终态错误改为轻量行且不再暴露原始响应；流式文本按动画帧合并发布，刷新和断线恢复保持同一身份与顺序，轨迹页面和导出同步展示。
+ - Operator Chat 在后台断线重连后不再丢消息：检测到中断会自动补齐缺口内容，也不会把正常的历史回放误判成丢事件而反复重连。
 - Operator Chat 的恢复快照现在只会合并属于目标会话的乐观提交；切换会话后，旧会话尚未确认的输入不会再因延迟重连恢复而显示到新会话中。
 - `/sdd-bingo` 成功提示现在展示上报的 Skill 与 Session ID；轨迹顶部会出现当前会话的常驻 SDD 身份栏，可一键复制、首次请求后自动更新；该上报以独立“操作”事件留痕，刷新或导出后仍在，不再伪装成工具调用。
 - Operator Chat 发送消息后的空白光标改为 Codex 式“正在思考”，真实思考、工具过程或最终回答出现后自然接替；并修复了状态偶发显示在用户输入上方的问题。
@@ -702,5 +705,3 @@
 ## 历史版本
 
 0.35.x 及更早（0.8.0 – 0.35.4-beta.0）的发布说明已归档到 [`CHANGELOG/CHANGELOG-0.35-and-earlier.md`](CHANGELOG/CHANGELOG-0.35-and-earlier.md)；版本线维护边界与归档规则见 [`CHANGELOG/README.md`](CHANGELOG/README.md)。
-
-

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.3",
-  "gitSha": "2bc5338a83fc147e9ac1a201797b3d04f5617bbe",
-  "builtAt": "2026-09-15T12:05:43.839Z"
+  "version": "0.44.0-next.4",
+  "gitSha": "6d1cd2f6dd13854cd48bcd4b38718a53cc24109a",
+  "builtAt": "2026-09-15T17:21:15.173Z"
 }

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

@@ -6274,7 +6274,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 });
             }
         }
-        const promptForMissingPhase = (missing) => session.coverageOnly
+        const promptForMissingPhase = (missing) => `Actionable completeness findings (repair only these facts; preserve unrelated committed facts):\n${missing.map((item) => `- fact=${item.kind}${item.id ? `/${item.id}` : ""}; requirements=${item.requirementIds.join(",")}; reason=${item.reason}; owner=${item.owner ?? "Plan"}; repairScope=${item.repairScope ?? "fact"}; next=${item.nextAction ?? "replace-fact-and-finalize"}`).join("\n")}\n\n` + (session.coverageOnly
             ? buildCoveragePrompt(session.coverageSlice ?? [], missing)
             : isCompactLocalSession
                 ? buildCompactLocalPrompt(missing)
@@ -6282,7 +6282,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
                     ? buildUxRegistryPrompt(missing)
                     : isUxLocalSession
                         ? buildUxPrompt(session.requirementSlice ?? [], missing)
-                        : buildPhasePrompt(globalMockDataSegment, missing, session.requirementSlice ?? allRequirementIds);
+                        : buildPhasePrompt(globalMockDataSegment, missing, session.requirementSlice ?? allRequirementIds));
         const recovery = classifyFrontendPlanRecovery({ ...result, stopReason: readWriterThinkingExhaustionEvidence(result).stopReason });
         if (recovery === "stop")
             return { ...result, ok: false };

package/dist/task/config-types.js

@@ -308,9 +308,10 @@ const taskConfigObjectSchema = z.object({
         .object({
         allowed: z.array(z.string().min(1)).optional(),
         forbidden: z.array(z.string().min(1)).optional(),
+        requiredClauses: z.array(z.string().min(1)).optional(),
     })
         .strict()
-        .refine((entry) => (entry.allowed?.length ?? 0) > 0 || (entry.forbidden?.length ?? 0) > 0, { message: "capabilityBoundary needs allowed or forbidden entries" })
+        .refine((entry) => (entry.allowed?.length ?? 0) > 0 || (entry.forbidden?.length ?? 0) > 0 || (entry.requiredClauses?.length ?? 0) > 0, { message: "capabilityBoundary needs allowed or forbidden entries" })
         .optional(),
     /** Generation-frozen interaction id vocabulary. Contract interaction names
      * must come from this set (plan finalize deterministic check). */

package/dist/task/contract/schema.js

@@ -88,6 +88,7 @@ export const taskContractDraftSchema = z
         .object({
         allowed: z.array(z.string().min(1)).optional(),
         forbidden: z.array(z.string().min(1)).optional(),
+        requiredClauses: z.array(z.string().min(1)).optional(),
     })
         .strict()
         .optional(),

package/dist/worker/console/chat/chat-event-store.js

@@ -327,6 +327,10 @@ export function projectChatToolEventPayload(input) {
             toolName: input.toolName,
             argsPreview: preview,
             previewHash,
+            ...(input.step === undefined ? {} : { step: input.step }),
+            ...(input.parentToolCallId
+                ? { parentToolCallId: input.parentToolCallId }
+                : {}),
         };
     }
     const { preview, previewHash } = projectToolResultPreview(input.value);
@@ -336,9 +340,37 @@ export function projectChatToolEventPayload(input) {
         resultPreview: preview,
         previewHash,
         isError: Boolean(input.isError),
+        ...(input.step === undefined ? {} : { step: input.step }),
+        ...(input.parentToolCallId
+            ? { parentToolCallId: input.parentToolCallId }
+            : {}),
         ...(input.operationId ? { operationId: input.operationId } : {}),
     };
 }
+export function projectUnknownChatEventPayload(input) {
+    const redact = (value, depth) => {
+        if (depth >= 6)
+            return "[DEPTH_LIMIT]";
+        if (Array.isArray(value)) {
+            return value.slice(0, 50).map((item) => redact(item, depth + 1));
+        }
+        if (!value || typeof value !== "object")
+            return value;
+        const result = {};
+        for (const [key, child] of Object.entries(value).slice(0, 100)) {
+            result[key] = /authorization|cookie|password|secret|token|api[-_]?key/i.test(key)
+                ? "[REDACTED]"
+                : redact(child, depth + 1);
+        }
+        return result;
+    };
+    const { preview, previewHash } = boundedRedactedJson(redact(input.value, 0));
+    return {
+        eventType: input.eventType.slice(0, 120),
+        preview,
+        previewHash,
+    };
+}
 export function projectOperationEventSummary(event) {
     const messagePreview = boundedRedactedText(event.message, 600);
     const dataPreview = event.data === undefined

package/dist/worker/console/chat/conversation-nodes.js

@@ -0,0 +1,383 @@
+function finiteStep(data) {
+    return typeof data.step === "number" && Number.isSafeInteger(data.step) && data.step >= 0
+        ? data.step
+        : undefined;
+}
+function locationFor(event, step = finiteStep(event.data)) {
+    return step === undefined
+        ? { kind: "turn", turnId: event.turnId }
+        : { kind: "step", turnId: event.turnId, step };
+}
+function status(value) {
+    return value === "scheduled" ||
+        value === "started" ||
+        value === "cancelled" ||
+        value === "running" ||
+        value === "completed" ||
+        value === "failed" ||
+        value === "interrupted"
+        ? value
+        : undefined;
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+        ? value
+        : undefined;
+}
+function nonNegativeNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function unknownRetryNode(event, base) {
+    return {
+        ...base,
+        key: `unknown:${event.eventId}`,
+        kind: "unknown",
+        location: locationFor(event),
+        data: {
+            eventType: "model_retry",
+            preview: "Incomplete model retry lifecycle event",
+        },
+    };
+}
+function retryStateFromEvent(data) {
+    if (data.state === "scheduled")
+        return "scheduled";
+    return data.success === false || data.state === "failed"
+        ? "cancelled"
+        : "started";
+}
+function isRetryAttempt(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const attempt = value;
+    return (positiveInteger(attempt.attempt) !== undefined &&
+        positiveInteger(attempt.maxAttempts) !== undefined &&
+        nonNegativeNumber(attempt.delayMs) !== undefined &&
+        nonEmptyString(attempt.errorMessage) !== undefined &&
+        (attempt.state === "scheduled" ||
+            attempt.state === "started" ||
+            attempt.state === "cancelled") &&
+        typeof attempt.seq === "number" &&
+        typeof attempt.at === "number");
+}
+/** Read the current complete attempt from a projected retry-chain node. */
+export function modelRetryCurrent(node) {
+    if (node.kind !== "retry")
+        return undefined;
+    return isRetryAttempt(node.data.current) ? node.data.current : undefined;
+}
+function modelRetryAttempts(node) {
+    return Array.isArray(node.data.attempts)
+        ? node.data.attempts.filter(isRetryAttempt)
+        : [];
+}
+function retryUpdate(node) {
+    const value = node.data.retryUpdate;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    if (positiveInteger(candidate.attempt) === undefined ||
+        (candidate.state !== "started" && candidate.state !== "cancelled"))
+        return undefined;
+    return candidate;
+}
+/** Convert one already-redacted durable event into a stable UI node. */
+export function conversationNodeFromEvent(event) {
+    const at = Date.parse(event.at);
+    const base = {
+        anchorSeq: event.seq,
+        updatedSeq: event.seq,
+        at: Number.isFinite(at) ? at : 0,
+        data: event.data,
+    };
+    const step = finiteStep(event.data);
+    switch (event.kind) {
+        case "step_start":
+        case "step_end": {
+            if (step === undefined)
+                return undefined;
+            const outcome = status(event.data.outcome);
+            return {
+                ...base,
+                key: `step:${event.turnId}:${step}`,
+                kind: "step",
+                location: { kind: "step", turnId: event.turnId, step },
+                status: event.kind === "step_start" ? "running" : (outcome ?? "completed"),
+            };
+        }
+        case "model_retry": {
+            const attempt = positiveInteger(event.data.attempt);
+            if (attempt === undefined)
+                return unknownRetryNode(event, base);
+            const retryState = retryStateFromEvent(event.data);
+            const key = `retry:${event.turnId}:${step ?? 0}`;
+            if (retryState !== "scheduled") {
+                return {
+                    ...base,
+                    key,
+                    kind: "retry",
+                    location: locationFor(event),
+                    status: retryState,
+                    data: {
+                        retryUpdate: {
+                            attempt,
+                            state: retryState,
+                            seq: event.seq,
+                            at: base.at,
+                        },
+                    },
+                };
+            }
+            const maxAttempts = positiveInteger(event.data.maxAttempts);
+            const delayMs = nonNegativeNumber(event.data.delayMs);
+            const errorMessage = nonEmptyString(event.data.errorMessage);
+            if (maxAttempts === undefined || delayMs === undefined || !errorMessage) {
+                return unknownRetryNode(event, base);
+            }
+            const current = {
+                attempt,
+                maxAttempts,
+                delayMs,
+                errorMessage,
+                state: "scheduled",
+                seq: event.seq,
+                at: base.at,
+            };
+            return {
+                ...base,
+                key,
+                kind: "retry",
+                location: locationFor(event),
+                status: "scheduled",
+                data: { attempts: [current], current },
+            };
+        }
+        case "turn_error":
+            return {
+                ...base,
+                key: `turn-error:${event.turnId}`,
+                kind: "turn-error",
+                location: locationFor(event),
+                status: "failed",
+            };
+        case "turn_max_tokens":
+            return {
+                ...base,
+                key: `max-tokens:${event.turnId}:${step ?? 0}`,
+                kind: "max-tokens",
+                location: locationFor(event),
+                status: "completed",
+            };
+        case "request_context": {
+            const requestId = typeof event.data.requestId === "string" && event.data.requestId
+                ? event.data.requestId
+                : event.eventId;
+            return {
+                ...base,
+                key: `request:${requestId}`,
+                kind: "request",
+                location: locationFor(event),
+                status: "completed",
+            };
+        }
+        case "command": {
+            const commandId = typeof event.data.commandId === "string" && event.data.commandId
+                ? event.data.commandId
+                : event.eventId;
+            return {
+                ...base,
+                key: `command:${commandId}`,
+                kind: "command",
+                location: { kind: "turn", turnId: event.turnId },
+                status: status(event.data.outcome) ?? "completed",
+            };
+        }
+        case "unknown":
+            return {
+                ...base,
+                key: `unknown:${event.eventId}`,
+                kind: "unknown",
+                location: locationFor(event),
+            };
+    }
+}
+export function conversationNodesFromEvents(events) {
+    let nodes = [];
+    for (const event of events) {
+        const node = conversationNodeFromEvent(event);
+        if (node)
+            nodes = upsertConversationNode(nodes, node);
+    }
+    return nodes;
+}
+/** Keyed upsert that preserves the first structural anchor and location. */
+export function upsertConversationNode(nodes, next) {
+    if (next.kind === "retry")
+        return upsertRetryNode(nodes, next);
+    const merged = upsertBase(nodes, next);
+    if (next.kind === "step" && next.location.kind === "step") {
+        const { step: nextStep, turnId } = next.location;
+        if (next.status === "running") {
+            return transitionScheduledRetries(merged, (node) => node.location.kind === "step" &&
+                node.location.turnId === turnId &&
+                node.location.step < nextStep, "started", next.updatedSeq);
+        }
+        return transitionScheduledRetries(merged, (node) => node.location.kind === "step" &&
+            node.location.turnId === turnId &&
+            node.location.step === nextStep &&
+            node.anchorSeq < next.updatedSeq, "cancelled", next.updatedSeq);
+    }
+    if (next.kind === "turn-error") {
+        return transitionScheduledRetries(merged, (node) => node.location.kind !== "session" &&
+            next.location.kind !== "session" &&
+            node.location.turnId === next.location.turnId, "cancelled", next.updatedSeq);
+    }
+    return merged;
+}
+function upsertBase(nodes, next) {
+    const index = nodes.findIndex((node) => node.key === next.key);
+    if (index < 0) {
+        return [...nodes, next].sort((left, right) => left.anchorSeq - right.anchorSeq || left.key.localeCompare(right.key));
+    }
+    const previous = nodes[index];
+    if (next.updatedSeq < previous.updatedSeq)
+        return [...nodes];
+    const merged = {
+        ...previous,
+        ...next,
+        anchorSeq: previous.anchorSeq,
+        at: previous.at,
+        location: previous.location,
+        data: { ...previous.data, ...next.data },
+    };
+    const result = [...nodes];
+    result[index] = merged;
+    return result;
+}
+function retryTurnId(node) {
+    return node.location.kind === "session" ? undefined : node.location.turnId;
+}
+function retryCandidateIndex(nodes, next) {
+    const exact = nodes.findIndex((node) => node.key === next.key);
+    if (exact >= 0)
+        return exact;
+    const update = retryUpdate(next);
+    const nextCurrent = modelRetryCurrent(next);
+    const attempt = update?.attempt ?? nextCurrent?.attempt;
+    const turnId = retryTurnId(next);
+    if (attempt === undefined || !turnId)
+        return -1;
+    for (let index = nodes.length - 1; index >= 0; index -= 1) {
+        const candidate = nodes[index];
+        const current = modelRetryCurrent(candidate);
+        if (candidate.kind !== "retry" || retryTurnId(candidate) !== turnId || !current)
+            continue;
+        if (current.attempt === attempt)
+            return index;
+        if (nextCurrent?.state === "scheduled" && current.attempt + 1 === attempt)
+            return index;
+    }
+    return -1;
+}
+function upsertRetryNode(nodes, next) {
+    const index = retryCandidateIndex(nodes, next);
+    const nextCurrent = modelRetryCurrent(next);
+    const update = retryUpdate(next);
+    if (index < 0) {
+        if (nextCurrent)
+            return upsertBase(nodes, next);
+        return upsertBase(nodes, {
+            ...next,
+            key: `unknown:${next.key}:${next.updatedSeq}`,
+            kind: "unknown",
+            status: undefined,
+            data: {
+                eventType: "model_retry",
+                preview: "Orphan model retry lifecycle update",
+            },
+        });
+    }
+    const previous = nodes[index];
+    if (next.updatedSeq < previous.updatedSeq)
+        return [...nodes];
+    let attempts = modelRetryAttempts(previous);
+    if (nextCurrent) {
+        attempts = attempts.map((attempt) => attempt.state === "scheduled" && attempt.attempt < nextCurrent.attempt
+            ? { ...attempt, state: "started" }
+            : attempt);
+        const existing = attempts.findIndex((attempt) => attempt.attempt === nextCurrent.attempt);
+        if (existing >= 0)
+            attempts[existing] = { ...attempts[existing], ...nextCurrent };
+        else
+            attempts = [...attempts, nextCurrent];
+    }
+    else if (update) {
+        attempts = attempts.map((attempt) => attempt.attempt === update.attempt
+            ? { ...attempt, state: update.state }
+            : attempt);
+    }
+    const current = attempts.at(-1);
+    if (!current)
+        return [...nodes];
+    const result = [...nodes];
+    result[index] = {
+        ...previous,
+        updatedSeq: next.updatedSeq,
+        status: current.state,
+        data: { attempts, current },
+    };
+    return result;
+}
+function transitionScheduledRetries(nodes, predicate, state, updatedSeq) {
+    return nodes.map((node) => {
+        const current = modelRetryCurrent(node);
+        if (node.kind !== "retry" || current?.state !== "scheduled" || !predicate(node)) {
+            return node;
+        }
+        const attempts = modelRetryAttempts(node).map((attempt) => attempt.attempt === current.attempt
+            ? { ...attempt, state }
+            : attempt);
+        const nextCurrent = attempts.at(-1);
+        return {
+            ...node,
+            updatedSeq: Math.max(node.updatedSeq, updatedSeq),
+            status: state,
+            data: { attempts, current: nextCurrent },
+        };
+    });
+}
+/** Resolve explicit parent links only. Cycles and excessive chains fail flat. */
+export function toolNestingDepths(tools, maxDepth = 32) {
+    const byId = new Map(tools.map((tool) => [tool.id, tool]));
+    const depths = new Map();
+    const cyclic = new Set();
+    const resolve = (id, path) => {
+        const cached = depths.get(id);
+        if (cached !== undefined)
+            return cached;
+        const cycleAt = path.indexOf(id);
+        if (cycleAt >= 0) {
+            for (const key of path.slice(cycleAt))
+                cyclic.add(key);
+            return 0;
+        }
+        if (path.length >= maxDepth)
+            return 0;
+        const tool = byId.get(id);
+        const parent = tool?.parentToolCallId;
+        if (!parent || !byId.has(parent) || parent === id)
+            return 0;
+        const depth = Math.min(maxDepth, resolve(parent, [...path, id]) + 1);
+        return cyclic.has(id) ? 0 : depth;
+    };
+    for (const tool of tools)
+        depths.set(tool.id, resolve(tool.id, []));
+    for (const id of cyclic)
+        depths.set(id, 0);
+    return depths;
+}