@tea-agent/loop-agent 0.42.0 → 0.43.0-next.2

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;
@@ -730,6 +741,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 +758,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 +788,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 +813,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 +918,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,39 @@ 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";
+/** 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 +579,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 +606,14 @@ 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();
     const usageSamples = [];
+    const observationEvents = [];
+    const readObservation = createFrontendReadObservation();
     let observedTurns = 0;
     let contextBudgetExhausted = false;
     let contextBudgetDetail = "";
@@ -660,6 +703,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;
@@ -737,6 +787,13 @@ export async function executeSingleSdkAttempt(options) {
                     // best-effort: activity must never change Pi result
                 }
             }
+            const observationMessage = isRecord(event.message) ? event.message : undefined;
+            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);
@@ -850,6 +907,8 @@ export async function executeSingleSdkAttempt(options) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        if (options.reserveProviderRequest && message.startsWith("FRONTEND_PROVIDER_"))
+            providerBudgetFailure = message;
         appendStderr(message);
     }
     finally {
@@ -885,7 +944,7 @@ export async function executeSingleSdkAttempt(options) {
         ? collected.parsedEvents
         : (fallbackParsed?.parsedEvents ?? 0);
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const failureCategory = terminationConfirmed
+    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : 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,
@@ -915,6 +974,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,22 @@
+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),
+    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);

package/dist/task/source-prepare/source-fidelity-pi.js

@@ -1,3 +1,6 @@
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { observeFrontendSession } from "../../workflows/dag/frontend-session-budget.js";
 /**
  * 生产 Source Fidelity Pi 适配器（AC-PROD-001..006 / AC-001..006）
  *
@@ -22,7 +25,7 @@ import { resolveDagPiModelConfig } from "../../executors/dag-pi-executor.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 import { listPiSdkAvailableModels } from "../../executors/pi-sdk-executor.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
-import { loadTaskConfig } from "../runtime.js";
+import { getTaskPaths, loadTaskConfig } from "../runtime.js";
 import { buildSemanticIntakeModelQueue, extractJsonObject, } from "./semantic-intake.js";
 import { LEDGER_RECONCILIATION_DEFAULT_BUDGET_CHARS, LedgerReconciliationError, } from "./ledger-reconciliation.js";
 import { LedgerReviewError, } from "./ledger-review.js";
@@ -112,7 +115,7 @@ function buildReconciliationPrompt(request) {
         `fragment path: ${request.fragment.path}`,
         `fragment headingPath: ${request.fragment.headingPath}`,
         `fragment lineRange: ${JSON.stringify(request.fragment.lineRange)}`,
-        `budgetChars: ${request.budgetChars}`,
+        `packing hint: ${request.budgetChars} chars; the fragment below is complete and must not be truncated or summarized before deciding`,
         "fragment text:",
         "```markdown",
         request.fragment.text,
@@ -247,7 +250,11 @@ export async function runProductionLedgerReconciliation(request, options) {
     let lastFailure = "";
     for (const modelRef of queue) {
         try {
-            const result = await execute({
+            const result = await observeFrontendSession({
+                phase: "source-reconciliation", userMessage: "Reconcile the source fragment into the required JSON only.", sourceDigest: createHash("sha256").update(JSON.stringify(request)).digest("hex"), scopeIds: [request.fragment.id], prompt, model: modelRef, taskId: options.taskId, sink: options.observationSink,
+                artifactPath: options.taskId ? path.join(getTaskPaths(options.repoRoot, options.taskId).taskDir, "artifacts", "session-budget", `${randomUUID()}.json`) : undefined,
+            }, observer => execute({
+                onAttemptObservation: observer,
                 attachedFiles: [],
                 modelConfig: resolveDagPiModelConfig(modelRef),
                 prompt,
@@ -266,10 +273,14 @@ export async function runProductionLedgerReconciliation(request, options) {
                         return [error instanceof Error ? error.message : String(error)];
                     }
                 },
-            });
+            }));
             if (!result.ok) {
                 lastFailure =
                     `${result.failureCategory}: ${(result.stderr || result.assistantText).slice(0, 2000)}`;
+                if (result.stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory)) {
+                    lastFailure = `SOURCE_FIDELITY_CAPACITY_EXHAUSTED: refine this complete source fragment without losing conditions; ${lastFailure}`;
+                    break;
+                }
                 continue;
             }
             try {
@@ -306,7 +317,11 @@ export async function runProductionLedgerReview(request, options) {
     let lastFailure = "";
     for (const modelRef of queue) {
         try {
-            const result = await execute({
+            const result = await observeFrontendSession({
+                phase: "source-review", userMessage: "Review the fragment disposition into the required JSON only.", sourceDigest: createHash("sha256").update(JSON.stringify(request)).digest("hex"), scopeIds: [request.fragment.id], prompt, model: modelRef, taskId: options.taskId, sink: options.observationSink,
+                artifactPath: options.taskId ? path.join(getTaskPaths(options.repoRoot, options.taskId).taskDir, "artifacts", "session-budget", `${randomUUID()}.json`) : undefined,
+            }, observer => execute({
+                onAttemptObservation: observer,
                 attachedFiles: [],
                 modelConfig: resolveDagPiModelConfig(modelRef),
                 prompt,
@@ -325,10 +340,14 @@ export async function runProductionLedgerReview(request, options) {
                         return [error instanceof Error ? error.message : String(error)];
                     }
                 },
-            });
+            }));
             if (!result.ok) {
                 lastFailure =
                     `${result.failureCategory}: ${(result.stderr || result.assistantText).slice(0, 2000)}`;
+                if (result.stopReason === "length" || ["context-overflow", "context-budget-exhausted"].includes(result.failureCategory)) {
+                    lastFailure = `SOURCE_FIDELITY_CAPACITY_EXHAUSTED: refine this complete source fragment without losing conditions; ${lastFailure}`;
+                    break;
+                }
                 continue;
             }
             try {
@@ -380,5 +399,5 @@ export async function resolveProductionSourceFidelityPi(input) {
     }
     if (effectiveTaskKind !== SOURCE_FIDELITY_TASK_KIND)
         return undefined;
-    return createProductionSourceFidelityPi({ repoRoot: input.repoRoot });
+    return createProductionSourceFidelityPi({ repoRoot: input.repoRoot, taskId: input.taskId });
 }