@tea-agent/loop-agent 0.39.0-next.9 → 0.39.1

package/dist/task/contract/transaction.js

@@ -21,6 +21,7 @@ export async function runJournaledContractCommit(input) {
     const constraintsRel = `source/${CONSTRAINTS_FILE_NAME}`;
     const taskConfigRel = "task.json";
     const contractRel = CONTRACT_FILE_NAME;
+    const requirementLedgerRel = `source/requirement-ledger.json`;
     const targetSpecs = [
         {
             kind: "requirement",
@@ -46,6 +47,17 @@ export async function runJournaledContractCommit(input) {
             content: input.targets.contractRef,
             isJson: true,
         },
+        ...(input.targets.requirementLedgerContent !== undefined
+            ? [
+                {
+                    kind: "requirement-ledger",
+                    relativePath: requirementLedgerRel,
+                    // Content is already serialized JSON text; stageText avoids double-encoding.
+                    content: input.targets.requirementLedgerContent,
+                    isJson: false,
+                },
+            ]
+            : []),
     ];
     const targetRecords = [];
     for (const spec of targetSpecs) {

package/dist/task/source-prepare/build-draft.js

@@ -22,6 +22,18 @@ function resolveTaskKindExplicit(flags, baseDraft) {
         return flags.taskKindExplicit;
     return baseDraft?.taskKindExplicit ?? false;
 }
+/**
+ * Resolve managed backend-test layout config.
+ * Precedence: explicit CLI flags > --from-draft base > existing task.json
+ * (the last tier self-heals tasks whose backendTest was hand-written).
+ */
+function resolveBackendTest(flags, baseDraft, existing) {
+    if (flags.backendTest !== undefined)
+        return flags.backendTest;
+    if (baseDraft?.backendTest !== undefined)
+        return baseDraft.backendTest;
+    return existing?.backendTest ?? undefined;
+}
 function resolveTitle(taskId, flags, facts, baseDraft, existing) {
     return (trimNonEmpty(flags.title) ??
         trimNonEmpty(baseDraft?.title) ??
@@ -205,6 +217,9 @@ export function buildPrepareDraft(input) {
     };
     if (featureId)
         draft.featureId = featureId;
+    const backendTest = resolveBackendTest(flags, baseDraft, existingTaskConfig);
+    if (backendTest !== undefined)
+        draft.backendTest = backendTest;
     if (references && references.length > 0) {
         draft.references = references.map((ref) => ({
             role: ref.role,

package/dist/task/source-prepare/completeness.js

@@ -55,6 +55,25 @@ export function observationBlocksPrepare(state) {
     }
     return null;
 }
+/**
+ * 精确 identity 绑定的人类 resolution 判定（AC-001 / AC-005）：decidedBy==='human'、
+ * decision trim 后非空、sourceRef 与冲突 id 精确匹配三者同时成立才算有效；model/
+ * system 伪造判定、stale sourceRef（不匹配当前冲突 identity）或空/空白 decision 一律
+ * 不解锁。resolution 信息取自 draft 层（不重排流水线，listPrepareGaps 仍先于 ledger
+ * 构建执行）。
+ */
+export function hasValidHumanConflictResolution(draft, conflictId) {
+    for (const resolution of draft.sourceResolutions ?? []) {
+        if (resolution.sourceRef !== conflictId)
+            continue;
+        if (resolution.decidedBy !== "human")
+            continue;
+        if (!resolution.decision?.trim())
+            continue;
+        return true;
+    }
+    return false;
+}
 export function listPrepareGaps(input) {
     const gaps = [];
     const risks = [];
@@ -108,6 +127,12 @@ export function listPrepareGaps(input) {
     }
     if (input.acceptanceConflicts && input.acceptanceConflicts.length > 0) {
         for (const conflict of input.acceptanceConflicts) {
+            // AC-001：有效 human resolution（human + 非空 decision + sourceRef 与冲突 id
+            // 精确匹配）解除该 id 的 legacy blocking gap；无 resolution 或 resolution 不
+            // 满足三条件（AC-005：伪造判定 / stale sourceRef / 空 decision）仍发射阻断。
+            if (hasValidHumanConflictResolution(input.draft, conflict.id)) {
+                continue;
+            }
             gaps.push({
                 code: "ACCEPTANCE_ID_CONFLICT",
                 level: "blocking",
@@ -246,3 +271,166 @@ export function hasBlockingGaps(gaps) {
 export function hasBlockingRisks(risks) {
     return risks.some((risk) => risk.level === "blocking");
 }
+/**
+ * Source fidelity ledger 分级 fail-closed 阻断（AC-003 / AC-FIDELITY-003）：
+ * 高风险未映射/排除、unresolved、冲突返回稳定错误并阻断；低风险 context-only 仅当
+ * 理由完整且独立 reviewer pass 后继续；duplicate 保留全部来源（warning 可见）。
+ * 仅 taskKind 为 frontend-implementation 时全量阻断，其他 taskKind 保持 warning。
+ */
+export function appendLedgerGaps(input) {
+    const { gaps, risks } = input;
+    if (!input.ledgerSummary?.present)
+        return;
+    const blocking = input.taskKind === "frontend-implementation";
+    const level = blocking ? "blocking" : "warning";
+    const summary = input.ledgerSummary;
+    if (summary.unresolvedCount > 0) {
+        const gap = {
+            code: "SOURCE_FIDELITY_UNRESOLVED",
+            level,
+            message: `ledger 有 ${summary.unresolvedCount} 个 unresolved fragment（需人工 sourceResolutions 确认后才可继续）`,
+            details: {
+                fragmentIds: summary.exclusions
+                    .filter((e) => /^REQ-SRC-/.test(e.fragmentId) || e.fragmentId.startsWith("AC-"))
+                    .slice(0, 10)
+                    .map((e) => e.fragmentId),
+            },
+            selfHealing: blocking
+                ? {
+                    action: "reimport-prd",
+                    steps: [
+                        "检查原始 PRD 中无法映射到 canonical AC 的可执行片段（unresolved）",
+                        "补齐/修正 PRD 使每个可执行片段都能绑定 AC，或由人工在 sourceResolutions 中确认排除理由",
+                        "重新 importPrd（同 taskId）后 task advance 重建 ledger",
+                    ],
+                }
+                : undefined,
+        };
+        gaps.push(gap);
+        risks.push({
+            code: "SOURCE_FIDELITY_UNRESOLVED",
+            level: blocking ? "blocking" : "elevated",
+            message: gap.message,
+        });
+    }
+    if (summary.conflictCount > 0) {
+        const gap = {
+            code: "SOURCE_FIDELITY_CONFLICT",
+            level,
+            message: `ledger 检测到 ${summary.conflictCount} 个 AC 文本冲突（同一 ID 不同文本）`,
+            selfHealing: blocking
+                ? {
+                    action: "reimport-prd",
+                    steps: [
+                        "统一同一 AC ID 的文本后重新 importPrd（同 taskId）",
+                        "或由人工在 sourceResolutions 中声明冲突取舍（conflict → decision）",
+                    ],
+                }
+                : undefined,
+        };
+        gaps.push(gap);
+        risks.push({
+            code: "SOURCE_FIDELITY_CONFLICT",
+            level: blocking ? "blocking" : "elevated",
+            message: gap.message,
+        });
+    }
+    if (summary.failureCode === "SOURCE_FIDELITY_HIGH_RISK_UNCOVERED") {
+        const gap = {
+            code: "SOURCE_FIDELITY_HIGH_RISK_UNCOVERED",
+            level,
+            message: "ledger 存在高风险 acceptance 片段未映射到 canonical requirement",
+            selfHealing: blocking
+                ? {
+                    action: "reimport-prd",
+                    steps: [
+                        "为每个未覆盖的高风险片段补齐 canonical AC（或人工 sourceResolutions 确认）",
+                        "重新 importPrd（同 taskId）后 task advance 重建 ledger",
+                    ],
+                }
+                : undefined,
+        };
+        gaps.push(gap);
+        risks.push({
+            code: "SOURCE_FIDELITY_HIGH_RISK_UNCOVERED",
+            level: blocking ? "blocking" : "elevated",
+            message: gap.message,
+        });
+    }
+    for (const error of input.ledgerErrors ?? []) {
+        if (error.code === "SOURCE_FIDELITY_LEDGER_MISSING") {
+            const gap = {
+                code: "SOURCE_FIDELITY_LEDGER_MISSING",
+                level,
+                message: error.message,
+            };
+            gaps.push(gap);
+        }
+        // AC-BLOCK-001：canonical requirement 缺少 fragment/sourceRef 证据、来源引用
+        // 无效、fragment 无效均为 blocking gap（frontend task），保证 prepare/apply
+        // 以稳定码 fail closed（appendLedgerGaps 是 prepare 补洞的唯一入口）。
+        if (error.code === "SOURCE_FIDELITY_REQUIREMENT_NOT_COVERED" ||
+            error.code === "SOURCE_FIDELITY_SOURCE_REF_INVALID" ||
+            error.code === "SOURCE_FIDELITY_FRAGMENT_INVALID") {
+            const gap = {
+                code: error.code,
+                level,
+                message: error.message,
+                selfHealing: blocking
+                    ? {
+                        action: "reimport-prd",
+                        steps: [
+                            "检查 PRD 中每个 canonical requirement 是否都有可审计的 fragment/sourceRef 证据",
+                            "补齐缺失的验收标准映射或修正引用后重新 importPrd（同 taskId）",
+                            "重新 importPrd（同 taskId）后 task advance 重建 ledger",
+                        ],
+                    }
+                    : undefined,
+            };
+            gaps.push(gap);
+            risks.push({
+                code: error.code,
+                level: blocking ? "blocking" : "elevated",
+                message: error.message,
+            });
+        }
+        if (error.code === "SOURCE_FIDELITY_CONTEXT_ONLY_UNREVIEWED" &&
+            blocking) {
+            // 低风险 context-only 仅独立 reviewer pass 放行；未通过则 frontend 任务阻断。
+            const gap = {
+                code: "SOURCE_FIDELITY_CONTEXT_ONLY_UNREVIEWED",
+                level: "blocking",
+                message: error.message,
+                selfHealing: {
+                    action: "reimport-prd",
+                    steps: [
+                        "检查 context-only 片段是否缺少完整排除理由，或由人工在 sourceResolutions 中确认",
+                        "重新 importPrd（同 taskId）后 task advance 重建 ledger 并复核 reviewer 判定",
+                    ],
+                },
+            };
+            gaps.push(gap);
+        }
+    }
+    // 低风险 context-only：记录并提示排除理由/独立 reviewer 要求（不阻断普通任务）。
+    if (summary.contextOnlyCount > 0) {
+        gaps.push({
+            code: "SOURCE_FIDELITY_CONTEXT_ONLY_UNREVIEWED",
+            level: "warning",
+            message: `ledger 有 ${summary.contextOnlyCount} 个 context-only fragment（低风险排除；frontend 任务需完整理由且独立 reviewer pass）`,
+            details: {
+                fragmentIds: summary.exclusions
+                    .filter((e) => e.fragmentId.startsWith("REQ-SRC-"))
+                    .slice(0, 10)
+                    .map((e) => e.fragmentId),
+            },
+        });
+    }
+    if (summary.duplicateCount > 0) {
+        gaps.push({
+            code: "SOURCE_FIDELITY_DUPLICATE_PRESERVED",
+            level: "warning",
+            message: `ledger 保留 ${summary.duplicateCount} 个 duplicate fragment（duplicate 保留全部来源）`,
+        });
+    }
+}