@tea-agent/loop-agent 0.33.7-beta.0 → 0.34.1

package/dist/application/task-lifecycle/observe.js

@@ -5,7 +5,7 @@ import { logicalRevisionForState, observeTaskContractState, } from "../../task/c
 import { assessDagRunLiveness, listAllDagRunEntries, readDagRunSpec, readDagRunState, } from "../../workflows/dag/lifecycle.js";
 import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
 import { loadLifecycleRecord } from "./record.js";
-import { buildGateBinding, buildWriteSetGate, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
+import { buildGateBinding, buildWriteSetGate, buildWriteSetGateDelta, controllerIdentityAnchor, hashCanonicalPayload, normalizeWriteSet, sha256Hex, } from "./gates.js";
 async function exists(filePath) {
     try {
         await access(filePath);
@@ -263,6 +263,15 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
                 : null),
         })
         : null;
+    const gateDelta = gateBound != null
+        ? buildWriteSetGateDelta({
+            writeSet: gateBound.writeSet,
+            contractAllowedPaths: taskConfigAllowed,
+            writers: (parsedSpec?.tasks ?? [])
+                .filter((task) => task.writePolicy === "exclusive")
+                .map((task) => ({ id: task.id, writeSet: task.writeSet ?? [] })),
+        })
+        : null;
     const lastGate = record?.lastGate;
     const currentDigest = gateBound != null
         ? buildWriteSetGate({ taskId, bound: gateBound }).digest
@@ -277,7 +286,7 @@ export async function observeTaskLifecycle(repoRoot, taskId) {
     // not already approved/rejected. Rejected same-digest gates stay closed
     // until contract/source/DAG/writeSet/controller binding changes.
     const gate = gateBound && strictValidated && !approvedCurrent && !rejectedCurrent
-        ? buildWriteSetGate({ taskId, bound: gateBound })
+        ? buildWriteSetGate({ taskId, bound: gateBound, delta: gateDelta })
         : null;
     const gateOpen = Boolean(gate);
     let legacyState;

package/dist/application/task-lifecycle/plan-transitions.js

@@ -62,17 +62,21 @@ export function planTransitions(input) {
         expectedTransitions.push("contract-managed");
     }
     else if (!sourceReady || !contractManaged) {
-        if ((shouldImportPrd || alreadyImportedPrd) &&
-            !input.hasEngineeringBoundary) {
-            // Console bootstrap / import-only: archive PRD(s), do not prepare contract yet.
-            if (shouldImportPrd) {
-                actions.push({ type: "import-prd" });
-                expectedTransitions.push("prd-imported");
-            }
+        // Console PRD Intake Bridge (2026-08-11), two-phase:
+        // 1) hasPrdInput without engineering boundary → import only (archive
+        //    references). Do NOT prepare yet so multi-file bootstrap can finish
+        //    all imports before the one-shot Semantic Intake burns.
+        // 2) alreadyImportedPrd without new --prd (and/or with boundary) →
+        //    prepare-contract so deterministic parse + Semantic Intake run.
+        // prepare soft-stops on EMPTY_ALLOWED_PATHS etc. and never opens the
+        // writeSet gate without a complete managed contract.
+        if (shouldImportPrd && !input.hasEngineeringBoundary) {
+            actions.push({ type: "import-prd" });
+            expectedTransitions.push("prd-imported");
             actions.push({ type: "stop", reason: "blocker" });
             blockers.push({
                 code: "BOUNDARY_REQUIRED",
-                message: "PRD imported; provide --allowed-path / --verify (or --from-text with boundaries) to prepare contract and open writeSet gate",
+                message: "PRD imported; re-run task advance (optionally with --allowed-path / --verify) to prepare contract / semantic intake",
             });
             return {
                 actions,
@@ -80,7 +84,7 @@ export function planTransitions(input) {
                 blockers,
                 next: {
                     kind: "advance",
-                    command: `loop-agent task advance ${snapshot.taskId} --allowed-path <glob> --verify <label:command> --json`,
+                    command: `loop-agent task advance ${snapshot.taskId} --json`,
                 },
                 expectedTransitions,
             };
@@ -218,18 +222,6 @@ export function planTransitions(input) {
         expectedTransitions,
     };
 }
-function stopWith(actions, expectedTransitions, blockers, snapshot, reason) {
-    return {
-        actions: [...actions, { type: "stop", reason }],
-        gate: snapshot.gate ?? null,
-        blockers,
-        next: {
-            kind: "advance",
-            command: `loop-agent task advance ${snapshot.taskId} --json`,
-        },
-        expectedTransitions,
-    };
-}
 function deriveNext(snapshot, gate, approveGate) {
     if (gate && !approveGate) {
         return { kind: "approve-gate", command: gate.approveCommand };

package/dist/commands/init-upgrade.js

@@ -1023,6 +1023,7 @@ function assertPendingAcceptance(value, state, task) {
     }
     const pending = value;
     const desiredSha256 = task.evidence.desiredSha256;
+    const sourceAnchorSha256 = task.evidence.sourceAnchorSha256;
     const guard = pending.guard;
     const receipt = pending.receipt;
     const transition = pending.transition;
@@ -1039,6 +1040,9 @@ function assertPendingAcceptance(value, state, task) {
         !isSha256(guard.desiredSha256) ||
         !isSha256(desiredSha256) ||
         guard.desiredSha256 !== desiredSha256 ||
+        (sourceAnchorSha256 === undefined
+            ? guard.sourceAnchorSha256 !== undefined
+            : guard.sourceAnchorSha256 !== sourceAnchorSha256) ||
         !isMergeReceipt(receipt) ||
         receipt.taskId !== guard.taskId ||
         receipt.path !== guard.path ||
@@ -1076,6 +1080,9 @@ function acceptedSurface(input) {
     acceptedEntry.acceptedMerge = {
         currentSha256: input.currentSha256,
         desiredSha256: input.desiredSha256,
+        ...(typeof input.task.evidence.sourceAnchorSha256 === "string"
+            ? { sourceAnchorSha256: input.task.evidence.sourceAnchorSha256 }
+            : {}),
     };
     return { beforeEntry: cloneJson(entry), accepted };
 }
@@ -1210,6 +1217,7 @@ async function recordAcceptedMerge(input) {
     if (!desiredSha256) {
         throw new Error(`init upgrade cannot accept ${input.task.path}: desired hash evidence is missing`);
     }
+    const sourceAnchorSha256 = input.task.evidence.sourceAnchorSha256;
     const canonicalPath = normalizeAllowedPath(input.task.path);
     const surfacePath = path.join(input.state.repoRoot, INIT_SURFACE_STATE_PATH);
     let pending = input.pending;
@@ -1263,6 +1271,9 @@ async function recordAcceptedMerge(input) {
                 allowedPaths: [canonicalPath],
                 currentSha256: input.currentSha256,
                 desiredSha256,
+                ...(sourceAnchorSha256 !== undefined
+                    ? { sourceAnchorSha256 }
+                    : {}),
             },
             receipt,
             transition: {
@@ -2412,7 +2423,27 @@ async function executeUpgrade(directory, state, input) {
     });
     state.actionReceipts.push(...safe.applied);
     await writeJsonAtomic(path.join(directory, "change-manifest.json"), state.actionReceipts);
-    const post = await checkInitUpdate({ repoRoot: state.repoRoot });
+    let post = await checkInitUpdate({ repoRoot: state.repoRoot });
+    // Converge remaining safe deterministic init actions before the final check.
+    // Project/governance-derived drift (e.g. a personalized project rename after
+    // an accepted merge) settles here instead of failing finalCheck. Model merge
+    // tasks and human decisions are never auto-applied.
+    while (post.deterministicActions.length > 0) {
+        const converged = await applyInitUpdate({
+            repoRoot: state.repoRoot,
+            applySafe: true,
+            clientRecovery: "project",
+        });
+        state.actionReceipts.push(...converged.applied);
+        await writeJsonAtomic(path.join(directory, "change-manifest.json"), state.actionReceipts);
+        if (converged.applied.length === 0)
+            break;
+        post = await checkInitUpdate({ repoRoot: state.repoRoot });
+        if (post.humanDecisions.length > 0 ||
+            post.modelMergeTasks.length > 0) {
+            break;
+        }
+    }
     state.humanDecisions = post.humanDecisions;
     if (post.humanDecisions.length > 0) {
         state.mergeTasks = [];

package/dist/commands/init.js

@@ -1414,6 +1414,70 @@ async function readExistingSurfaceState(repoRoot) {
         return undefined;
     return parsed;
 }
+/** The IDE schema reference remains a structural update signal. */
+const HARNESS_STRUCTURAL_VALUE_KEYS = new Set(["$schema"]);
+const PI_MODEL_ROUTING_KEYS = new Set(["LOW", "MED", "HIGH", "defaultModel"]);
+function isPiModelRoutingPath(path) {
+    return path.length === 2 && path[0] === "executors" && path[1] === "pi";
+}
+/**
+ * Attribute-set iteration comparison for harness.json: object key shapes must
+ * agree at every level, except that the Pi model-routing fields are opaque
+ * project-owned configuration. Scalars and array contents may otherwise differ
+ * freely unless the key is structurally sensitive.
+ */
+function harnessJsonShapeMatches(current, desired, path = []) {
+    if (isRecord(current) || isRecord(desired)) {
+        if (!isRecord(current) || !isRecord(desired))
+            return false;
+        const filterKeys = (value) => Object.keys(value)
+            .filter((key) => !isPiModelRoutingPath(path) || !PI_MODEL_ROUTING_KEYS.has(key))
+            .sort();
+        const currentKeys = filterKeys(current);
+        const desiredKeys = filterKeys(desired);
+        if (currentKeys.length !== desiredKeys.length)
+            return false;
+        for (let index = 0; index < currentKeys.length; index += 1) {
+            const key = currentKeys[index];
+            if (key !== desiredKeys[index])
+                return false;
+            if (HARNESS_STRUCTURAL_VALUE_KEYS.has(key)) {
+                if (!isDeepStrictEqual(current[key], desired[key]))
+                    return false;
+                continue;
+            }
+            if (!harnessJsonShapeMatches(current[key], desired[key], [...path, key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return true;
+}
+/**
+ * Stable package/source anchor for generated desired content: sha256 of the
+ * desired content re-rendered through buildDesiredSurfaceContent with fixed
+ * sentinel identity values (PROJECT_NAME_TOKEN / GOVERNANCE_ROOT_TOKEN). The
+ * anchor is therefore deterministic and invariant to the real project name and
+ * governance root: a project rename or governance-root change never invalidates
+ * a previously accepted semantic merge, while package/template content changes
+ * still do. Rendering with sentinels (instead of reverse split/join replacement
+ * on already-rendered bytes) avoids false drift when a real project name is a
+ * common substring such as `init` or `docs`.
+ */
+async function stableDesiredSourceAnchor(input) {
+    const manifestPath = targetPathToManifestPath(input.entry.path, input.governanceRoot);
+    const sentinel = await buildDesiredSurfaceContent({
+        assetRoot: input.assetRoot,
+        repoRoot: input.repoRoot,
+        projectName: PROJECT_NAME_TOKEN,
+        governanceRoot: GOVERNANCE_ROOT_TOKEN,
+        entry: { ...input.entry, path: manifestPath },
+    });
+    return sentinel.content === undefined
+        ? undefined
+        : sha256Text(sentinel.content);
+}
 /**
  * Lightweight read-only preflight for the post-upgrade init surface notifier.
  *
@@ -1458,10 +1522,20 @@ async function buildCurrentSurfaceState(input) {
             entry: manifestEntry,
         });
         const sourceSha256 = desired.content === undefined ? undefined : sha256Text(desired.content);
+        const sourceAnchorSha256 = entry.mode !== "generated" || desired.content === undefined
+            ? undefined
+            : await stableDesiredSourceAnchor({
+                assetRoot,
+                repoRoot: input.repoRoot,
+                projectName: input.projectName,
+                governanceRoot: input.governanceRoot,
+                entry,
+            });
         const base = {
             status: targetStat ? "present" : "missing",
             relationship: "missing-from-target",
             sourceSha256,
+            sourceAnchorSha256,
             sourcePath: desired.sourcePath
                 ? repoRelative(assetRoot, desired.sourcePath)
                 : undefined,
@@ -1510,7 +1584,7 @@ async function buildCurrentSurfaceState(input) {
         if (targetRelativePath === "harness.json" &&
             desired.content !== undefined) {
             try {
-                semanticallyMatchesGeneratedJson = isDeepStrictEqual(JSON.parse(current.toString("utf-8")), JSON.parse(desired.content));
+                semanticallyMatchesGeneratedJson = harnessJsonShapeMatches(JSON.parse(current.toString("utf-8")), JSON.parse(desired.content));
             }
             catch {
                 // Invalid JSON remains local-existing-unknown for model merge / doctor.
@@ -1563,6 +1637,9 @@ async function writeInitSurfaceState(input) {
             harness.acceptedMerge = {
                 currentSha256: harness.currentSha256,
                 desiredSha256: harness.sourceSha256,
+                ...(harness.sourceAnchorSha256 !== undefined
+                    ? { sourceAnchorSha256: harness.sourceAnchorSha256 }
+                    : {}),
             };
         }
     }
@@ -2729,6 +2806,7 @@ function modelMergeTaskFor(pathName, state, allPaths, recordedState) {
             baseSha256: recordedState?.files[pathName]?.currentSha256,
             currentSha256: state.currentSha256,
             desiredSha256: state.sourceSha256,
+            sourceAnchorSha256: state.sourceAnchorSha256,
         },
     };
 }
@@ -2847,8 +2925,16 @@ export async function checkInitUpdate(input) {
         if (state.relationship === "local-existing-unknown") {
             const acceptedMerge = recordedState?.files[pathName]?.acceptedMerge;
             if (acceptedMerge) {
+                // Generated acceptance is bound to the stable source anchor so that
+                // project-derived desired drift (projectName/governanceRoot changes)
+                // cannot invalidate an already accepted merge. Copied files remain
+                // byte-strict; desiredSha256 stays the audit receipt in both cases.
+                const anchorAccepted = state.mode === "generated" &&
+                    state.sourceAnchorSha256 !== undefined &&
+                    acceptedMerge.sourceAnchorSha256 === state.sourceAnchorSha256;
                 if (acceptedMerge.currentSha256 === state.currentSha256 &&
-                    acceptedMerge.desiredSha256 === state.sourceSha256) {
+                    (anchorAccepted ||
+                        acceptedMerge.desiredSha256 === state.sourceSha256)) {
                     continue;
                 }
                 // A previously accepted semantic merge is user-preserving ownership.
@@ -2906,7 +2992,12 @@ export async function checkInitUpdate(input) {
                     reason: `replace the legacy default governanceRoot docs with ${governanceRoot}`,
                 });
             }
-            if (isRecord(harness)) {
+            // A harness that already matches the current generated surface except for
+            // opaque Pi routing fields is modern, not a legacy-routing candidate.
+            // Keep the explicit migration assessment for every other harness shape.
+            if (isRecord(harness) &&
+                currentState.files["harness.json"]?.relationship !==
+                    "matches-current-generated") {
                 const modelMigration = assessHarnessModelMigration(harness);
                 if (modelMigration.kind === "safe") {
                     deterministicActions.push({

package/dist/executors/dag-pi-executor.js

@@ -8,7 +8,7 @@ import { cleanupPlaywrightCliDefaultSession, createPlaywrightCliTool, PI_COMMAND
 import { dagCommandPolicyAllows, resolveDagCommandPolicy, } from "../workflows/dag/types.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
 import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
-import { isWriterEmptyDiffRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
+import { isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 /**
@@ -831,6 +831,18 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     if (meta.writeGuardAttribution === "best-effort") {
         stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
     }
+    // Pure provider stall/timeout with zero workspace side effects is eligible
+    // for a single writer transport retry (implement-pi flake resilience).
+    // Partial writes, tool calls, or write-guard failures keep raw `timeout`.
+    const writerCleanTimeout = !mapped.ok &&
+        mapped.failureCategory === "timeout" &&
+        writeGuardOk &&
+        !completenessFailure &&
+        !writerThinkingExhausted &&
+        isWriterTransportRetryCandidate(input.task) &&
+        changeManifestChangedFiles !== undefined &&
+        changeManifestChangedFiles.length === 0 &&
+        readWriterThinkingExhaustionEvidence(result).writeToolCallCount === 0;
     return {
         ...mapped,
         ok: false,
@@ -851,7 +863,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 // the continuation is retryable and carries the embedded target paths.
                 // Provider/transport failures (quota, auth, network, timeout,
                 // rate-limit, unavailable) keep their original category so a provider
-                // outage is never masked as a recoverable local write problem.
+                // outage is never masked as a recoverable local write problem — except
+                // clean timeouts with zero attributed writes, remapped below.
                 writeGuardOk &&
                     completenessFailure?.failureCategory ===
                         INCOMPLETE_WRITE_SET_RETRY_CATEGORY &&
@@ -867,7 +880,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                         // upgrade to incomplete-write-set above.
                         writerThinkingExhausted
                             ? WRITER_THINKING_EXHAUSTED_CATEGORY
-                            : mapped.failureCategory,
+                            : writerCleanTimeout
+                                ? WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY
+                                : mapped.failureCategory,
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }

package/dist/executors/shell-executor.js

@@ -31,7 +31,7 @@ import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorresp
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
 import { collectBackendTestHumanCaseCatalog, collectBackendTestMappedPytestScripts, resolveBackendTestMappedPytestScripts, collectJacocoCoverage, hasBlockingBackendMarkdownSafetyFindings, hasBlockingBackendMarkdownModuleStemFindings, inspectBackendTestEnvironment, requiredBackendMarkdownCaseAcIds, renderBackendTestFacts, renderBackendTestHtml, renderBackendTestL5Dashboard, redactBackendTestOutput, validateBackendMarkdownCases, validateBackendMarkdownTraceability, writeRunReport, } from "../workflows/dag/backend-test-markdown-workflow.js";
 import { applyDeterministicScenarioParamRepairs, assessBackendScenarioParamConsistency, classifyBackendTestFailureWithScenarioParam, readBackendScenarioParamFacts, renderBackendTestFailureAnalysis, writeBackendScenarioParamArtifacts, writeScenarioParamRepairAudit, } from "../workflows/dag/backend-test-scenario-param.js";
-import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, buildBackendTestItemEligibility, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
+import { assessBackendPytestCollection, assessMissingBackendPytestScripts, assessPriorityOnlyBackendPytestModules, assertBackendTestExecutionReadinessFresh, buildBackendPytestAssetInventory, materializeBackendTestExecutionReadiness, materializeEffectiveBackendPytestCollection, readBackendPytestCollectionFacts, readBackendTestExecutionReadiness, writeBackendPytestCollectionArtifacts, } from "../workflows/dag/backend-test-pytest-collection.js";
 import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
@@ -678,42 +678,6 @@ async function executeBackendTestPipeline(input, meta) {
                     fixtureResolution,
                 });
             }
-            try {
-                const correspondence = await analyzeBackendTestMarkdownPytestCorrespondence({
-                    workspaceRoot: input.cwd,
-                    taskId: meta.spec.sourceBinding?.taskId ?? "unbound",
-                });
-                const correspondenceReportPath = await writeRunReport(meta.runDir, "backend-test-markdown-pytest-correspondence-initial.md", correspondence.markdown);
-                const contractsDir = path.join(meta.runDir, "contracts");
-                await mkdir(contractsDir, { recursive: true });
-                const correspondenceFactsPath = path.join(contractsDir, "backend-test-markdown-pytest-correspondence-initial.json");
-                await writeFile(correspondenceFactsPath, JSON.stringify(correspondence.facts, null, 2), "utf8");
-                outputs.push(`initialCorrespondence=${correspondenceReportPath}`, `initialCorrespondenceFacts=${correspondenceFactsPath}`);
-                if (correspondence.facts.status === "FAIL" && facts.status === "PASS") {
-                    const correspondenceRepairPaths = Array.from(new Set(correspondence.facts.entries
-                        .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                        .flatMap((entry) => [entry.expectedScript, ...entry.actualScripts])
-                        .filter((candidate) => candidate.startsWith("testcase/") && candidate.endsWith(".py")))).sort();
-                    if (correspondenceRepairPaths.length > 0) {
-                        facts.status = "REPAIRABLE";
-                        facts.repairEligible = true;
-                        facts.repairPaths = Array.from(new Set([...facts.repairPaths, ...correspondenceRepairPaths])).sort();
-                        facts.findings.push({
-                            kind: "markdown-pytest-correspondence",
-                            classification: "test-asset-defect",
-                            repairability: "repairable",
-                            detail: correspondence.facts.entries
-                                .filter((entry) => entry.status !== "EXACT_1_TO_1")
-                                .flatMap((entry) => entry.findings)
-                                .join("; ")
-                                .slice(0, 12_000) || "Markdown-to-pytest correspondence is incomplete",
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                outputs.push(`initialCorrespondence=UNAVAILABLE: ${error instanceof Error ? error.message : String(error)}`);
-            }
             const artifacts = await writeBackendPytestCollectionArtifacts({
                 runDir: meta.runDir,
                 stem: "initial",
@@ -812,56 +776,12 @@ async function executeBackendTestPipeline(input, meta) {
                 facts: effective,
             });
             const scenarioFacts = await readBackendScenarioParamFacts(path.join(meta.runDir, "contracts", "backend-test-scenario-param-consistency-facts.json"));
-            const correspondence = meta.spec.sourceBinding
-                ? await analyzeBackendTestMarkdownPytestCorrespondence({
-                    workspaceRoot: input.cwd,
-                    taskId: meta.spec.sourceBinding.taskId,
-                })
-                : undefined;
-            const eligibility = correspondence
-                ? buildBackendTestItemEligibility(effective.collectedItemIds, {
-                    correspondenceEntries: correspondence.facts.entries,
-                    scenarioEntries: scenarioFacts.entries,
-                })
-                : { eligibleItemIds: effective.collectedItemIds, excludedItems: [] };
-            const eligibilityInputHashes = Object.fromEntries((correspondence?.facts.inputFiles ?? []).map((item) => [item.path, item.sha256]));
-            const eligibilityFactsPath = path.join(meta.runDir, "contracts", "backend-test-execution-eligibility.json");
-            await mkdir(path.dirname(eligibilityFactsPath), { recursive: true });
-            await writeFile(eligibilityFactsPath, `${JSON.stringify({
-                schemaId: "backend-test-execution-eligibility-v1",
-                status: eligibility.eligibleItemIds.length === 0 ? "BLOCKED" : eligibility.excludedItems.length > 0 ? "PARTIAL" : "PASS",
-                collectedItemCount: effective.collectedItemIds.length,
-                eligibleItemCount: eligibility.eligibleItemIds.length,
-                excludedItemCount: eligibility.excludedItems.length,
-                eligibleItemIds: eligibility.eligibleItemIds,
-                excludedItems: eligibility.excludedItems,
-                inputHashes: eligibilityInputHashes,
-            }, null, 2)}\n`, "utf8");
-            const eligibilityReportPath = await writeRunReport(meta.runDir, "backend-test-execution-eligibility.md", [
-                "# Backend Test Execution Eligibility",
-                "",
-                "## Status",
-                "",
-                eligibility.eligibleItemIds.length === 0 ? "BLOCKED" : eligibility.excludedItems.length > 0 ? "PARTIAL" : "PASS",
-                "",
-                `- Collected items: ${effective.collectedItemIds.length}`,
-                `- Eligible items: ${eligibility.eligibleItemIds.length}`,
-                `- Excluded items: ${eligibility.excludedItems.length}`,
-                "",
-                "## Excluded Items",
-                "",
-                ...(eligibility.excludedItems.length > 0 ? eligibility.excludedItems.map((item) => `- \`${item.itemId}\` (${item.caseId ?? "unknown Case"}): ${item.reasons.join("; ")}`) : ["- None"]),
-                "",
-            ].join("\n"));
-            outputs.push(`executionEligibility=${eligibilityReportPath}`, `executionEligibilityFacts=${eligibilityFactsPath}`);
             const readiness = await materializeBackendTestExecutionReadiness({
                 runDir: meta.runDir,
                 workspaceRoot: input.cwd,
                 effective,
                 scenarioParamStatus: scenarioFacts.overallStatus,
                 scenarioParamRepairAttempt: scenarioFacts.repairAttempt,
-                eligibility,
-                eligibilityInputHashes,
             });
             return {
                 ok: true,
@@ -872,8 +792,6 @@ async function executeBackendTestPipeline(input, meta) {
                     collectedItemCount: effective.collectedItemCount,
                     fixtureResolutionStatus: effective.fixtureResolutionStatus,
                     executionReadinessStatus: readiness.status,
-                    eligibleItemCount: readiness.eligibleItemIds.length,
-                    excludedItemCount: readiness.excludedItems.length,
                     factsPath: "contracts/backend-test-pytest-collection-effective.json",
                     readinessPath: "contracts/backend-test-execution-readiness.json",
                     reportPath: artifacts.reportPath,
@@ -972,8 +890,7 @@ async function executeBackendTestPipeline(input, meta) {
             await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd);
             const shellQuote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
-            const eligibleItemIds = executionReadiness.eligibleItemIds;
-            const pytestTargets = eligibleItemIds.map(shellQuote).join(" ");
+            const pytestTargets = mappedScripts.map(shellQuote).join(" ");
             // Split into short bash -c commands (aligned with markdown-environment).
             // A single ultra-long compound command has been observed on Windows to
             // exit 0xC0000142 (STATUS_DLL_INIT_FAILED) in ~40ms with empty stdout/
@@ -1050,9 +967,7 @@ async function executeBackendTestPipeline(input, meta) {
                 'PYTHON_BIN="$(command -v python || command -v python3 || true)"',
                 'if [ -z "${PYTHON_BIN}" ]; then echo "python/python3 is required for backend-test execution" | tee -a "${DIAG_FILE}" >&2; exit 127; fi',
                 'echo "STEP=pytest-run"',
-                `echo "- pytestCommand: python -m pytest <${eligibleItemIds.length} eligibility-authorized-items> -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
-                `echo "- eligibleItemCount: ${eligibleItemIds.length}" >> "\${DIAG_FILE}"`,
-                `echo "- excludedItemCount: ${executionReadiness.excludedItems.length}" >> "\${DIAG_FILE}"`,
+                `echo "- pytestCommand: python -m pytest ${mappedScripts.join(" ")} -v -p no:cacheprovider --html=reports/backend-test.html --self-contained-html" >> "\${DIAG_FILE}"`,
                 `PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 "\${PYTHON_BIN}" -m pytest ${pytestTargets} -v -p no:cacheprovider --html="\${HARNESS_DAG_RUN_DIR}/reports/backend-test.html" --self-contained-html`,
                 "STATUS=$?",
                 'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
@@ -1142,9 +1057,7 @@ async function executeBackendTestPipeline(input, meta) {
             const caseValidationSummary = await readRequiredRunReport(reportsDir, "backend-md-case-validation.md");
             const caseCoverageSummary = await readAdvisoryRunReport(reportsDir, "backend-test-case-coverage-analysis.md", "Backend Test Case Coverage Analysis");
             const traceabilitySummary = await readRequiredRunReport(reportsDir, "backend-test-traceability.md");
-            const correspondenceSummaryBase = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
-            const eligibilitySummary = await readAdvisoryRunReport(reportsDir, "backend-test-execution-eligibility.md", "Backend Test Execution Eligibility");
-            const correspondenceSummary = `${correspondenceSummaryBase.trim()}\n\n${eligibilitySummary.trim()}\n`;
+            const correspondenceSummary = await readAdvisoryRunReport(reportsDir, "backend-test-markdown-pytest-correspondence.md", "Backend Test Markdown → pytest Correspondence");
             const htmlContent = renderBackendTestHtml({
                 title: meta.spec.title,
                 parsed,

package/dist/executors/shell-write-guard.js

@@ -4,6 +4,7 @@ import { constants, createReadStream } from "node:fs";
 import { access, lstat, readlink, unlink } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
+import { ResilientGitCommandError, runResilientGitCommand, } from "../shared/resilient-git.js";
 async function sha256File(filePath) {
     const hash = createHash("sha256");
     for await (const chunk of createReadStream(filePath)) {
@@ -401,14 +402,31 @@ async function resolveGitExecutableCandidates(platform, env) {
     return ["git"];
 }
 export async function readGitStatusPorcelain(cwd, options = {}) {
-    return readGitStatusPorcelainWithDependencies(cwd, options, {
-        platform: process.platform,
-        resolveExecutableCandidates: () => resolveGitExecutableCandidates(process.platform, process.env),
-        runAttempt: readGitStatusPorcelainOnce,
-        sleep: async (delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)),
-        now: Date.now,
-        env: process.env,
-    });
+    try {
+        const result = await runResilientGitCommand({
+            cwd,
+            args: ["status", "--porcelain=v1", "--untracked-files=all"],
+            readOnly: true,
+            attempts: options.attempts,
+            retryDelayMs: options.retryDelayMs,
+        });
+        if (result.code === 0)
+            return result.stdout;
+        throw new Error(result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`);
+    }
+    catch (error) {
+        if (error instanceof ResilientGitCommandError) {
+            throw new GitStatusUnavailableError({
+                cwd,
+                phase: options.phase,
+                platform: error.diagnostics.platform,
+                executableCandidates: error.diagnostics.executableCandidates,
+                attempts: error.diagnostics.attempts,
+                requiredWindowsEnvironment: requiredWindowsEnvironment(process.env),
+            });
+        }
+        throw error;
+    }
 }
 export async function readGitStatusPorcelainWithDependencies(cwd, options, dependencies) {
     const candidates = await dependencies.resolveExecutableCandidates();