@tea-agent/loop-agent 0.24.7 → 0.24.8

package/CHANGELOG.md

@@ -10,6 +10,17 @@
 
 - 修复前端证据校验在 Windows 下通过长 `node -e` 命令执行时的终端转义崩溃：改为由 runtime 内部直接校验，兼容 CMD、Git Bash、PowerShell 与 Unix shell
 
+## [0.24.8] - 2026-07-29
+
+### 重点更新
+
+- 修复 FINAL-VERIFY 改写已存在的 allowed_paths 证据（gitignore）时 Git checkpoint 误失败，以及 record-error 后 Task Pool 卡在 Running 无法 mark-failed/retry 的问题
+
+### 修复
+
+- `finalizeGitTask` 对 allowed_paths 内的 pre-existing ignored evidence 允许 rewrite 并 force-add
+- `runReadyTasks` 在 record-error 时 best-effort 投影 `runs.jsonl` + Failed 状态，便于官方 retry
+
 ## [0.24.7] - 2026-07-29
 
 ### 重点更新

package/dist/worker/delivery/git-transaction.js

@@ -101,11 +101,12 @@ export async function finalizeGitTask(transaction, outcome) {
     await assertTransactionPosition(transaction.repoRoot, current);
     const currentIgnored = await readIgnoredBaseline(transaction.repoRoot);
     const ignoredBaselineByPath = new Map(current.ignoredBaseline.map((entry) => [entry.path, entry.sha256]));
-    const changedBaselineIgnored = currentIgnored.filter((entry) => ignoredBaselineByPath.has(entry.path) && ignoredBaselineByPath.get(entry.path) !== entry.sha256).map((entry) => entry.path);
-    const missingBaselineIgnored = current.ignoredBaseline.filter((entry) => !currentIgnored.some((candidate) => candidate.path === entry.path)).map((entry) => entry.path);
-    if (changedBaselineIgnored.length > 0 || missingBaselineIgnored.length > 0) {
-        throw new Error(`pre-existing ignored file changed during Git transaction: ${[...changedBaselineIgnored, ...missingBaselineIgnored].join(", ")}`);
-    }
+    const changedBaselineIgnored = currentIgnored
+        .filter((entry) => ignoredBaselineByPath.has(entry.path) && ignoredBaselineByPath.get(entry.path) !== entry.sha256)
+        .map((entry) => entry.path);
+    const missingBaselineIgnored = current.ignoredBaseline
+        .filter((entry) => !currentIgnored.some((candidate) => candidate.path === entry.path))
+        .map((entry) => entry.path);
     const existing = current.checkpoints.find((entry) => entry.workerRunId === outcome.workerRunId);
     if (outcome.status === "reused" || existing) {
         if (!existing)
@@ -123,12 +124,28 @@ export async function finalizeGitTask(transaction, outcome) {
     const newIgnored = currentIgnored.map((entry) => entry.path).filter((entry) => !ignoredBaselineByPath.has(entry));
     if (outcome.status === "succeeded") {
         const allowedPaths = expandAllowedPathsForWorkflow(resolveWorkflow(outcome.taskSpec).workflow, outcome.taskSpec.constraints.allowed_paths);
+        const isAllowedEvidencePath = (entry) => !isSensitivePath(entry) &&
+            !isEphemeralToolCachePath(entry) &&
+            allowedPaths.some((glob) => matchesGlob(entry, glob));
+        // Pre-existing ignored evidence under allowed_paths may be rewritten by
+        // FINAL-VERIFY smoke / verify-final and must force-add into the checkpoint.
+        // Other baseline ignored mutations remain fail-closed (e.g. dist/, secrets).
+        const blockedBaselineChanged = changedBaselineIgnored.filter((entry) => !isAllowedEvidencePath(entry));
+        const blockedBaselineMissing = missingBaselineIgnored.filter((entry) => !isEphemeralToolCachePath(entry) && !isAllowedEvidencePath(entry));
+        if (blockedBaselineChanged.length > 0 || blockedBaselineMissing.length > 0) {
+            throw new Error(`pre-existing ignored file changed during Git transaction: ${[...blockedBaselineChanged, ...blockedBaselineMissing].join(", ")}`);
+        }
         // Evidence under allowed_paths may be gitignored for local convenience (e.g.
         // reports/welcome/** smoke JSON) but must still checkpoint for Task Pool Done.
         // Sensitive / out-of-scope ignored files remain fail-closed; ephemeral tool
         // caches neither block nor force-add.
         const forceAddIgnored = [];
         const blockedIgnored = [];
+        const rewrittenBaselineEvidence = changedBaselineIgnored.filter((entry) => isAllowedEvidencePath(entry));
+        for (const entry of rewrittenBaselineEvidence) {
+            if (!forceAddIgnored.includes(entry))
+                forceAddIgnored.push(entry);
+        }
         for (const entry of newIgnored) {
             if (isEphemeralToolCachePath(entry))
                 continue;
@@ -137,7 +154,8 @@ export async function finalizeGitTask(transaction, outcome) {
                 continue;
             }
             if (allowedPaths.some((glob) => matchesGlob(entry, glob))) {
-                forceAddIgnored.push(entry);
+                if (!forceAddIgnored.includes(entry))
+                    forceAddIgnored.push(entry);
             }
             else {
                 blockedIgnored.push(entry);
@@ -166,7 +184,10 @@ export async function finalizeGitTask(transaction, outcome) {
             await assertTransactionPosition(transaction.repoRoot, { ...current, lastCheckpoint: commit });
             await assertCheckpointMetadata(transaction.repoRoot, commit, outcome.taskSpec, outcome.workerRunId);
             const afterCommitIgnored = await readIgnoredBaseline(transaction.repoRoot);
-            assertIgnoredBaselineUnchanged(current.ignoredBaseline.filter((entry) => !isEphemeralToolCachePath(entry.path)), afterCommitIgnored.filter((entry) => !isEphemeralToolCachePath(entry.path)));
+            // force-add may promote allowed evidence from ignored → tracked; drop those
+            // paths from the post-commit baseline equality check.
+            const forceAdded = new Set(forceAddIgnored);
+            assertIgnoredBaselineUnchanged(current.ignoredBaseline.filter((entry) => !isEphemeralToolCachePath(entry.path) && !forceAdded.has(entry.path)), afterCommitIgnored.filter((entry) => !isEphemeralToolCachePath(entry.path) && !forceAdded.has(entry.path)));
         }
         catch (error) {
             const branch = await git(transaction.repoRoot, ["branch", "--show-current"]).catch(() => "");
@@ -199,6 +220,10 @@ export async function finalizeGitTask(transaction, outcome) {
             changedFiles: checkpointFiles,
         };
     }
+    // Failed / keep-diff paths still fail closed on unexpected baseline ignored mutations.
+    if (changedBaselineIgnored.length > 0 || missingBaselineIgnored.length > 0) {
+        throw new Error(`pre-existing ignored file changed during Git transaction: ${[...changedBaselineIgnored, ...missingBaselineIgnored].join(", ")}`);
+    }
     const artifactDir = path.join(path.dirname(transaction.recordPath), "failures", outcome.workerRunId);
     await captureFailureArtifacts(transaction.repoRoot, artifactDir, changes, newIgnored, outcome);
     if (outcome.keepFailedDiff) {

package/dist/worker/runner/run-ready.js

@@ -304,11 +304,51 @@ export async function runReadyTasks(options) {
             if (result.status !== "succeeded") {
                 await options.onTaskFinalized?.({ status: result.status, taskSpec, workerRunId: result.workerRunId, runRecordPath: result.runRecordPath });
             }
+            const recordErrorMessage = errorMessage(error);
+            // Always project a Pool run fact for record-error so operators can
+            // mark-failed / retry without hand-editing Running state.
+            try {
+                await recordTaskPoolRun({
+                    repoRoot: options.repoRoot,
+                    run: {
+                        schemaVersion: 1,
+                        batchRunId,
+                        workerRunId: result.workerRunId,
+                        taskId: result.businessId,
+                        featureId: taskSpec.feature_id,
+                        status: "run-error",
+                        recordedAt: new Date().toISOString(),
+                        error: recordErrorMessage,
+                        runRecordPath: result.runRecordPath,
+                        ...(result.workflow ? { workflow: result.workflow } : {}),
+                        ...(controllerIdentity ? { controllerIdentity } : {}),
+                        ...(retryOfWorkerRunId ? { retryOfWorkerRunId } : {}),
+                    },
+                });
+                await writeTaskPoolState(options.repoRoot, {
+                    schemaVersion: 2,
+                    featureId: taskSpec.feature_id,
+                    taskId,
+                    status: "Failed",
+                    updatedAt: new Date().toISOString(),
+                    workerRunId: result.workerRunId,
+                    lastRunRecordPath: result.runRecordPath,
+                    failure: {
+                        category: "EnvFailure",
+                        recommendedFollowUpKind: "manual-review",
+                        derivedFollowUpTaskId: `${taskId}-record-error-review`,
+                        source: "report-decision",
+                    },
+                });
+            }
+            catch {
+                // Best-effort; batch still reports record-error.
+            }
             tasks.push({
                 taskId,
                 workerRunId: result.workerRunId,
                 status: "record-error",
-                error: errorMessage(error),
+                error: recordErrorMessage,
                 runRecordPath: result.runRecordPath,
             });
             break;

package/package.json

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