@tea-agent/loop-agent 0.28.1 → 0.28.2-beta.1

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -570,6 +570,106 @@ function canonicalizeVerificationTargetAliases(value) {
         : record.requirements;
     return { ...record, requirements };
 }
+/**
+ * Model-written evidence gaps are hypotheses, not authoritative coverage
+ * facts. If the plan contains a real verification target that explicitly
+ * names a requirement, the executor can prove that the requirement has a
+ * verification path even when the model forgot to wire the target into the
+ * requirement entry or conservatively marked its gap as blocking.
+ *
+ * Keep gaps blocking when that proof cannot be derived. This is deliberately
+ * narrow: it uses only sourceBinding requirement IDs and structurally present
+ * verification targets, and never invents a command, file, or target.
+ */
+function deriveFrontendVerificationCoverage(value, canonicalBinding) {
+    const record = asRecord(value);
+    if (!record)
+        return value;
+    const rawTargets = Array.isArray(record.verificationTargets)
+        ? record.verificationTargets
+        : [];
+    const targetIds = new Set(rawTargets
+        .map((item) => asRecord(item))
+        .filter((item) => Boolean(item))
+        .map((item) => asString(item.id))
+        .filter(Boolean));
+    const targetIdsByRequirement = new Map();
+    for (const item of rawTargets) {
+        const target = asRecord(item);
+        if (!target)
+            continue;
+        const targetId = asString(target.id);
+        const commandLabel = asString(target.commandLabel) || asString(target.command);
+        const file = asString(target.file);
+        // A target is usable evidence only when it has an identity, command and
+        // file. The strict schema will validate the final shape afterwards.
+        if (!targetId || !commandLabel || !file)
+            continue;
+        for (const requirementId of asStringArray(target.requirementIds)) {
+            const canonicalId = canonicalizeRequirementId(requirementId);
+            if (!canonicalBinding.requirementIds.includes(canonicalId))
+                continue;
+            const ids = targetIdsByRequirement.get(canonicalId) ?? [];
+            if (!ids.includes(targetId))
+                ids.push(targetId);
+            targetIdsByRequirement.set(canonicalId, ids);
+        }
+    }
+    const provenRequirementIds = new Set(targetIdsByRequirement.keys());
+    const requirements = Array.isArray(record.requirements)
+        ? record.requirements.map((item) => {
+            const requirement = asRecord(item);
+            if (!requirement)
+                return item;
+            const requirementId = canonicalizeRequirementId(asString(requirement.id));
+            const inferredTargetIds = targetIdsByRequirement.get(requirementId) ?? [];
+            const existingTargetIds = asStringArray(requirement.verificationTargetIds)
+                .filter((id) => targetIds.has(id));
+            const verificationTargetIds = [...new Set([
+                    ...existingTargetIds,
+                    ...inferredTargetIds,
+                ])];
+            const evidenceGap = asRecord(requirement.evidenceGap);
+            const hasProof = provenRequirementIds.has(requirementId);
+            return {
+                ...requirement,
+                ...(verificationTargetIds.length > 0 ? { verificationTargetIds } : {}),
+                ...(hasProof
+                    ? (evidenceGap ? { evidenceGap: { ...evidenceGap, blocking: false } } : {})
+                    : {
+                        evidenceGap: {
+                            requirementId,
+                            description: `No executable verification target can be derived for ${requirementId}`,
+                            blocking: true,
+                        },
+                    }),
+            };
+        })
+        : record.requirements;
+    const modelEvidenceGaps = Array.isArray(record.evidenceGaps)
+        ? record.evidenceGaps.map((item) => {
+            const gap = asRecord(item);
+            if (!gap)
+                return item;
+            const requirementId = canonicalizeRequirementId(asString(gap.requirementId));
+            // Model gaps are advisory. Blocking status is reconstructed below
+            // from the source binding and executable verification targets.
+            return { ...gap, blocking: false };
+        })
+        : [];
+    const derivedBlockingGaps = canonicalBinding.requirementIds
+        .filter((requirementId) => !provenRequirementIds.has(requirementId))
+        .map((requirementId) => ({
+        requirementId,
+        description: `No executable verification target can be derived for ${requirementId}`,
+        blocking: true,
+    }));
+    return {
+        ...record,
+        requirements,
+        evidenceGaps: [...modelEvidenceGaps, ...derivedBlockingGaps],
+    };
+}
 function assertFrontendContractPathsSafe(value) {
     const record = asRecord(value);
     if (!record)
@@ -1069,10 +1169,10 @@ export async function materializeFrontendImplementationContract(input) {
     const normalizedContract = coerceFrontendImplementationContractInput(parsed, canonicalBinding);
     // There is exactly one post-security candidate. A fallback candidate would
     // allow malformed raw fields to bypass the boundary checks above.
-    const candidate = {
+    const candidate = deriveFrontendVerificationCoverage({
         ...(asRecord(normalizedContract) ?? parsed),
         sourceBinding: canonicalBinding,
-    };
+    }, canonicalBinding);
     const result = frontendImplementationContractSchema.safeParse(candidate);
     if (!result.success)
         throw new Error(`invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.28.1",
+  "version": "0.28.2-beta.1",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",