@tea-agent/loop-agent 0.42.0-next.9 → 0.42.1

package/dist/executors/shell-executor.js

@@ -1,7 +1,8 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { withFrontendTestReporter, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { writeDagNodeJsonArtifact, writeDagNodeTextArtifact, writeDagRunJsonArtifact, } from "../infrastructure/harness/artifact-store.js";
 import { captureWorkspaceCheckpoint } from "../workflows/dag/workspace-checkpoint.js";
@@ -15,7 +16,7 @@ import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdi
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { extractBackendTestContractEnvelope } from "../workflows/dag/backend-test-contract-envelope.js";
 import { materializeFrontendImplementationContract } from "../workflows/dag/frontend-implementation-contract.js";
-import { assertFrontendSourceBindingFresh, buildContractFromCommittedFacts, deterministicSha256, frontendImplementationContractSchema, serializeCompactDeterministicJson, sha256Hex, writeFrontendImplementationContractArtifact, } from "../workflows/dag/frontend-implementation-contract.js";
+import { assertFrontendSourceBindingFresh, buildContractFromCommittedFacts, deterministicSha256, frontendImplementationContractSchema, serializeCompactDeterministicJson, sha256Hex, writeFrontendImplementationContractArtifact, buildFrontendVerifyCommandDirectory, } from "../workflows/dag/frontend-implementation-contract.js";
 import { checkFrontendSourceFidelityLedger } from "../workflows/dag/frontend-source-fidelity-ledger.js";
 import { materializeFrontendTestResult, validateFrontendCaseEvidence, } from "../workflows/dag/frontend-test-result-contract.js";
 import { copyFrontendTestStandardScenarios } from "../workflows/dag/frontend-test-standard-scenarios.js";
@@ -1907,11 +1908,12 @@ async function executePipelineCommands(input, meta, overrideCommands) {
     return results;
 }
 /** A+B (AC-008): derive unresolved verification entrypoints from committed plan
- * facts. A verification target is unresolved when its commandLabel does not
- * match any frozen command label from the verify shell evidence bundle.
- * Returns `{ ref, digest }` entries; a missing/unreadable plan ledger fails
- * closed to [] so the router restarts the contract instead of inventing refs. */
-async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandLabels) {
+ * facts. A verification target is unresolved when its commandId does not
+ * match any frozen command directory entry derived from the verify shell
+ * evidence bundle. Returns `{ ref, digest }` entries; a missing/unreadable
+ * plan ledger fails closed to [] so the router restarts the contract instead
+ * of inventing refs. */
+async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandIds) {
     try {
         const { restorePlanPatchFromCommittedFacts } = await import("../workflows/dag/frontend-shadow-dual-write.js");
         const records = await readTypedEventStoreFromJsonl(path.join(runDir, "frontend-plan-pi", "plan-typed-facts.jsonl"));
@@ -1920,15 +1922,13 @@ async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandL
             ?.verificationTargets;
         if (!Array.isArray(targets))
             return [];
-        const frozen = new Set(frozenCommandLabels
-            .map((label) => label.trim().toLowerCase())
-            .filter(Boolean));
+        const frozen = new Set(frozenCommandIds.filter(Boolean));
         const refs = [];
         for (const item of targets) {
             const target = item;
-            const commandLabel = typeof target.commandLabel === "string" ? target.commandLabel : "";
-            if (commandLabel &&
-                frozen.has(commandLabel.trim().toLowerCase())) {
+            // v2 plan facts carry commandId as the stable directory key.
+            const commandId = typeof target.commandId === "string" ? target.commandId : "";
+            if (commandId && frozen.has(commandId)) {
                 continue;
             }
             const file = typeof target.file === "string" ? target.file : "";
@@ -1951,6 +1951,23 @@ async function executeFrontendVerificationBundle(input, meta) {
     const bundle = shell.frontendVerificationBundle;
     const cwd = resolveShellCwd(input.cwd, shell.cwd);
     const results = [];
+    const commandResultsByKey = new Map();
+    const commandKey = (command) => `${cwd}\u0000${command.trim()}`;
+    const reuseCommandResult = (result, command) => {
+        const reusedAt = new Date().toISOString();
+        return {
+            ...result,
+            command,
+            durationMs: 0,
+            wallDurationMs: 0,
+            executionDurationMs: result.executionDurationMs ?? result.durationMs,
+            startedAt: reusedAt,
+            finishedAt: reusedAt,
+            stdoutArtifactPath: undefined,
+            stderrArtifactPath: undefined,
+            reused: true,
+        };
+    };
     let beforeStatus;
     try {
         beforeStatus = await readGitStatusPorcelain(input.cwd);
@@ -1959,22 +1976,32 @@ async function executeFrontendVerificationBundle(input, meta) {
         beforeStatus = undefined;
     }
     const lintResults = [];
+    const successfulLabels = new Map();
+    const successfulCommandTexts = new Map();
+    const executedTests = new Map();
+    const commandExecutionEvidence = new Map();
     for (const command of bundle.lintCommands ?? []) {
-        const commandNumber = results.length + 1;
-        const result = await executeShellCommand({
-            command,
-            cwd,
-            timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
-            envAllowlist: shell.envAllowlist,
-            dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
-            reportActivity: input.reportActivity,
-            outputArtifacts: {
-                stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
-                stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
-            },
-        });
-        lintResults.push(result);
+        const key = commandKey(command);
+        const cached = commandResultsByKey.get(key);
+        let result = cached ? reuseCommandResult(cached, command) : undefined;
+        if (!result) {
+            const commandNumber = results.length + 1;
+            result = await executeShellCommand({
+                command,
+                cwd,
+                timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+                envAllowlist: shell.envAllowlist,
+                dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+                reportActivity: input.reportActivity,
+                outputArtifacts: {
+                    stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                    stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+                },
+            });
+            commandResultsByKey.set(key, result);
+        }
         results.push(result);
+        lintResults.push(result);
     }
     let lintAssessment;
     if ((bundle.lintCommands?.length ?? 0) > 0 &&
@@ -2008,30 +2035,67 @@ async function executeFrontendVerificationBundle(input, meta) {
             labels: bundle.behaviorEvidence.commandLabels,
         },
     ];
-    const successfulLabels = new Map();
+    const failedGroups = new Set();
+    const groupFailures = [];
     for (const group of lintBlocked ? [] : groups) {
         for (const [index, command] of group.commands.entries()) {
-            const commandNumber = results.length + 1;
-            const result = await executeShellCommand({
-                command,
-                cwd,
-                timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
-                envAllowlist: shell.envAllowlist,
-                dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
-                reportActivity: input.reportActivity,
-                outputArtifacts: {
-                    stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
-                    stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
-                },
-            });
+            if (failedGroups.has(group.name))
+                break;
+            const key = commandKey(command);
+            const cached = commandResultsByKey.get(key);
+            let result = cached ? reuseCommandResult(cached, command) : undefined;
+            if (!result) {
+                const commandNumber = results.length + 1;
+                const reportPath = path.join(meta.runDir, input.task.id, "commands", `${commandNumber}-${randomUUID()}.vitest.json`);
+                const observedCommand = await withFrontendTestReporter({ command, cwd, reportPath });
+                if (observedCommand)
+                    await mkdir(path.dirname(reportPath), { recursive: true });
+                result = await executeShellCommand({
+                    command: observedCommand ?? command,
+                    cwd,
+                    timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
+                    envAllowlist: shell.envAllowlist,
+                    dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
+                    reportActivity: input.reportActivity,
+                    outputArtifacts: {
+                        stdoutPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stdout.txt`),
+                        stderrPath: path.join(meta.runDir, input.task.id, "commands", `${commandNumber}.stderr.txt`),
+                    },
+                });
+                let reportError;
+                if (observedCommand && result.ok) {
+                    try {
+                        // Vitest reports physical paths (e.g. /private/var on macOS).
+                        // Match those in workspace coordinates even when shell.cwd is
+                        // a subdirectory or the caller used a directory alias.
+                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(await readFile(reportPath, "utf8")), await realpath(cwd), await realpath(input.cwd)));
+                    }
+                    catch (error) {
+                        reportError = `frontend test execution report unavailable: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                }
+                if (reportError) {
+                    result = { ...result, ok: false, failureCategory: "invalid-output", stderr: reportError };
+                }
+                commandResultsByKey.set(key, result);
+            }
             results.push(result);
             if (result.ok && group.labels[index]) {
+                const observations = commandExecutionEvidence.get(key);
+                if (observations !== undefined)
+                    executedTests.set(group.labels[index], observations);
                 const labels = successfulLabels.get(group.name) ?? [];
                 labels.push(group.labels[index]);
                 successfulLabels.set(group.name, labels);
+                const texts = successfulCommandTexts.get(group.name) ?? [];
+                texts.push(command);
+                successfulCommandTexts.set(group.name, texts);
             }
-            if (!result.ok)
+            if (!result.ok) {
+                groupFailures.push(result);
+                failedGroups.add(group.name);
                 break;
+            }
         }
     }
     if (beforeStatus !== undefined) {
@@ -2061,12 +2125,15 @@ async function executeFrontendVerificationBundle(input, meta) {
         exitCode: result.exitCode,
         failureCategory: result.failureCategory,
         command: result.command,
+        reused: result.reused === true,
     }));
+    // Lint baseline-debt is tolerated, so a lint-only failure must not become the
+    // verification failure. A shared lint/static or lint/behavior command is
+    // different: once reused by a non-lint lane, its failure belongs to that lane
+    // and must remain the primary failure evidence.
     const firstFailure = lintBlocked
         ? lintResults.find((result) => !result.ok)
-        : results
-            .filter((result) => !lintResults.includes(result))
-            .find((result) => !result.ok);
+        : groupFailures[0];
     const lintSyntheticFailure = lintBlocked && !firstFailure
         ? {
             failureCategory: "invalid-output",
@@ -2083,7 +2150,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 mock: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("mock") ?? [],
-                    commandTexts: bundle.mockCommands.slice(0, successfulLabels.get("mock")?.length ?? 0),
+                    commandTexts: successfulCommandTexts.get("mock") ?? [],
                 },
                 static: {
                     nodeId: input.task.id,
@@ -2092,6 +2159,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                 behavior: {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("behavior") ?? [],
+                    executedTests,
                 },
             },
         });
@@ -2124,7 +2192,9 @@ async function executeFrontendVerificationBundle(input, meta) {
             nodeId: failedNodeId,
             rawFailureCategory: failureCategory,
         });
-        const failureOwner = classifiedOwner === "unknown" ? "implement-pi" : classifiedOwner;
+        const failureOwner = classifiedOwner === "unknown" &&
+            ["typecheck", "build", "lint", "component-test", "unit-test", "trace"].includes(failureClass)
+            ? "implementation" : classifiedOwner;
         const restartPhase = classifyRestartPhase(failureOwner);
         // A+B (AC-008): verification-config routing. Produce structured
         // unresolved entrypoint refs from committed plan facts and the frozen
@@ -2135,12 +2205,18 @@ async function executeFrontendVerificationBundle(input, meta) {
         // never re-classifies the same signal twice.
         let verificationConfigRoute;
         if (failureOwner === "verification-config") {
-            const frozenCommandLabels = [
-                ...(bundle.staticEvidence.commandLabels ?? []),
-                ...(bundle.behaviorEvidence.commandLabels ?? []),
-                ...(bundle.mockEvidence?.commandLabels ?? []),
-            ];
-            const unresolvedEntrypointRefs = await deriveUnresolvedVerificationEntrypointRefs(meta.runDir, frozenCommandLabels);
+            const verifyDirectory = buildFrontendVerifyCommandDirectory({
+                staticLabels: bundle.staticEvidence.commandLabels ?? [],
+                behaviorLabels: bundle.behaviorEvidence.commandLabels ?? [],
+                mockLabels: bundle.mockEvidence?.commandLabels ?? [],
+                lintLabels: bundle.lintEvidence?.commandLabels ?? [],
+                staticCommandTexts: bundle.staticEvidence.commandTexts ?? [],
+                behaviorCommandTexts: bundle.behaviorEvidence.commandTexts ?? [],
+                mockCommandTexts: bundle.mockEvidence?.commandTexts ?? [],
+                lintCommandTexts: bundle.lintEvidence?.commandTexts ?? [],
+            });
+            const frozenCommandLabels = verifyDirectory.map((entry) => entry.label);
+            const unresolvedEntrypointRefs = await deriveUnresolvedVerificationEntrypointRefs(meta.runDir, verifyDirectory.map((entry) => entry.commandId));
             verificationConfigRoute = routeVerificationConfig({
                 unresolvedEntrypointRefs: unresolvedEntrypointRefs.map((ref) => ref.ref),
             });
@@ -2531,7 +2607,7 @@ async function executeFrontendDesignPolicy(input, meta) {
                 };
             }
             const uncoveredVTs = contract.verificationTargets
-                .filter((vt) => vt.type !== "static")
+                .filter((vt) => vt.mode !== "static")
                 .filter((vt) => ![...writeSet].some((pattern) => pathMatchesPattern(vt.file, pattern) || vt.file === pattern));
             if (uncoveredVTs.length > 0) {
                 return {
@@ -2598,6 +2674,10 @@ async function executeFrontendDesignPolicy(input, meta) {
                 [],
             allowedDependencies: config.allowedDependencies,
             writeSetPatterns: config.implementationWriteSet ?? [],
+            // Fresh-existence evidence at gate time (Scout pathEvidence.fresh
+            // semantics): a reuse-existing evidencePath must name a file that
+            // exists NOW; greenfield paths are decision=new only.
+            hasFreshPathEvidence: (candidate) => existsSync(path.resolve(input.cwd, candidate)),
         });
         // 8. Write canonical contract + policy result.
         const contractArtifact = await writeFrontendImplementationContractArtifact({

package/dist/shared/dag-failure-category.js

@@ -63,6 +63,12 @@ const RAW_TO_NORMALIZED = {
     // compaction / fresh context before retrying — an executor-side
     // environment condition, not a plan-quality defect.
     "context-overflow": "executor",
+    // stopReason=length output-capacity truncation: same executor-side
+    // capacity class as context-overflow. Legacy thinking-exhausted labels
+    // (pre-output-limit artifacts) map to the same class.
+    "output-limit": "executor",
+    "writer-thinking-exhausted": "executor",
+    "planner-thinking-exhausted": "executor",
     // Deterministic capability/policy refusal: missing verified launcher JS
     // entry, capability allowlist rejection, or missing bounded write tool
     // profile. These are environment/config defects the operator repairs

package/dist/shared/frontend-execution-policy.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+/** Execution hints and estimation reserves, never model-name capacity defaults. */
+export const frontendExecutionPolicySchema = z.object({
+    scopeTargetBytes: z.number().int().positive().default(24_000),
+    maxScopeUnits: z.number().int().positive().default(4),
+    maxCoverageConcurrency: z.number().int().min(1).max(4).default(4),
+    outputReserveTokens: z.number().int().positive().default(4096),
+    readGrowthReserveTokens: z.number().int().nonnegative().default(2048),
+    safetyRatio: z.number().min(0).max(0.5).default(0.15),
+}).strict();
+export function frontendModelCapabilities(model) {
+    const value = model && typeof model === "object" ? model : {};
+    const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null;
+    return { model: typeof value.id === "string" ? `${value.provider ?? "unknown"}/${value.id}` : null, source: Object.keys(value).length ? "model-registry" : "unknown", inputLimit: positive(value.inputLimit), totalContextLimit: positive(value.contextWindow), outputLimit: positive(value.maxTokens), reasoningControllability: "unknown" };
+}
+export function measureFrontendRequestEnvelope(context, model, policy) {
+    const bytes = Buffer.byteLength(JSON.stringify(context));
+    const estimatedTokens = Math.ceil(bytes / 3);
+    const capabilities = frontendModelCapabilities(model);
+    const outputReserve = Math.min(policy.outputReserveTokens, capabilities.outputLimit ?? policy.outputReserveTokens);
+    const availableInputTokens = Math.min(capabilities.inputLimit ?? Infinity, capabilities.totalContextLimit === null ? Infinity : Math.floor(capabilities.totalContextLimit * (1 - policy.safetyRatio)) - outputReserve - policy.readGrowthReserveTokens);
+    return { bytes, estimatedTokens, estimatorVersion: "utf8-bytes-div3-v1-estimate", capabilities, availableInputTokens: Number.isFinite(availableInputTokens) ? availableInputTokens : null, exceedsEstimate: estimatedTokens > availableInputTokens };
+}

package/dist/task/config-types.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { frontendExecutionPolicySchema } from "../shared/frontend-execution-policy.js";
 import { DEFAULT_FRONTEND_SPEC_ROOTS, isFrontendSpecFilePath, isValidFrontendSpecRoot, } from "../shared/openspec-spec.js";
 export const taskFlowSchema = z.enum([
     "auto",
@@ -300,6 +301,8 @@ const taskConfigObjectSchema = z.object({
      * default; raise to 2-3 for more tolerance of transient verify failures). */
     frontendRecovery: z
         .object({
+        /** Frozen request quota across the original run and recovery lineage; not a model capacity. */
+        maxProviderRequests: z.number().int().positive().optional(),
         maxContinuations: z
             .number()
             .int()
@@ -310,6 +313,7 @@ const taskConfigObjectSchema = z.object({
     })
         .strict()
         .optional(),
+    frontendExecutionPolicy: frontendExecutionPolicySchema.optional(),
     /** Outer loop auto mode never writes by default; DAG execute requires this policy plus path/writeSet gates. */
     loopAutoExecutionPolicy: loopAutoExecutionPolicySchema
         .optional()

package/dist/task/contract/apply.js

@@ -147,7 +147,7 @@ export async function applyTaskContract(input) {
             ref,
             changedFiles: [],
             idempotentReplay: true,
-            txId: existing.txId,
+            ...(existing.txId ? { txId: existing.txId } : { noOp: true }),
         };
     }
     const lock = await acquireTaskContractLock({
@@ -175,7 +175,9 @@ export async function applyTaskContract(input) {
                 ref,
                 changedFiles: [],
                 idempotentReplay: true,
-                txId: existingUnderLock.txId,
+                ...(existingUnderLock.txId
+                    ? { txId: existingUnderLock.txId }
+                    : { noOp: true }),
             };
         }
         const state = await observeTaskContractState(input.repoRoot, input.taskId);
@@ -251,6 +253,38 @@ export async function applyTaskContract(input) {
             sourceHashes,
             taskConfigSha256,
         });
+        // Content-level no-op: when the freshly projected draft hashes
+        // identically to both the recorded contract and the on-disk observation,
+        // the journaled commit would only churn revision/updatedAt metadata and
+        // force downstream consumers (writeSet gate digest binds
+        // contractRevision+contractCanonicalHash) to re-issue approvals for
+        // zero content change. Return the current ref untouched instead. A
+        // drifted disk (observed !== ref) never reaches this short-circuit: the
+        // apply is then a repair projection and must run.
+        if (state.ref &&
+            canonicalHash === state.ref.canonicalHash &&
+            state.observedCanonicalHash === state.ref.canonicalHash) {
+            await assertLockHeld(lock);
+            await appendRequestLedgerEntry({
+                repoRoot: input.repoRoot,
+                taskId: input.taskId,
+                entry: {
+                    schemaVersion: 1,
+                    requestId: input.requestId,
+                    requestPayloadSha256: input.requestPayloadSha256,
+                    revision: state.ref.revision,
+                    canonicalHash: state.ref.canonicalHash,
+                    recordedAt: new Date().toISOString(),
+                    resultSummary: { ok: true, operation: "apply" },
+                },
+            });
+            return {
+                ref: state.ref,
+                changedFiles: [],
+                idempotentReplay: false,
+                noOp: true,
+            };
+        }
         const nextRevision = currentRevision + 1;
         const nextRef = {
             schemaVersion: TASK_CONTRACT_REF_SCHEMA_VERSION,

package/dist/task/source-prepare/ledger-reconciliation.js

@@ -3,7 +3,7 @@ import { normalizeFragmentText } from "./fragment-inventory.js";
 // 顺序 reconciliation（AC-006 / AC-FIDELITY-REPAIR-006）
 // 结构化确定性片段走代码映射（显式 AC ID / 文本精确匹配），绝不调用 executor；
 // 仅叙述性/歧义 chunk 调用可注入 executor，按标题顺序串行、逐块有界处理
-// （budgetChars 按 chunk 截断，绝不整文件裁 24K）。executor 超时/异常/无效
+// （budgetChars 仅为调用提示，不截断判定所需的原文）。executor 超时/异常/无效
 // 返回/identity 越界一律 fail closed（SOURCE_FIDELITY_RECONCILIATION_FAILED），
 // 不回退 heuristics。
 // ---------------------------------------------------------------------------
@@ -65,7 +65,7 @@ export async function reconcileLedgerFragments(input) {
                 path: fragment.path,
                 headingPath: fragment.headingPath,
                 lineRange: fragment.lineRange,
-                text: fragment.text.slice(0, budgetChars),
+                text: fragment.text,
             },
             canonicalRequirements,
             budgetChars,

package/dist/task/source-prepare/ledger-review.js

@@ -7,8 +7,7 @@ import { mergeInventoryItems } from "./ledger-reconciliation.js";
 // context-only 仅 reviewer pass 放行，高风险 context-only 始终阻断；duplicate
 // 保留全部来源但审核失败（含修订后仍拒绝）以稳定码 fail closed。
 // ---------------------------------------------------------------------------
-/** review 片段原文按 budget 有界截断（AC-004 / AC-HARD-004），禁止整文档入
- * prompt；沿用 MAX_SOURCE_EXCERPT_CHARS 边界语义。 */
+/** Historical caller hint; it must never clip the fragment used for a decision. */
 export const LEDGER_REVIEW_DEFAULT_BUDGET_CHARS = 2000;
 export const LEDGER_REVIEW_MAX_REVISIONS = 1;
 /** review 失败（reviewer 异常/第二次不通过）统一稳定错误码。 */
@@ -180,12 +179,9 @@ export const defaultLedgerReviewer = async (request) => {
             : "conflict 无有效 human resolution 覆盖，保持阻断",
     };
 };
-/** 供 prepare.ts 接入：从 ledger fragments 中挑选需审核的条目，复用
- * mergeInventoryItems 的 id→原文映射，按 budgetChars 有界截断后传入 reviewer
- * （AC-004 / AC-HARD-004）：请求携带非空有界原文与精确 fragment id，完整文档
- * 绝不进入下游 prompt；原文不可得时退化为 reason / id 保证非空。 */
+/** Resolve complete source fragments for independent review; missing original text
+ * cannot be replaced with its reason or identity. */
 export function ledgerReviewItemsFromRecords(records, input) {
-    const budgetChars = input?.budgetChars ?? LEDGER_REVIEW_DEFAULT_BUDGET_CHARS;
     const merged = input?.fragments
         ? mergeInventoryItems({ records, fragments: input.fragments })
         : records.map((record) => ({
@@ -200,8 +196,9 @@ export function ledgerReviewItemsFromRecords(records, input) {
             canonicalRequirementIds: record.canonicalRequirementIds,
         }));
     return merged.map((item) => {
-        const bounded = item.text.slice(0, budgetChars);
-        const text = bounded.trim() || item.reason?.trim() || item.id;
+        const text = item.text;
+        if (!text.trim() && ["context-only", "duplicate", "conflict"].includes(item.disposition))
+            throw new LedgerReviewError(`SOURCE_FIDELITY_ORIGINAL_MISSING: ${item.id}; independent review needs the full source text`);
         return {
             id: item.id,
             text,

package/dist/task/source-prepare/parse-intent.js

@@ -13,6 +13,13 @@ const HEADING_ALIASES = {
         "需求范围",
         "已确认范围",
         "已确认需求",
+        // Common zh-CN frontend-PRD variants seen in real PRDs; without these a
+        // raw-PRD fallback parse (semantic intake unavailable) yields an empty
+        // scope and flips the import to incomplete (EMPTY scope deadlock).
+        "目标表面",
+        "交付范围",
+        "实现范围",
+        "交付内容",
     ]),
     nonGoals: new Set(["非目标", "out of scope", "non-goals", "non goals"]),
     acceptance: new Set([

package/dist/task/source-prepare/semantic-intake.js

@@ -1,3 +1,5 @@
+import { randomUUID } from "node:crypto";
+import { observeFrontendSession } from "../../workflows/dag/frontend-session-budget.js";
 /**
  * P2 Semantic Intake: one-shot, read-only Pi structuring of imported PRDs
  * into TaskContractDraftV1. Does not write source/需求.md directly — caller
@@ -411,24 +413,6 @@ export async function buildRepoHint(repoRoot) {
     }
     return lines.join("\n");
 }
-/**
- * 在 maxChars 附近回退到最近的标题边界再截断（AC-005 / AC-FIDELITY-REPAIR-005
- * 回归点移除）：避免把可执行项/列表项从中间切开吞掉。仅用于模型提示词预算；
- * ledger fragment inventory 始终消费完整原文，不经过此裁剪。
- */
-function clipAtSectionBoundary(content, maxChars) {
-    if (content.length <= maxChars)
-        return content;
-    const prefix = content.slice(0, maxChars);
-    const headingRe = /^(?:#{1,6})\s+.+$/gm;
-    let boundary = prefix.length;
-    let match;
-    while ((match = headingRe.exec(prefix)) !== null) {
-        if (match.index >= maxChars * 0.4)
-            boundary = match.index;
-    }
-    return `${content.slice(0, boundary)}\n\n[truncated at section boundary]`;
-}
 async function buildPrompt(input) {
     const bodies = input.documents
         .map((doc, index) => {
@@ -436,14 +420,14 @@ async function buildPrompt(input) {
         const metaLine = meta.recognized
             ? `artifact_type=${meta.artifactType} status=${meta.requirementStatus ?? meta.analysisStatus ?? "n/a"}`
             : "artifact_type=unknown";
-        const clipped = clipAtSectionBoundary(doc.content, 24_000);
+        const complete = doc.content;
         return [
             `### Document ${index + 1}`,
             `role: ${doc.role}`,
             `path: ${doc.materializedPath}`,
             metaLine,
             "```markdown",
-            clipped,
+            complete,
             "```",
         ].join("\n");
     })
@@ -609,9 +593,7 @@ export async function runSemanticIntake(input) {
                 message: "semantic intake has no MED/HIGH/LOW or Pi-supported models to try",
             };
         }
-        const attached = usableDocs
-            .map((d) => d.absolutePath)
-            .filter((p) => Boolean(p));
+        // Complete text is already inline; attaching the same documents duplicates it.
         const prompt = await buildPrompt({
             taskId: input.taskId,
             title: input.title,
@@ -623,8 +605,12 @@ export async function runSemanticIntake(input) {
         let chosenText;
         for (const modelRef of queue) {
             try {
-                const result = await execute({
-                    attachedFiles: attached,
+                const result = await observeFrontendSession({
+                    phase: "semantic-intake", userMessage: "Structure the imported requirement documents into the required JSON only.", prompt, model: modelRef, taskId: input.taskId,
+                    artifactPath: path.join(getTaskPaths(input.repoRoot, input.taskId).taskDir, "artifacts", "session-budget", `${randomUUID()}.json`),
+                }, observer => execute({
+                    onAttemptObservation: observer,
+                    attachedFiles: [],
                     modelConfig: resolveDagPiModelConfig(modelRef),
                     prompt,
                     repoRoot: input.repoRoot,
@@ -643,7 +629,7 @@ export async function runSemanticIntake(input) {
                             return [error instanceof Error ? error.message : String(error)];
                         }
                     },
-                });
+                }));
                 attempted.push({
                     model: result.modelDisplay || modelRef,
                     ok: result.ok,
@@ -656,6 +642,10 @@ export async function runSemanticIntake(input) {
                 }
                 lastFailure =
                     `${result.failureCategory}: ${result.stderr || result.assistantText}`.slice(0, 2000);
+                if (result.stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory)) {
+                    lastFailure = `SEMANTIC_INTAKE_CAPACITY_EXHAUSTED: refine the complete source into independently reviewable documents; ${lastFailure}`;
+                    break;
+                }
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);