@tea-agent/loop-agent 0.43.0-next.1 → 0.43.0-next.10

package/dist/executors/pi-executor.js

@@ -1,3 +1,4 @@
+import { collectFrontendUsage, createFrontendReadObservation, observeFrontendAttempt } from "../workflows/dag/frontend-session-budget.js";
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
@@ -453,6 +454,9 @@ export function extractPiEventStopReason(event) {
     return undefined;
 }
 export class PiJsonlStreamCollector {
+    frontendReads = createFrontendReadObservation();
+    frontendUsageEvents = [];
+    frontendObservation() { return { readObservation: this.frontendReads.snapshot(), usageObservation: collectFrontendUsage(this.frontendUsageEvents) }; }
     lineBuffer = "";
     discardUntilNewline = false;
     assistantText = "";
@@ -518,6 +522,13 @@ export class PiJsonlStreamCollector {
         }
     }
     consumeEvent(event) {
+        try {
+            this.frontendReads.observe(event);
+            const message = isRecord(event.message) ? event.message : undefined;
+            if (event.usage || message?.usage || event.tokenUsage)
+                this.frontendUsageEvents.push({ responseId: event.responseId, messageId: event.messageId, usage: event.usage, tokenUsage: event.tokenUsage, message: message ? { role: message.role, id: message.id, responseId: message.responseId, usage: message.usage } : undefined });
+        }
+        catch { /* observation only */ }
         const stopReason = extractPiEventStopReason(event);
         if (stopReason === "length" || !this.stopReason) {
             this.stopReason = stopReason ?? this.stopReason;
@@ -696,6 +707,8 @@ function shouldFallbackSdkToCli(sdkResult, validationIssues, options) {
         return true;
     if (!sdkResult.ok &&
         (sdkResult.failureCategory === "auth" ||
+            sdkResult.failureCategory === "output-limit" ||
+            sdkResult.failureCategory === "cancelled" ||
             sdkResult.failureCategory === "timeout" ||
             sdkResult.failureCategory === "termination-unconfirmed")) {
         return false;
@@ -730,6 +743,8 @@ function writerPolicyFailureResult(options, message, extras) {
 export async function executePiStep(options) {
     const backendMode = resolvePiBackend();
     const writerRequiresSdk = options.writerToolPolicy?.requireSdk === true;
+    if (options.reserveProviderRequest && backendMode === "cli-only")
+        return { ...writerPolicyFailureResult(options, "FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: actual request admission requires SDK", { sdkAttempted: false }), failureCategory: "budget_breach" };
     if (backendMode === "cli-only") {
         if (writerRequiresSdk) {
             return writerPolicyFailureResult(options, "pi writer tool policy requires SDK backend; CODE_AGENT_PI_BACKEND=cli-only is fail-closed for writers", { sdkAttempted: false, backend: "cli" });
@@ -745,6 +760,8 @@ export async function executePiStep(options) {
     const { checkPiSdkAvailability, executeSingleSdkAttempt, getActivePiSdkReuseScope, } = await import("./pi-sdk-executor.js");
     const sdkCheck = await checkPiSdkAvailability(options.repoRoot);
     if (!sdkCheck.ok) {
+        if (options.reserveProviderRequest)
+            return { ...writerPolicyFailureResult(options, `FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: ${sdkCheck.detail}`, { sdkAttempted: false }), failureCategory: "budget_breach" };
         if (writerRequiresSdk) {
             return writerPolicyFailureResult(options, `pi writer tool policy requires SDK; ${sdkCheck.detail}`, { sdkAttempted: false });
         }
@@ -773,7 +790,7 @@ export async function executePiStep(options) {
             reuseRuntimeActive,
         });
     }
-    if (!shouldFallbackSdkToCli(sdkResult, validationIssues, options)) {
+    if (options.reserveProviderRequest || !shouldFallbackSdkToCli(sdkResult, validationIssues, options)) {
         const failureCategory = validationIssues.length > 0
             ? "invalid-output"
             : sdkResult.failureCategory;
@@ -798,6 +815,9 @@ export async function executePiStep(options) {
     return { ...cliResult, reuseRuntimeActive };
 }
 async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
+    return observeFrontendAttempt({ backend: "cli", model: [modelConfig.provider, modelConfig.model].filter(Boolean).join("/"), observer: options.onAttemptObservation }, () => executeSingleCliAttemptInternal(options, modelConfig, promptFilePath));
+}
+async function executeSingleCliAttemptInternal(options, modelConfig, promptFilePath) {
     const modelDisplay = modelConfig.provider && modelConfig.model
         ? `${modelConfig.provider}/${modelConfig.model}`
         : (modelConfig.model ?? "default");
@@ -900,6 +920,7 @@ async function executeSingleCliAttempt(options, modelConfig, promptFilePath) {
                 });
             resolve({
                 assistantText: collected.assistantText,
+                ...stdoutCollector.frontendObservation(),
                 command: ["pi", ...recordedPiArgs],
                 durationMs,
                 exitCode: code,

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

@@ -1,3 +1,5 @@
+import { collectFrontendUsage, createFrontendReadObservation, observeFrontendAttempt } from "../workflows/dag/frontend-session-budget.js";
+import { frontendModelCapabilities, measureFrontendRequestEnvelope } from "../shared/frontend-execution-policy.js";
 import { appendFile, mkdir } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -7,6 +9,42 @@ import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DE
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
 import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
+/** Maximum number of same-session continuations after provider output truncation. */
+export const PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX = 3;
+export const PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT = "继续。上一轮因输出长度上限（stopReason=length）截断；当前会话、工具与已完成工作仍保留。只完成尚未完成的部分，不重做已成功的写入或事实提交。";
+/** Wrap the actual stream seam: tool turns, retries and compaction all await it. */
+export async function installPiProviderRequestBudget(session, reserve, onFailure, capacity) {
+    const agent = session.agent;
+    const original = agent?.streamFunction;
+    if (!agent || typeof original !== "function")
+        throw Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
+    const { createAssistantMessageEventStream } = await import("@earendil-works/pi-ai");
+    agent.streamFunction = async (...args) => {
+        try {
+            if (args[2]?.signal?.aborted)
+                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+            if (capacity) {
+                const measurement = measureFrontendRequestEnvelope(args[1], args[0], capacity.policy);
+                capacity.observe(measurement);
+                if (measurement.exceedsEstimate)
+                    throw Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
+            }
+            await reserve();
+            if (args[2]?.signal?.aborted)
+                throw Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            onFailure(message);
+            const stream = createAssistantMessageEventStream();
+            const model = args[0] ?? {};
+            stream.push({ type: "error", reason: "error", error: { role: "assistant", content: [], api: model.api ?? "unknown", provider: model.provider ?? "unknown", model: model.id ?? "unknown", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "error", errorMessage: message, timestamp: Date.now() } });
+            stream.end();
+            return stream;
+        }
+        return original.apply(agent, args);
+    };
+}
 /** Same-session recovery after a transport stall. Exactly one continue per SDK attempt. */
 export const PI_SDK_STALL_CONTINUE_MAX = 1;
 /**
@@ -544,6 +582,9 @@ function aggregateSdkTokenUsage(samples) {
  * same session; that is in-attempt recovery, not cross-step session reuse.
  */
 export async function executeSingleSdkAttempt(options) {
+    return observeFrontendAttempt({ backend: "sdk", model: [options.modelConfig.provider, options.modelConfig.model].filter(Boolean).join("/"), observer: options.onAttemptObservation }, () => executeSingleSdkAttemptInternal(options));
+}
+async function executeSingleSdkAttemptInternal(options) {
     const modelConfig = options.modelConfig;
     const modelDisplay = modelConfig.provider && modelConfig.model
         ? `${modelConfig.provider}/${modelConfig.model}`
@@ -568,9 +609,16 @@ export async function executeSingleSdkAttempt(options) {
     let timedOut = false;
     let terminationConfirmed = true;
     let stderr = "";
+    let providerBudgetFailure;
+    let capabilitiesObservation = frontendModelCapabilities(undefined);
+    const requestEnvelopeObservation = { peakBytes: 0, peakEstimatedTokens: 0, estimatorVersion: "utf8-bytes-div3-v1-estimate" };
     const stdoutPreview = new BoundedTextPreview("stdout");
     const stdoutCollector = createPiJsonlStreamCollector();
+    let turnCollector = createPiJsonlStreamCollector();
+    let committedTerminalObserved = false;
     const usageSamples = [];
+    const observationEvents = [];
+    const readObservation = createFrontendReadObservation();
     let observedTurns = 0;
     let contextBudgetExhausted = false;
     let contextBudgetDetail = "";
@@ -579,6 +627,9 @@ export async function executeSingleSdkAttempt(options) {
     // length-stopped thinking-only attempt with no persisted write tool calls is
     // still distinguishable from generic empty output.
     let stopReason;
+    let providerErrorMessage;
+    let promptIndex = 0;
+    let outputContinuesSent = 0;
     let thinkingObserved = false;
     let writeToolCallCount = 0;
     const observeWriterThinkingExhaustionEvidence = (event) => {
@@ -660,6 +711,13 @@ export async function executeSingleSdkAttempt(options) {
                 ? { additionalExtensionPaths: options.piExtensionPaths }
                 : {}),
         });
+        capabilitiesObservation = frontendModelCapabilities(session.agent?.state?.model);
+        if (options.reserveProviderRequest || options.frontendExecutionPolicy)
+            await installPiProviderRequestBudget(session, options.reserveProviderRequest ?? (async () => { }), message => { providerBudgetFailure = message; appendStderr(message); }, options.frontendExecutionPolicy ? { policy: options.frontendExecutionPolicy, observe: measurement => {
+                    capabilitiesObservation = measurement.capabilities;
+                    requestEnvelopeObservation.peakBytes = Math.max(requestEnvelopeObservation.peakBytes, measurement.bytes);
+                    requestEnvelopeObservation.peakEstimatedTokens = Math.max(requestEnvelopeObservation.peakEstimatedTokens, measurement.estimatedTokens);
+                } } : undefined);
         let resolveStall;
         let resolveSettlement;
         let resolveContextBudget;
@@ -718,6 +776,8 @@ export async function executeSingleSdkAttempt(options) {
             resolveContextBudget?.("context-budget");
         };
         unsubscribe = session.subscribe((event) => {
+            if (event.type === "tool_execution_end" && event.isError !== true && typeof event.toolName === "string" && options.outputLimitRecovery?.terminalToolNames.includes(event.toolName) && isRecord(event.result) && isRecord(event.result.details) && event.result.details.ok === true)
+                committedTerminalObserved = true;
             if (event.type === "agent_settled" && !settled) {
                 settled = true;
                 resolveSettlement?.("settled");
@@ -737,9 +797,18 @@ export async function executeSingleSdkAttempt(options) {
                     // best-effort: activity must never change Pi result
                 }
             }
+            const observationMessage = isRecord(event.message) ? event.message : undefined;
+            if (typeof observationMessage?.errorMessage === "string")
+                providerErrorMessage = observationMessage.errorMessage;
+            try {
+                readObservation.observe(event);
+            }
+            catch { /* observation must not change execution */ }
+            if (!(typeof observationMessage?.errorMessage === "string" && observationMessage.errorMessage.startsWith("FRONTEND_PROVIDER_")) && (event.usage || observationMessage?.usage || event.tokenUsage))
+                observationEvents.push({ responseId: event.responseId, messageId: event.messageId, usage: event.usage, tokenUsage: event.tokenUsage, message: observationMessage ? { role: observationMessage.role, id: observationMessage.id, responseId: observationMessage.responseId, usage: observationMessage.usage } : undefined });
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
-                usageSamples.push(usageSample);
+                usageSamples.push({ ...usageSample, responseKey: usageSample.responseKey ?? `turn-${promptIndex}` });
             if (event.type === "turn_end")
                 observedTurns += 1;
             checkContextBudget();
@@ -753,6 +822,7 @@ export async function executeSingleSdkAttempt(options) {
             const line = serializeSessionEvent(event);
             stdoutPreview.append(`${line}\n`);
             stdoutCollector.append(`${line}\n`);
+            turnCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
         const timeoutPromise = timeoutMs > 0
@@ -763,6 +833,9 @@ export async function executeSingleSdkAttempt(options) {
             })
             : null;
         const runTurn = async (userMessage) => {
+            promptIndex += 1;
+            stopReason = undefined;
+            turnCollector = createPiJsonlStreamCollector();
             const settlementPromise = resetSettlement();
             const stallPromise = resetStallPromise();
             const contextBudgetPromise = options.contextBudget
@@ -808,48 +881,61 @@ export async function executeSingleSdkAttempt(options) {
             : options.userMessage;
         let continuesSent = 0;
         let raced = await runTurn(promptMessage);
-        if (raced === "context-budget") {
-            appendStderr(contextBudgetDetail);
-            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
-            await disposeSession();
-        }
-        else if (raced === "stall") {
-            abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
-            const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
-            const canContinue = abortConfirmed &&
-                writeToolCallCount === 0 &&
-                withinAbsoluteTimeout &&
-                continuesSent < PI_SDK_STALL_CONTINUE_MAX;
-            if (canContinue) {
-                // The aborted turn's stopReason must not leak onto a recovered continue.
-                stopReason = undefined;
-                continuesSent += 1;
-                persistRuntimeNote({
-                    type: "loop-agent-stall-continue",
-                    prompt: PI_SDK_STALL_CONTINUE_PROMPT,
-                    maxContinues: PI_SDK_STALL_CONTINUE_MAX,
-                });
-                raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
-                if (raced !== "done" && raced !== "settled") {
-                    await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
-                        ? "pi SDK stall continue did not recover; treating as timeout"
-                        : "pi SDK stall continue hit the absolute timeout", true);
+        while (true) {
+            if (raced === "context-budget") {
+                appendStderr(contextBudgetDetail);
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+                await disposeSession();
+            }
+            else if (raced === "stall") {
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+                const withinAbsoluteTimeout = timeoutMs <= 0 || Date.now() - startedAt < timeoutMs;
+                const canContinue = abortConfirmed &&
+                    writeToolCallCount === 0 &&
+                    withinAbsoluteTimeout &&
+                    continuesSent < PI_SDK_STALL_CONTINUE_MAX;
+                if (canContinue) {
+                    // The aborted turn's stopReason must not leak onto a recovered continue.
+                    stopReason = undefined;
+                    continuesSent += 1;
+                    persistRuntimeNote({
+                        type: "loop-agent-stall-continue",
+                        prompt: PI_SDK_STALL_CONTINUE_PROMPT,
+                        maxContinues: PI_SDK_STALL_CONTINUE_MAX,
+                    });
+                    raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
+                    if (raced !== "done" && raced !== "settled") {
+                        await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
+                            ? "pi SDK stall continue did not recover; treating as timeout"
+                            : "pi SDK stall continue hit the absolute timeout", true);
+                    }
+                }
+                else {
+                    await failClosedAfterWait("stall", !abortConfirmed
+                        ? undefined
+                        : writeToolCallCount > 0
+                            ? "pi SDK stall continue skipped because write tools already ran"
+                            : "pi SDK stall continue skipped because absolute timeout elapsed", false);
                 }
             }
-            else {
-                await failClosedAfterWait("stall", !abortConfirmed
-                    ? undefined
-                    : writeToolCallCount > 0
-                        ? "pi SDK stall continue skipped because write tools already ran"
-                        : "pi SDK stall continue skipped because absolute timeout elapsed", false);
+            else if (raced === "absolute-timeout") {
+                await failClosedAfterWait("absolute-timeout");
             }
-        }
-        else if (raced === "absolute-timeout") {
-            await failClosedAfterWait("absolute-timeout");
+            if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !stderr && outputContinuesSent < PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX && !timedOut) {
+                outputContinuesSent += 1;
+                const note = serializeSessionEvent({ type: "loop-agent-output-limit-continue", continue: outputContinuesSent, maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX, prompt: PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT });
+                stdoutPreview.append(`${note}\n`);
+                stdoutCollector.append(`${note}\n`);
+                raced = await runTurn(PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT);
+                continue;
+            }
+            break;
         }
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        if (options.reserveProviderRequest && message.startsWith("FRONTEND_PROVIDER_"))
+            providerBudgetFailure = message;
         appendStderr(message);
     }
     finally {
@@ -872,20 +958,29 @@ export async function executeSingleSdkAttempt(options) {
             }
         }
     }
+    if (providerErrorMessage && stopReason === "error" && !stderr)
+        appendStderr(providerErrorMessage);
+    if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && outputContinuesSent >= PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX) {
+        const note = serializeSessionEvent({ type: "loop-agent-output-limit-exhausted", maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX });
+        stdoutPreview.append(`${note}\n`);
+    }
     const stdout = stdoutPreview.text();
     const durationMs = Date.now() - startedAt;
     const collected = stdoutCollector.finish();
     const fallbackParsed = collected.parsedEvents > 0
         ? undefined
         : extractAssistantTextFromPiJson(stdout);
+    const finalTurn = turnCollector.finish();
     const assistantText = collected.parsedEvents > 0
-        ? collected.assistantText
+        ? finalTurn.assistantText
         : (fallbackParsed?.assistantText ?? "");
     const parsedEvents = collected.parsedEvents > 0
         ? collected.parsedEvents
         : (fallbackParsed?.parsedEvents ?? 0);
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const failureCategory = terminationConfirmed
+    const cancelled = stopReason === "aborted";
+    const outputLimitExhausted = Boolean(options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !timedOut && !stderr);
+    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : stopReason === "aborted" ? "cancelled" : outputLimitExhausted ? "output-limit" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : terminationConfirmed
         ? classifyPiFailure({
             assistantText,
             exitCode: timedOut ? 1 : stderr ? 1 : 0,
@@ -900,12 +995,14 @@ export async function executeSingleSdkAttempt(options) {
         backend: "sdk",
         command: ["pi-sdk", ...piSdkArgs],
         durationMs,
-        exitCode: timedOut || stderr ? 1 : 0,
+        exitCode: timedOut || stderr || outputLimitExhausted || cancelled ? 1 : 0,
         failureCategory,
         modelDisplay,
         ok: terminationConfirmed &&
             !timedOut &&
             !stderr &&
+            !outputLimitExhausted &&
+            !cancelled &&
             assistantText.length > 0 &&
             !collected.outputTooLarge,
         parsedEvents,
@@ -915,6 +1012,10 @@ export async function executeSingleSdkAttempt(options) {
         outputTooLarge: collected.outputTooLarge,
         timedOut,
         tokensUsed,
+        usageObservation: collectFrontendUsage(observationEvents),
+        readObservation: readObservation.snapshot(),
+        capabilitiesObservation,
+        ...(options.frontendExecutionPolicy ? { requestEnvelopeObservation } : {}),
         subagentStats: collected.subagentStats,
         // Writer-thinking-exhausted diagnosis evidence (AC-002). Carried through
         // the object spread in executePiStep so executeDagPiNode can read them

package/dist/executors/shell-executor.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 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";
@@ -2065,7 +2065,10 @@ async function executeFrontendVerificationBundle(input, meta) {
                 let reportError;
                 if (observedCommand && result.ok) {
                     try {
-                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(await readFile(reportPath, "utf8")), cwd));
+                        // 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)}`;

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/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/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);