@tea-agent/loop-agent 0.39.2 → 0.39.3

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.39.2",
-  "gitSha": "307af1c538597568c7afc8cb976183cf622eb547",
-  "builtAt": "2026-08-28T07:27:33.141Z"
+  "version": "0.39.3",
+  "gitSha": "048826da6ab8dba7f01daa635ab582f68c539d06",
+  "builtAt": "2026-08-28T09:06:21.116Z"
 }

package/dist/task/source-prepare/fragment-inventory.js

@@ -92,6 +92,18 @@ function isAtxHeading(line) {
         return null;
     return { level: match[1].length, text: match[2].trim() };
 }
+/** Find the nearest explicit AC heading in a nested Markdown heading path.
+ * A subsection such as "异常场景" belongs to its enclosing `#### AC-*` block,
+ * even though the subsection heading itself has no ID. */
+function nearestAncestorExplicitAc(headingPath) {
+    const ancestors = headingPath.split(" > ").slice(0, -1).reverse();
+    for (const heading of ancestors) {
+        const matched = matchExplicitAcHeading(heading);
+        if (matched)
+            return matched;
+    }
+    return null;
+}
 function isListItem(line) {
     return /^\s*(?:[-*+]|\d+[.)])\s+(?:\[(?: |x|X)\]\s+)?/.test(line);
 }
@@ -173,6 +185,7 @@ export function splitDocumentIntoFragments(doc) {
         // V4 显式 AC 标题（`#### AC-*`）本身即验收段：标题行的 ID 原样保留。
         const lastHeadingSegment = section.headingPath.split(" > ").pop() ?? section.headingPath;
         const explicitSectionAc = matchExplicitAcHeading(lastHeadingSegment);
+        const ancestorExplicitAc = nearestAncestorExplicitAc(section.headingPath);
         const sectionKind = classifySectionHeading(section.headingPath);
         const effectiveKind = explicitSectionAc ? "acceptance" : sectionKind;
         const bodyStart = section.headingPath
@@ -181,7 +194,7 @@ export function splitDocumentIntoFragments(doc) {
         const bodyEnd = section.endLine;
         const bodyLines = lines.slice(Math.max(0, bodyStart - 1), Math.min(bodyEnd, lines.length));
         // 当前验收章节内最近的显式 AC ID（V4 标题或 AC 条目），正文片段继承它。
-        let pendingAcId = null;
+        let pendingAcId = explicitSectionAc?.id ?? ancestorExplicitAc?.id ?? null;
         const emit = (fragment) => {
             const explicit = fragment.explicitId ?? null;
             let id = explicit;

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.2",
+  "version": "0.39.3",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",