@tea-agent/loop-agent 0.44.0-next.7 → 0.44.0-next.8

package/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### 新增
 
+- main 上的 npm `next` 预发布改为跑默认测试（fast + integration），不再在每次发布时重复跑约 6 分钟的 I/O-heavy 池；完整三池仍由 PR、正式 release 线、本地推送前检查与发布前钩子承担。同时把该预发布任务的 I/O 并发从 1 调到 2，并把 npm 包可见性确认的等待窗口从约 3 分钟拉长到约 10 分钟，避免包已发出却因仓库异步处理未完成而被判失败。
+
 - 修复 main 分支的 next 发布链在类型检查阶段内存溢出失败的问题：完整源码与测试的类型图已超过 Node 默认约 2 GiB 堆上限，类型检查进程因此中止（exit 134），导致 `next` 发布无法完成。此前该上限只在部分验证入口生效，其余入口直接运行类型检查就会因默认堆不足而失败；现把上限固化到类型检查命令本身，各验证入口与本地开发统一生效，不再依赖各入口自行声明。
 - 数据库连接支持断线自动重连：MySQL/PostgreSQL 空闲会话被服务端超时杀掉后，下一次查询会用同一配置透明重开连接并重试一次，不再需要手动重连或重启 Console；MySQL 适配器同时吸收服务端主动断开产生的异步错误，避免未处理错误事件影响进程。
 
@@ -38,6 +40,7 @@
 
 ### 改进
 
+- Operator Chat 输入框下方的会话统计对齐 DSH：长串静态文字收敛为两个可点击摘要，可分别查看模型/工具用时、TTFT、TPS 与 Token 分项；详情卡互斥并支持外部点击或 Escape 关闭，窄屏打开时不会推动输入框或消息流。
 - Operator Chat 长会话新增完整轮次轨道与按需历史定位，可从任意用户消息精确新建会话；历史图片刷新后仍可预览，仓库文件链接可直接定位到行，最终回答显示单轮 token/耗时，并支持可持久化的紧凑/完整阅读模式。图片文件与消息记录分离保存，删除、分叉和失败回滚会同步清理，附件读取重新校验类型与引用。
 - 本地分支合并默认只执行与影响面匹配的定向测试、类型检查、构建和治理检查；完整测试推迟到 push 或完整交付前，并通过 receipt、`verify:tree` 或 pre-push 在最终 tree 上只执行一次。发布与推送门禁仍包含 I/O-heavy 测试。
 - Operator Chat 重新整理消息时间线：思考、工具、重试、命令和回答按实际顺序展示，工具调用不再被误标为“未识别事件”，未知事件只显示简短摘要。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.7",
-  "gitSha": "561015cd071b2aba74c823716703e756d2236929",
-  "builtAt": "2026-09-16T18:31:45.598Z"
+  "version": "0.44.0-next.8",
+  "gitSha": "e100bbbeba403ae8cbe6c9a93ccce76cbadf434e",
+  "builtAt": "2026-09-16T23:48:41.706Z"
 }

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

@@ -0,0 +1,4 @@
+/** DAG Pi 共享类型守卫：纯叶子模块，零依赖，禁止反向依赖执行器入口。 */
+export function isRecordObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/executors/dag-pi/model-config.js

@@ -0,0 +1,30 @@
+/** DAG Pi 模型引用解析：纯配置叶子模块，零依赖，禁止反向依赖执行器入口。 */
+export const DEFAULT_DAG_PI_PROVIDER = "wizard-local";
+export const DAG_PI_MODEL_PROVIDERS = {
+    "gpt-5.3-codex-spark": "wizard-local",
+    "gpt-5.5": "wizard-local",
+    "glm-5.2": "wizard-local",
+    "deepseek-v4-flash": "deepseek",
+    "deepseek-v4-pro": "deepseek",
+};
+export function resolveDagPiModelConfig(modelReference, options) {
+    const separatorIndex = modelReference.indexOf("/");
+    const qualified = separatorIndex >= 0;
+    const provider = qualified
+        ? modelReference.slice(0, separatorIndex)
+        : (DAG_PI_MODEL_PROVIDERS[modelReference] ?? DEFAULT_DAG_PI_PROVIDER);
+    const model = qualified
+        ? modelReference.slice(separatorIndex + 1)
+        : modelReference;
+    if (!provider || !model) {
+        throw new Error(`invalid DAG Pi model reference "${modelReference}": expected non-empty provider/model`);
+    }
+    const explicitThinking = options?.thinking?.trim();
+    const thinking = explicitThinking ??
+        (provider === "wizard-local" && model === "gpt-5.5" ? "low" : undefined);
+    return {
+        provider,
+        model,
+        ...(thinking ? { thinking } : {}),
+    };
+}

package/dist/{workflows/dag/frontend-plan-completeness.js → executors/dag-pi/plan/facts.js}

@@ -1,14 +1,5 @@
-import { collectCanonicalStateFlowNames } from "./frontend-contract-facts.js";
-export function enrichFrontendPlanMissingFacts(missing) {
-    return missing.map((item) => ({
-        ...item,
-        owner: "Plan",
-        repairScope: item.kind === "state-registry" || item.kind === "mock-api"
-            ? "global-phase"
-            : item.requirementIds.length > 1 ? "requirement-slice" : "fact",
-        nextAction: "replace-fact-and-finalize",
-    }));
-}
+/** DAG Pi plan ledger 完整性事实计算：纯类型与纯函数，禁止反向依赖执行器入口。 */
+import { collectCanonicalStateFlowNames } from "../../../workflows/dag/frontend-contract-facts.js";
 export function committedFactFromPlanRecord(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return undefined;
@@ -76,9 +67,16 @@ export function collectFrontendPlanMissingFacts(input) {
             });
             continue;
         }
-        const targetIds = Array.isArray(entry.verificationTargetIds)
+        // Verification targets are the single authoritative direction. The
+        // legacy requirement-side list is accepted only as a fallback while
+        // resuming older ledgers; new plans derive it from target.requirementIds.
+        const derivedTargetIds = [...verificationTargetRequirements.entries()]
+            .filter(([, requirementIds]) => requirementIds.has(id))
+            .map(([targetId]) => targetId);
+        const legacyTargetIds = Array.isArray(entry.verificationTargetIds)
             ? entry.verificationTargetIds.filter((value) => typeof value === "string" && value.trim().length > 0)
             : [];
+        const targetIds = derivedTargetIds.length > 0 ? derivedTargetIds : legacyTargetIds;
         const gap = entry.evidenceGap && typeof entry.evidenceGap === "object"
             ? entry.evidenceGap
             : undefined;
@@ -104,7 +102,7 @@ export function collectFrontendPlanMissingFacts(input) {
             }
         }
     }
-    return enrichFrontendPlanMissingFacts(missing);
+    return missing;
 }
 /** Completeness checks for phases whose facts are committed incrementally. */
 export function collectFrontendPlanPhaseMissingFacts(input) {
@@ -123,54 +121,40 @@ export function collectFrontendPlanPhaseMissingFacts(input) {
             ];
     }
     if (input.phase === "ux-local") {
-        // One snapshot per check: no cross-revision cache to invalidate.
-        const required = new Set(input.behaviorRequiredRequirementIds ?? []);
-        const requested = new Set(input.requirementIds.filter(id => required.has(id)));
-        if (!requested.size)
-            return [];
-        const byRequirement = new Map();
-        for (const fact of facts) {
-            for (const id of new Set(planFactStringList(fact.scopeRequirementIds))) {
-                if (!requested.has(id))
-                    continue;
-                const entries = byRequirement.get(id) ?? [];
-                entries.push(fact);
-                byRequirement.set(id, entries);
-            }
-        }
-        const liveStateFlow = collectCanonicalStateFlowNames(facts);
         const missing = [];
-        for (const id of input.requirementIds) {
-            if (!required.has(id))
+        // Evaluate each behaviour requirement independently. A fact scoped to AC-1
+        // must not accidentally satisfy AC-2 merely because both ids share one
+        // UX session; shared facts remain valid when they explicitly list both ids.
+        for (const requirementId of input.requirementIds) {
+            if (!input.behaviorRequiredRequirementIds?.includes(requirementId))
                 continue;
-            const scopedFacts = byRequirement.get(id) ?? [];
+            const scopedFacts = facts.filter((fact) => planFactScopeIntersects(fact, new Set([requirementId])));
             const hasChoice = scopedFacts.some((fact) => fact.kind === "component-choice" &&
                 Array.isArray(fact.uiComponentChoices) &&
                 fact.uiComponentChoices.length > 0);
             const canonicalStateFlow = collectCanonicalStateFlowNames(scopedFacts);
-            const hasStateFlow = [...canonicalStateFlow.uiStateNames].some(name => liveStateFlow.uiStateNames.has(name)) ||
-                [...canonicalStateFlow.interactionNames].some(name => liveStateFlow.interactionNames.has(name));
+            const hasStateFlow = canonicalStateFlow.uiStateNames.size > 0 ||
+                canonicalStateFlow.interactionNames.size > 0;
             if (!hasChoice) {
                 missing.push({
                     kind: "component-choice",
-                    requirementIds: [id],
+                    requirementIds: [requirementId],
                     reason: "behaviour-required UX slice has no committed component-choice fact",
                 });
             }
             if (!hasStateFlow) {
                 missing.push({
                     kind: "state-flow",
-                    requirementIds: [id],
+                    requirementIds: [requirementId],
                     reason: "behaviour-required UX slice has no committed state-flow fact",
                 });
             }
         }
-        return enrichFrontendPlanMissingFacts(missing);
+        return missing;
     }
     const hasMockApi = facts.some((fact) => fact.kind === "mock-api");
-    const allInteractions = collectCanonicalStateFlowNames(facts).interactionNames;
-    const requested = new Set(input.requirementIds);
-    const liveInteractions = new Set([...collectCanonicalStateFlowNames(facts.filter(f => !planFactStringList(f.scopeRequirementIds).length || planFactScopeIntersects(f, requested))).interactionNames].filter(name => allInteractions.has(name)));
+    const allInteractions = collectCanonicalStateFlowNames(input.committedFacts).interactionNames;
+    const liveInteractions = new Set([...collectCanonicalStateFlowNames(facts.filter(f => !planFactStringList(f.scopeRequirementIds).length || planFactScopeIntersects(f, new Set(input.requirementIds)))).interactionNames].filter(name => allInteractions.has(name)));
     const coveredInteractions = new Set(facts
         .filter((fact) => fact.kind === "data-flow")
         .flatMap((fact) => planFactStringList(fact.interactions)));
@@ -192,5 +176,5 @@ export function collectFrontendPlanPhaseMissingFacts(input) {
             reason: `interaction ${interaction} has no committed data-flow fact`,
         });
     }
-    return enrichFrontendPlanMissingFacts(missing);
+    return missing;
 }

package/dist/executors/dag-pi/plan/ledger-contract.js

@@ -0,0 +1,55 @@
+/** DAG Pi plan ledger 契约与来源继承装载：纯类型与纯函数，禁止反向依赖执行器入口。 */
+import path from "node:path";
+import { frontendExecutionSchema } from "../../../workflows/dag/frontend-execution-groups.js";
+/**
+ * Source fidelity ledger (AC-005/AC-006): load the contract node's committed
+ * requirement facts and build a requirement-id → provenance map. The contract
+ * node declared sourceFragmentIds/sourceRefs from the ledger's
+ * requirement→fragment mapping; the plan inherits them by id so the compiled
+ * canonical contract carries authoritative provenance without the plan
+ * re-deriving (or fabricating) it. Best-effort: missing/unreadable contract
+ * ledger yields an empty map and the plan compiles as before (the design
+ * policy shell will then fail closed on missing provenance).
+ */
+export async function loadContractRequirementInheritance(runDir) {
+    const { readTypedEventStoreFromJsonl } = await import("../../../workflows/dag/frontend-typed-event-store.js");
+    let records;
+    try {
+        records = await readTypedEventStoreFromJsonl(path.join(runDir, "frontend-contract-pi", "contract-typed-facts.jsonl"));
+    }
+    catch {
+        return new Map();
+    }
+    const byId = new Map();
+    for (const record of records) {
+        const fact = record.fact;
+        if (!fact || typeof fact !== "object")
+            continue;
+        const recordFact = fact;
+        if (recordFact.origin !== "contract" ||
+            recordFact.kind !== "requirement") {
+            continue;
+        }
+        // Contract requirement facts carry id/sourceFragmentIds/sourceRefs on
+        // the fact itself (origin=contract, kind=requirement, id, text, ...),
+        // not inside an `entry` wrapper.
+        const id = typeof recordFact.id === "string" ? recordFact.id : "";
+        if (!id)
+            continue;
+        const sourceFragmentIds = Array.isArray(recordFact.sourceFragmentIds)
+            ? recordFact.sourceFragmentIds.filter((value) => typeof value === "string")
+            : undefined;
+        const sourceRefs = Array.isArray(recordFact.sourceRefs)
+            ? recordFact.sourceRefs.filter((value) => typeof value === "string")
+            : undefined;
+        if (sourceFragmentIds || sourceRefs) {
+            byId.set(id, {
+                ...(typeof recordFact.text === "string" ? { text: recordFact.text } : {}),
+                ...(recordFact.execution !== undefined ? { execution: frontendExecutionSchema.parse(recordFact.execution) } : {}),
+                ...(sourceFragmentIds ? { sourceFragmentIds } : {}),
+                ...(sourceRefs ? { sourceRefs } : {}),
+            });
+        }
+    }
+    return byId;
+}