@tea-agent/loop-agent 0.43.0-next.5 → 0.43.0-next.6

package/CHANGELOG.md

@@ -10,6 +10,8 @@
 
 ### 改进
 
+- 修复模型续跑取消后带部分文字仍被标记成功的问题；前端 Plan 的取消、认证、限流及策略失败优先于容量恢复，精确格式错误保留原修复路径。完整性检查按需求建立单次索引，减少大计划重复扫描，同时拆分纯检查与恢复策略模块。
+
 - 优化 Operator Chat 长会话的流式渲染：完成回合、消息行、工具卡和用户输入锚点建立稳定的 memo 边界，流式文本更新不再重复渲染整段历史或重装锚点测量监听；缓存会在历史消息或工具实际更新时正确失效；无新增折叠回合时不再提交空状态及重复写入本地存储，工具参数与结果格式化按真实输入变化缓存。
 - 对话页「过程折叠」对齐 DSH 细节：折叠后的内容仍保留在页面中，浏览器 Ctrl+F 可直接命中并自动展开；折叠行展开时不再多出底部空隙；箭头改为 16px、颜色更淡的固定图标（靠旋转而非换图标），并补齐系统「减少动态效果」偏好；汇总文案新增「N 个 subagent」，内置 Explore 子代理不再计入普通工具调用。
 - 恢复前端 Plan 实时事实分页读取、逐需求 UX 遗漏检查与已完成范围复用；超限时补齐剩余验证目标，并接通 DAG 到 SDK 的原会话续跑。局部状态修改保留其他需求的关联，沿用耐久账本、显式替换和冻结分片边界。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.43.0-next.5",
-  "gitSha": "6a8572a4f425eb430ee85547653c581987b6c0d2",
-  "builtAt": "2026-09-09T06:17:31.024Z"
+  "version": "0.43.0-next.6",
+  "gitSha": "086f94db72547618b8dceb905a3972164acf56dd",
+  "builtAt": "2026-09-09T06:46:29.301Z"
 }

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

@@ -1,3 +1,6 @@
+import { collectFrontendPlanMissingFacts, collectFrontendPlanPhaseMissingFacts, committedFactFromPlanRecord, planFactStringList, planFactScopeIntersects } from "../workflows/dag/frontend-plan-completeness.js";
+export { collectFrontendPlanMissingFacts, collectFrontendPlanPhaseMissingFacts } from "../workflows/dag/frontend-plan-completeness.js";
+import { classifyFrontendPlanRecovery } from "../workflows/dag/frontend-plan-recovery-policy.js";
 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";
@@ -268,16 +271,6 @@ export function isPlannerThinkingExhausted(result, committedAnyFacts) {
         return false;
     return true;
 }
-/** Capacity recovery must not depend on whether a gateway emitted prose or
- * diagnostics. Precise provider/governance failures retain their ownership. */
-function isFrontendPlanCapacityStop(result) {
-    if (result.ok || result.timedOut)
-        return false;
-    if (result.failureCategory === OUTPUT_LIMIT_RETRY_CATEGORY)
-        return true;
-    return readWriterThinkingExhaustionEvidence(result).stopReason === "length" &&
-        (!result.failureCategory || ["empty-output", "network", "nonzero-exit", "unknown"].includes(result.failureCategory));
-}
 /**
  * The writer session burned an excessive token budget (a read-edit-test loop
  * that never converged) and still failed. Distinct from empty-output so the
@@ -3811,180 +3804,6 @@ const FRONTEND_PLAN_SEGMENTS = [
         ].join(" "),
     },
 ];
-function committedFactFromPlanRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return undefined;
-    const record = value;
-    if (record.phase !== undefined && record.phase !== "committed")
-        return undefined;
-    const fact = record.fact;
-    return fact && typeof fact === "object" && !Array.isArray(fact)
-        ? fact
-        : typeof record.kind === "string"
-            ? record
-            : undefined;
-}
-function planFactStringList(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
-}
-function planFactScopeIntersects(fact, requirementIds) {
-    return planFactStringList(fact.scopeRequirementIds).some((id) => requirementIds.has(id));
-}
-/** Compute the authoritative coverage queue from the committed plan ledger. */
-export function collectFrontendPlanMissingFacts(input) {
-    const requirements = new Map();
-    const standaloneEvidenceGaps = new Set();
-    const verificationTargetIds = new Set();
-    const verificationTargetRequirements = new Map();
-    for (const value of input.committedFacts) {
-        const fact = committedFactFromPlanRecord(value);
-        if (!fact || fact.origin !== "plan")
-            continue;
-        if (fact.kind === "plan-requirement" && fact.entry && typeof fact.entry === "object") {
-            const entry = fact.entry;
-            if (typeof entry.id === "string" && entry.id.trim())
-                requirements.set(entry.id, entry);
-        }
-        if (fact.kind === "plan-verification-target" && fact.entry && typeof fact.entry === "object") {
-            const entry = fact.entry;
-            const id = entry.id;
-            if (typeof id === "string" && id.trim()) {
-                verificationTargetIds.add(id);
-                verificationTargetRequirements.set(id, new Set(Array.isArray(entry.requirementIds)
-                    ? entry.requirementIds.filter((value) => typeof value === "string")
-                    : []));
-            }
-        }
-        if (fact.kind === "plan-evidence-gap" && fact.entry && typeof fact.entry === "object") {
-            const entry = fact.entry;
-            const requirementId = entry.requirementId;
-            const description = entry.description;
-            if (typeof requirementId === "string" && requirementId.trim() && typeof description === "string" && description.trim()) {
-                standaloneEvidenceGaps.add(requirementId);
-            }
-        }
-    }
-    const missing = [];
-    for (const id of input.requirementIds) {
-        const entry = requirements.get(id);
-        if (!entry) {
-            missing.push({
-                kind: "plan-requirement",
-                id,
-                requirementIds: [id],
-                reason: `requirement ${id} has no committed plan-requirement fact`,
-            });
-            continue;
-        }
-        const targetIds = Array.isArray(entry.verificationTargetIds)
-            ? entry.verificationTargetIds.filter((value) => typeof value === "string" && value.trim().length > 0)
-            : [];
-        const gap = entry.evidenceGap && typeof entry.evidenceGap === "object"
-            ? entry.evidenceGap
-            : undefined;
-        const hasEvidenceGap = (typeof gap?.description === "string" && gap.description.trim().length > 0) ||
-            standaloneEvidenceGaps.has(id);
-        if (targetIds.length === 0 && !hasEvidenceGap) {
-            missing.push({
-                kind: "plan-verification-target",
-                requirementIds: [id],
-                reason: `requirement ${id} declares neither a verification target nor a non-empty evidenceGap`,
-            });
-            continue;
-        }
-        for (const targetId of targetIds) {
-            if (!verificationTargetIds.has(targetId) ||
-                !verificationTargetRequirements.get(targetId)?.has(id)) {
-                missing.push({
-                    kind: "plan-verification-target",
-                    id: targetId,
-                    requirementIds: [id],
-                    reason: `requirement ${id} references verification target ${targetId}, but that target is not committed`,
-                });
-            }
-        }
-    }
-    return missing;
-}
-/** Completeness checks for phases whose facts are committed incrementally. */
-export function collectFrontendPlanPhaseMissingFacts(input) {
-    const facts = input.committedFacts
-        .map(committedFactFromPlanRecord)
-        .filter((fact) => Boolean(fact && fact.origin === "plan"));
-    if (input.phase === "ux-registry") {
-        return facts.some((fact) => fact.kind === "state-registry")
-            ? []
-            : [
-                {
-                    kind: "state-registry",
-                    requirementIds: [...input.requirementIds],
-                    reason: "global UX vocabulary phase has no committed state-registry fact",
-                },
-            ];
-    }
-    if (input.phase === "ux-local") {
-        if (input.requirementIds.length > 1) {
-            return input.requirementIds.flatMap(id => collectFrontendPlanPhaseMissingFacts({
-                ...input, requirementIds: [id],
-            }));
-        }
-        const needsUx = input.requirementIds.some((id) => input.behaviorRequiredRequirementIds?.includes(id));
-        if (!needsUx)
-            return [];
-        const requirementSlice = new Set(input.requirementIds);
-        const scopedFacts = facts.filter((fact) => planFactScopeIntersects(fact, requirementSlice));
-        const hasChoice = scopedFacts.some((fact) => fact.kind === "component-choice" &&
-            Array.isArray(fact.uiComponentChoices) &&
-            fact.uiComponentChoices.length > 0);
-        const canonicalStateFlow = collectCanonicalStateFlowNames(scopedFacts);
-        const liveStateFlow = collectCanonicalStateFlowNames(facts);
-        const hasStateFlow = [...canonicalStateFlow.uiStateNames].some(name => liveStateFlow.uiStateNames.has(name)) ||
-            [...canonicalStateFlow.interactionNames].some(name => liveStateFlow.interactionNames.has(name));
-        const missing = [];
-        if (!hasChoice) {
-            missing.push({
-                kind: "component-choice",
-                requirementIds: [...input.requirementIds],
-                reason: "behaviour-required UX slice has no committed component-choice fact",
-            });
-        }
-        if (!hasStateFlow) {
-            missing.push({
-                kind: "state-flow",
-                requirementIds: [...input.requirementIds],
-                reason: "behaviour-required UX slice has no committed state-flow fact",
-            });
-        }
-        return missing;
-    }
-    const hasMockApi = facts.some((fact) => fact.kind === "mock-api");
-    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)));
-    const missing = [];
-    if (!hasMockApi) {
-        missing.push({
-            kind: "mock-api",
-            requirementIds: [...input.requirementIds],
-            reason: "global Mock/data phase has no committed mock-api fact",
-        });
-    }
-    for (const interaction of liveInteractions) {
-        if (coveredInteractions.has(interaction))
-            continue;
-        missing.push({
-            kind: "data-flow",
-            id: interaction,
-            requirementIds: [...input.requirementIds],
-            reason: `interaction ${interaction} has no committed data-flow fact`,
-        });
-    }
-    return missing;
-}
 /** Estimate calls conservatively: requirement + one VT, with a second VT
  * reserved for behaviour-required requirements. Explicit declarations win. */
 export function estimateFrontendPlanRequirementRecordCalls(fact) {
@@ -5069,13 +4888,13 @@ export async function runFrontendPlanSegmentedSessions(input) {
         // ownership; an unrelated/global fact must not prove a slice complete.
         if (input.attempt > 1 && input.committedFacts && session.id.startsWith("ux-local-") && session.requirementSlice?.length) {
             const facts = input.committedFacts();
-            const complete = session.requirementSlice.every(id => {
-                const owned = facts.filter(value => {
-                    const fact = committedFactFromPlanRecord(value);
-                    return fact && planFactStringList(fact.scopeRequirementIds).includes(id);
-                });
-                return owned.length > 0 && collectFrontendPlanPhaseMissingFacts({ phase: "ux-local", requirementIds: [id], committedFacts: facts, behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds }).length === 0;
-            });
+            const ownedIds = new Set(facts.flatMap(value => {
+                const fact = committedFactFromPlanRecord(value);
+                return fact ? planFactStringList(fact.scopeRequirementIds) : [];
+            }));
+            const complete = session.requirementSlice.every(id => ownedIds.has(id)) &&
+                collectFrontendPlanPhaseMissingFacts({ phase: "ux-local", requirementIds: session.requirementSlice,
+                    committedFacts: facts, behaviorRequiredRequirementIds: input.behaviorRequiredRequirementIds }).length === 0;
             if (complete) {
                 index += 1;
                 continue;
@@ -5278,9 +5097,10 @@ export async function runFrontendPlanSegmentedSessions(input) {
                         : isUxLocalSession
                             ? buildUxPrompt(session.requirementSlice ?? [], missing)
                             : buildPhasePrompt(globalMockDataSegment, missing, session.requirementSlice ?? allRequirementIds);
-        if (result.timedOut || /interrupt|termination-unconfirmed|budget_breach/.test(result.failureCategory))
+        const recovery = classifyFrontendPlanRecovery({ ...result, stopReason: readWriterThinkingExhaustionEvidence(result).stopReason });
+        if (recovery === "stop")
             return { ...result, ok: false };
-        if ((isFrontendPlanCapacityStop(result) || (session.atomicRecovery && result.ok)) && input.committedFacts &&
+        if ((recovery === "output" || (session.atomicRecovery && result.ok)) && input.committedFacts &&
             !(missingPhaseFacts.length === 1 && missingPhaseFacts[0].kind === "plan-requirement") &&
             (session.coverageOnly || isUxRegistrySession || isUxLocalSession || session.id.startsWith("global-mock-data"))) {
             if (missingPhaseFacts.length === 0) {
@@ -5317,7 +5137,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
             return { ...accumulated, ok: false, failureCategory: OUTPUT_LIMIT_RETRY_CATEGORY,
                 stderr: `${accumulated.stderr}\nfrontend plan capacity recovery exhausted: preserve committed facts; phase=${session.id}; scope=${missingIds.join(",")}; strategy=atomic-fact; missing=${JSON.stringify(missingPhaseFacts)}`.trim() };
         }
-        const capacityExhausted = readWriterThinkingExhaustionEvidence(result).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory);
+        const capacityExhausted = recovery === "output" || recovery === "context";
         if (capacityExhausted && !result.timedOut) {
             const failure = () => mapPlannerExhaustion({ ...result, ok: false, stderr: `${result.stderr}\nFRONTEND_INPUT_UNIT_TOO_LARGE: ${session.id}; no smaller complete scope can finish; unchanged retries are disabled` }, committedAfter > committedBefore);
             const missingCoverageIds = input.committedFacts ? [...new Set(collectFrontendPlanMissingFacts({ requirementIds: session.coverageSlice ?? session.requirementSlice ?? allRequirementIds, committedFacts: input.committedFacts() }).flatMap(f => f.requirementIds))] : [...(session.coverageSlice ?? session.requirementSlice ?? allRequirementIds)];
@@ -5423,7 +5243,7 @@ export async function runFrontendPlanSegmentedSessions(input) {
                 : undefined;
         const zeroProgressBurn = coverageSlice !== undefined &&
             coverageSlice.length > 1 &&
-            (readWriterThinkingExhaustionEvidence(result).stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory) || (committedAfter === committedBefore && !(result.assistantText ?? "").trim() && !result.stderr.trim())) &&
+            (capacityExhausted || (["empty-output", "unknown"].includes(result.failureCategory) && committedAfter === committedBefore && !(result.assistantText ?? "").trim() && !result.stderr.trim())) &&
             !result.timedOut;
         if (zeroProgressBurn && coverageSlice) {
             const missingIds = input.committedFacts ? new Set(collectFrontendPlanMissingFacts({ requirementIds: coverageSlice, committedFacts: input.committedFacts() }).flatMap(f => f.requirementIds)) : undefined;

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

@@ -978,6 +978,7 @@ async function executeSingleSdkAttemptInternal(options) {
         ? collected.parsedEvents
         : (fallbackParsed?.parsedEvents ?? 0);
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
+    const cancelled = stopReason === "aborted";
     const outputLimitExhausted = Boolean(options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !timedOut && !stderr);
     const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : stopReason === "aborted" ? "cancelled" : outputLimitExhausted ? "output-limit" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : terminationConfirmed
         ? classifyPiFailure({
@@ -994,13 +995,14 @@ async function executeSingleSdkAttemptInternal(options) {
         backend: "sdk",
         command: ["pi-sdk", ...piSdkArgs],
         durationMs,
-        exitCode: timedOut || stderr || outputLimitExhausted ? 1 : 0,
+        exitCode: timedOut || stderr || outputLimitExhausted || cancelled ? 1 : 0,
         failureCategory,
         modelDisplay,
         ok: terminationConfirmed &&
             !timedOut &&
             !stderr &&
             !outputLimitExhausted &&
+            !cancelled &&
             assistantText.length > 0 &&
             !collected.outputTooLarge,
         parsedEvents,

package/dist/workflows/dag/frontend-plan-completeness.js

@@ -0,0 +1,186 @@
+import { collectCanonicalStateFlowNames } from "./frontend-contract-facts.js";
+export function committedFactFromPlanRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (record.phase !== undefined && record.phase !== "committed")
+        return undefined;
+    const fact = record.fact;
+    return fact && typeof fact === "object" && !Array.isArray(fact)
+        ? fact
+        : typeof record.kind === "string"
+            ? record
+            : undefined;
+}
+export function planFactStringList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+export function planFactScopeIntersects(fact, requirementIds) {
+    return planFactStringList(fact.scopeRequirementIds).some((id) => requirementIds.has(id));
+}
+/** Compute the authoritative coverage queue from the committed plan ledger. */
+export function collectFrontendPlanMissingFacts(input) {
+    const requirements = new Map();
+    const standaloneEvidenceGaps = new Set();
+    const verificationTargetIds = new Set();
+    const verificationTargetRequirements = new Map();
+    for (const value of input.committedFacts) {
+        const fact = committedFactFromPlanRecord(value);
+        if (!fact || fact.origin !== "plan")
+            continue;
+        if (fact.kind === "plan-requirement" && fact.entry && typeof fact.entry === "object") {
+            const entry = fact.entry;
+            if (typeof entry.id === "string" && entry.id.trim())
+                requirements.set(entry.id, entry);
+        }
+        if (fact.kind === "plan-verification-target" && fact.entry && typeof fact.entry === "object") {
+            const entry = fact.entry;
+            const id = entry.id;
+            if (typeof id === "string" && id.trim()) {
+                verificationTargetIds.add(id);
+                verificationTargetRequirements.set(id, new Set(Array.isArray(entry.requirementIds)
+                    ? entry.requirementIds.filter((value) => typeof value === "string")
+                    : []));
+            }
+        }
+        if (fact.kind === "plan-evidence-gap" && fact.entry && typeof fact.entry === "object") {
+            const entry = fact.entry;
+            const requirementId = entry.requirementId;
+            const description = entry.description;
+            if (typeof requirementId === "string" && requirementId.trim() && typeof description === "string" && description.trim()) {
+                standaloneEvidenceGaps.add(requirementId);
+            }
+        }
+    }
+    const missing = [];
+    for (const id of input.requirementIds) {
+        const entry = requirements.get(id);
+        if (!entry) {
+            missing.push({
+                kind: "plan-requirement",
+                id,
+                requirementIds: [id],
+                reason: `requirement ${id} has no committed plan-requirement fact`,
+            });
+            continue;
+        }
+        const targetIds = Array.isArray(entry.verificationTargetIds)
+            ? entry.verificationTargetIds.filter((value) => typeof value === "string" && value.trim().length > 0)
+            : [];
+        const gap = entry.evidenceGap && typeof entry.evidenceGap === "object"
+            ? entry.evidenceGap
+            : undefined;
+        const hasEvidenceGap = (typeof gap?.description === "string" && gap.description.trim().length > 0) ||
+            standaloneEvidenceGaps.has(id);
+        if (targetIds.length === 0 && !hasEvidenceGap) {
+            missing.push({
+                kind: "plan-verification-target",
+                requirementIds: [id],
+                reason: `requirement ${id} declares neither a verification target nor a non-empty evidenceGap`,
+            });
+            continue;
+        }
+        for (const targetId of targetIds) {
+            if (!verificationTargetIds.has(targetId) ||
+                !verificationTargetRequirements.get(targetId)?.has(id)) {
+                missing.push({
+                    kind: "plan-verification-target",
+                    id: targetId,
+                    requirementIds: [id],
+                    reason: `requirement ${id} references verification target ${targetId}, but that target is not committed`,
+                });
+            }
+        }
+    }
+    return missing;
+}
+/** Completeness checks for phases whose facts are committed incrementally. */
+export function collectFrontendPlanPhaseMissingFacts(input) {
+    const facts = input.committedFacts
+        .map(committedFactFromPlanRecord)
+        .filter((fact) => Boolean(fact && fact.origin === "plan"));
+    if (input.phase === "ux-registry") {
+        return facts.some((fact) => fact.kind === "state-registry")
+            ? []
+            : [
+                {
+                    kind: "state-registry",
+                    requirementIds: [...input.requirementIds],
+                    reason: "global UX vocabulary phase has no committed state-registry fact",
+                },
+            ];
+    }
+    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))
+                continue;
+            const scopedFacts = byRequirement.get(id) ?? [];
+            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));
+            if (!hasChoice) {
+                missing.push({
+                    kind: "component-choice",
+                    requirementIds: [id],
+                    reason: "behaviour-required UX slice has no committed component-choice fact",
+                });
+            }
+            if (!hasStateFlow) {
+                missing.push({
+                    kind: "state-flow",
+                    requirementIds: [id],
+                    reason: "behaviour-required UX slice has no committed state-flow fact",
+                });
+            }
+        }
+        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 coveredInteractions = new Set(facts
+        .filter((fact) => fact.kind === "data-flow")
+        .flatMap((fact) => planFactStringList(fact.interactions)));
+    const missing = [];
+    if (!hasMockApi) {
+        missing.push({
+            kind: "mock-api",
+            requirementIds: [...input.requirementIds],
+            reason: "global Mock/data phase has no committed mock-api fact",
+        });
+    }
+    for (const interaction of liveInteractions) {
+        if (coveredInteractions.has(interaction))
+            continue;
+        missing.push({
+            kind: "data-flow",
+            id: interaction,
+            requirementIds: [...input.requirementIds],
+            reason: `interaction ${interaction} has no committed data-flow fact`,
+        });
+    }
+    return missing;
+}

package/dist/workflows/dag/frontend-plan-recovery-policy.js

@@ -0,0 +1,18 @@
+/** Precise failures own their recovery. A stale transport length marker must
+ * never turn cancellation, provider rejection or policy failure into progress. */
+export function classifyFrontendPlanRecovery(result) {
+    const category = result.failureCategory ?? "";
+    if (result.timedOut || result.stopReason === "aborted" ||
+        /interrupt|termination-unconfirmed|budget_breach/.test(category) ||
+        ["cancelled", "auth", "missing-api-key", "rate-limit", "quota", "timeout", "tool-policy", "write-guard", "path-violation", "governance-blocked", "human-rejected"].includes(category))
+        return "stop";
+    if (result.ok)
+        return "none";
+    if (category === "output-limit")
+        return "output";
+    if (["context-overflow", "context-budget-exhausted"].includes(category))
+        return "context";
+    if (result.stopReason === "length" && ["", "empty-output", "network", "nonzero-exit", "unknown"].includes(category))
+        return "output";
+    return "none";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0-next.5",
+  "version": "0.43.0-next.6",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",