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

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.6",
-  "gitSha": "11c9ac87f792e61b1bc31b1ef2aeacb48a6334d4",
-  "builtAt": "2026-09-16T11:49:07.558Z"
+  "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;
+}