@tea-agent/loop-agent 0.39.1 → 0.39.3

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

@@ -8,6 +8,7 @@ import { writeTextArtifactFile } from "../../infrastructure/harness/artifact-sto
 import { findPackageRoot } from "../../shared/package-metadata.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
+import { parseLedgerJson } from "../../task/source-prepare/ledger.js";
 import { isDagSourceBindingV2 } from "./types.js";
 import { canonicalContractRel, classifyStructuredContractFailure, formatStructuredArtifactPointer, openspecCitationsRel, parseOpenspecCitationsBlock, persistRuntimeSkeleton, } from "./structured-output-repair.js";
 export const frontendNormalizationActionSchema = z.enum([
@@ -17,6 +18,7 @@ export const frontendNormalizationActionSchema = z.enum([
     "canonicalize-verification-alias",
     "drop-unresolved-verification-symbols",
     "inject-source-binding",
+    "inject-source-fidelity-provenance",
 ]);
 export function sha256Hex(input) {
     return createHash("sha256").update(input, "utf8").digest("hex");
@@ -1155,6 +1157,74 @@ function withDerivedRequirementIdsWhenUnscoped(binding, parsed) {
         ? { ...binding, requirementIds: derivedIds }
         : binding;
 }
+/**
+ * Restore source-fidelity evidence after an editable planner/revision patch
+ * has replaced the requirements array. Provenance is runtime-owned: the
+ * ledger, pinned by the DAG source binding, is the sole authority for a
+ * requirement's sourceFragmentIds and sourceRefs. This deliberately
+ * overwrites values emitted by a model instead of treating them as an
+ * override, so a planner cannot omit, fabricate, or drift source evidence.
+ */
+async function injectRuntimeOwnedSourceProvenance(input) {
+    if (!isDagSourceBindingV2(input.sourceBinding)) {
+        return { value: input.value, injected: false };
+    }
+    const workspaceRoot = workspaceRootFromDagRunDir(input.runDir);
+    if (!workspaceRoot) {
+        throw new Error("frontend source fidelity provenance injection requires a DAG run directory under .harness/dag-runs");
+    }
+    const ledgerPath = resolveDagTaskSourcePath({
+        workspaceRoot,
+        taskId: input.sourceBinding.taskId,
+        sourcePath: input.sourceBinding.ledgerPath,
+    });
+    let rawLedger;
+    try {
+        rawLedger = await readFile(ledgerPath, "utf8");
+    }
+    catch (error) {
+        throw new Error(`frontend source fidelity ledger unavailable for provenance injection: ${input.sourceBinding.ledgerPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const observedSha256 = sha256Hex(rawLedger);
+    if (observedSha256 !== input.sourceBinding.ledgerSha256) {
+        throw new Error(`frontend source fidelity ledger is stale or tampered for provenance injection: ${input.sourceBinding.ledgerPath} (bound ${input.sourceBinding.ledgerSha256}, observed ${observedSha256})`);
+    }
+    const ledger = parseLedgerJson(rawLedger);
+    if (ledger.taskId !== input.sourceBinding.taskId) {
+        throw new Error(`frontend source fidelity ledger taskId mismatch for provenance injection: bound ${input.sourceBinding.taskId}, ledger ${ledger.taskId}`);
+    }
+    if (ledger.inputDigest !== input.sourceBinding.inputDigest) {
+        throw new Error(`frontend source fidelity ledger inputDigest mismatch for provenance injection: bound ${input.sourceBinding.inputDigest}, ledger ${ledger.inputDigest}`);
+    }
+    const record = asRecord(input.value);
+    if (!record || !Array.isArray(record.requirements)) {
+        return { value: input.value, injected: false };
+    }
+    const provenanceByRequirementId = new Map(ledger.canonicalRequirements.map((requirement) => [
+        requirement.id,
+        {
+            sourceFragmentIds: [...requirement.sourceFragmentIds],
+            sourceRefs: [...requirement.sourceRefs],
+        },
+    ]));
+    let injected = false;
+    const requirements = record.requirements.map((item) => {
+        const requirement = asRecord(item);
+        if (!requirement)
+            return item;
+        const requirementId = canonicalizeRequirementId(asString(requirement.id));
+        const provenance = provenanceByRequirementId.get(requirementId);
+        if (!provenance)
+            return item;
+        injected = true;
+        return {
+            ...requirement,
+            sourceFragmentIds: provenance.sourceFragmentIds,
+            sourceRefs: provenance.sourceRefs,
+        };
+    });
+    return { value: { ...record, requirements }, injected };
+}
 function looksLikeStrictFrontendContract(value) {
     const record = asRecord(value);
     if (!record)
@@ -1686,8 +1756,24 @@ export async function analyzeFrontendImplementationContract(input) {
     // There is exactly one post-security candidate. A fallback candidate would
     // allow malformed raw fields to bypass the boundary checks above.
     const normalizedContract = coerceFrontendImplementationContractInput(parsed, canonicalBinding);
+    let runtimeOwnedContract = normalizedContract;
+    if (input.injectRuntimeOwnedSourceProvenance) {
+        try {
+            const injected = await injectRuntimeOwnedSourceProvenance({
+                runDir: input.runDir,
+                value: normalizedContract,
+                sourceBinding: input.sourceBinding,
+            });
+            runtimeOwnedContract = injected.value;
+            if (injected.injected)
+                pushAction("inject-source-fidelity-provenance");
+        }
+        catch (error) {
+            fail("blocked", error instanceof Error ? error.message : String(error), candidateJsonSha256);
+        }
+    }
     const candidate = deriveFrontendVerificationCoverage({
-        ...(asRecord(normalizedContract) ?? parsed),
+        ...(asRecord(runtimeOwnedContract) ?? parsed),
         sourceBinding: canonicalBinding,
     }, canonicalBinding);
     const result = frontendImplementationContractSchema.safeParse(candidate);
@@ -1886,6 +1972,7 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             runDir: input.runDir,
             rawContractText: serializeDeterministicJson(merged),
             sourceBinding: input.sourceBinding,
+            injectRuntimeOwnedSourceProvenance: true,
         });
         const normalizedArtifact = await writeDeterministicJsonArtifact(input.runDir, path.posix.join(candidateDir, `attempt-${attempt}.normalized.json`), analysis.canonical);
         await writeReport({
@@ -2053,6 +2140,7 @@ export async function validateFrontendRevisionPatchNodeOutput(input) {
             runDir: input.runDir,
             rawContractText: serializeDeterministicJson(merged),
             sourceBinding: input.sourceBinding,
+            injectRuntimeOwnedSourceProvenance: true,
         });
         const candidateDir = path.posix.join("contracts", "candidates", nodeId);
         await writeDeterministicJsonArtifact(input.runDir, path.posix.join(candidateDir, `attempt-${attempt}.extracted.json`), patch);

package/package.json

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