@tea-agent/loop-agent 0.43.0-next.4 → 0.43.0-next.6

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

@@ -9,6 +9,9 @@ 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;
@@ -611,6 +614,8 @@ async function executeSingleSdkAttemptInternal(options) {
     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();
@@ -622,6 +627,9 @@ async function executeSingleSdkAttemptInternal(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) => {
@@ -768,6 +776,8 @@ async function executeSingleSdkAttemptInternal(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");
@@ -788,6 +798,8 @@ async function executeSingleSdkAttemptInternal(options) {
                 }
             }
             const observationMessage = isRecord(event.message) ? event.message : undefined;
+            if (typeof observationMessage?.errorMessage === "string")
+                providerErrorMessage = observationMessage.errorMessage;
             try {
                 readObservation.observe(event);
             }
@@ -796,7 +808,7 @@ async function executeSingleSdkAttemptInternal(options) {
                 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();
@@ -810,6 +822,7 @@ async function executeSingleSdkAttemptInternal(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
@@ -820,6 +833,9 @@ async function executeSingleSdkAttemptInternal(options) {
             })
             : null;
         const runTurn = async (userMessage) => {
+            promptIndex += 1;
+            stopReason = undefined;
+            turnCollector = createPiJsonlStreamCollector();
             const settlementPromise = resetSettlement();
             const stallPromise = resetStallPromise();
             const contextBudgetPromise = options.contextBudget
@@ -865,44 +881,55 @@ async function executeSingleSdkAttemptInternal(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) {
@@ -931,20 +958,29 @@ async function executeSingleSdkAttemptInternal(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 ? "termination-unconfirmed" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : 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,
@@ -959,12 +995,14 @@ async function executeSingleSdkAttemptInternal(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,

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

@@ -69,7 +69,7 @@ const reviewResponseSchema = z.object({
         disposition: z.enum(FRAGMENT_DISPOSITIONS).optional(),
         reason: z.string().min(1).optional(),
     })
-        .optional(),
+        .nullish(),
 });
 /**
  * 模型队列构建镜像 semantic-intake.ts：MED→HIGH→LOW（harness executors.pi）+
@@ -134,7 +134,7 @@ function buildReviewPrompt(request) {
         "- approved: true only when the exclusion/conflict handling is justified.",
         "- fragmentId: MUST equal the requested fragment id exactly (echo the `fragment id:` line verbatim); identity mismatch is rejected.",
         "- reason: recommended; explain the verdict.",
-        "- revision: optional single bounded revision {disposition, reason}; never invent requirements or human resolutions.",
+        "- revision: omit or use null when no revision is proposed; otherwise one bounded revision {disposition, reason}. Never invent requirements or human resolutions.",
         JSON.stringify({
             fragmentId: "REQ-SRC-AB12CD34EF56",
             approved: true,

package/dist/task/source-references.js

@@ -5,7 +5,7 @@
  * source/references/, separate from the derived source/需求.md contract.
  */
 import { createHash } from "node:crypto";
-import { access, copyFile, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
+import { access, copyFile, lstat, mkdir, readdir, readFile, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { getTaskPaths, loadTaskConfig } from "./runtime.js";
 import { writeTaskConfig } from "../infrastructure/harness/task-store.js";
@@ -87,6 +87,7 @@ export async function materializeTaskReferenceDocs(input) {
     const referenceDir = path.join(paths.sourceDir, SOURCE_REFERENCE_DIRECTORY);
     await mkdir(referenceDir, { recursive: true });
     const materialized = [];
+    const manifest = await readSourceManifest(paths.sourceDir);
     for (const doc of docs) {
         const absoluteSource = path.isAbsolute(doc.path)
             ? doc.path
@@ -94,7 +95,10 @@ export async function materializeTaskReferenceDocs(input) {
         await assertReadableFile(absoluteSource, `referenceDocs entry "${doc.name ?? doc.path}"`);
         const extension = path.extname(absoluteSource) || ".md";
         const baseName = slugifyName(doc.name ?? path.basename(absoluteSource, extension));
-        const targetName = `${baseName}${extension}`;
+        const imported = manifest?.documents.find((entry) => path.basename(entry.materializedPath, path.extname(entry.materializedPath)) === baseName);
+        const targetName = imported
+            ? path.basename(imported.materializedPath)
+            : `${baseName}${extension}`;
         const targetPath = path.join(referenceDir, targetName);
         try {
             await access(targetPath);
@@ -132,14 +136,23 @@ export async function importPrdDocument(input) {
     catch {
         // directory may be empty / just created
     }
-    // Prefer stable name "requirement.md" when free; otherwise suffix.
-    const preferredName = `${requestedName}${extension}`;
-    const targetFileName = existingNames.has(preferredName)
-        ? // If the same content is already there, reuse; else unique name.
-            (await sameHashIfExists(path.join(referenceDir, preferredName), hash.sha256))
-                ? preferredName
-                : ensureUniqueReferenceName(existingNames, requestedName, extension)
-        : preferredName;
+    // Search every immutable reference, including suffixed and renamed imports.
+    // Roles remain distinct: identical bytes must not erase a constraint/AC role.
+    const matching = existingManifest?.documents.find((doc) => doc.role === role && doc.sha256 === hash.sha256 && doc.bytes === hash.bytes);
+    if (matching) {
+        const candidate = path.resolve(paths.sourceDir, matching.materializedPath);
+        if (path.dirname(candidate) !== path.resolve(referenceDir)) {
+            throw new Error(`REFERENCE_PATH_UNSAFE: ${matching.materializedPath}`);
+        }
+        const stats = await lstat(candidate);
+        if (!stats.isFile() || stats.isSymbolicLink() ||
+            !(await sameHashIfExists(candidate, hash.sha256))) {
+            throw new Error(`REFERENCE_HASH_MISMATCH: ${matching.materializedPath}`);
+        }
+    }
+    const targetFileName = matching
+        ? path.basename(matching.materializedPath)
+        : ensureUniqueReferenceName(existingNames, requestedName, extension);
     const targetPath = path.join(referenceDir, targetFileName);
     if (!(await fileExists(targetPath))) {
         await writeFile(targetPath, hash.content);
@@ -149,7 +162,7 @@ export async function importPrdDocument(input) {
         ? toPosixRelative(input.repoRoot, absoluteSource)
         : input.filePath.split(path.sep).join("/");
     const materializedRelativePath = `${SOURCE_REFERENCE_DIRECTORY}/${targetFileName}`;
-    const document = {
+    const document = matching ?? {
         role,
         name: requestedName,
         sourcePath: sourcePathForRecord,
@@ -176,20 +189,28 @@ export async function importPrdDocument(input) {
             : (existingManifest?.updatedAt ?? importedAt),
         documents,
     };
-    await writeSourceManifest(paths.sourceDir, manifest);
+    if (documentSetChanged)
+        await writeSourceManifest(paths.sourceDir, manifest);
     const taskConfig = await loadTaskConfig(input.repoRoot, input.taskId);
     const referenceDocs = [...(taskConfig.referenceDocs ?? [])];
-    const alreadyListed = referenceDocs.some((doc) => {
+    const listedIndex = referenceDocs.findIndex((doc) => {
         const absolute = path.isAbsolute(doc.path)
             ? doc.path
             : path.resolve(input.repoRoot, doc.path);
         return absolute === absoluteSource;
     });
-    if (!alreadyListed) {
-        referenceDocs.push({
-            name: requestedName,
-            path: sourcePathForRecord,
-        });
+    // Keep original source paths as provenance, but point materialization at
+    // the chosen immutable filename so DAG generation cannot recreate duplicates.
+    const reference = {
+        name: path.basename(targetFileName, path.extname(targetFileName)),
+        path: sourcePathForRecord,
+    };
+    const configChanged = listedIndex < 0 || referenceDocs[listedIndex]?.name !== reference.name;
+    if (configChanged) {
+        if (listedIndex < 0)
+            referenceDocs.push(reference);
+        else
+            referenceDocs[listedIndex] = { ...referenceDocs[listedIndex], ...reference };
         await writeTaskConfig(input.repoRoot, input.taskId, {
             ...taskConfig,
             referenceDocs,
@@ -198,11 +219,15 @@ export async function importPrdDocument(input) {
     // Managed contracts must bump revision after import-prd mutates manifest/task config.
     // Lazy import avoids circular init with contract/observe.
     const { refreshManagedContractAfterImport } = await import("./contract/import-revision.js");
-    await refreshManagedContractAfterImport({
-        repoRoot: input.repoRoot,
-        taskId: input.taskId,
-    });
+    const changed = documentSetChanged || configChanged;
+    if (changed) {
+        await refreshManagedContractAfterImport({
+            repoRoot: input.repoRoot,
+            taskId: input.taskId,
+        });
+    }
     return {
+        changed,
         taskId: input.taskId,
         sourcePath: sourcePathForRecord,
         materializedAbsolutePath: targetPath,
@@ -210,7 +235,7 @@ export async function importPrdDocument(input) {
         sha256: hash.sha256,
         bytes: hash.bytes,
         manifestPath: getSourceManifestPath(paths.sourceDir),
-        referenceDocs: alreadyListed ? referenceDocs : [...referenceDocs],
+        referenceDocs,
     };
 }
 async function sameHashIfExists(filePath, sha256) {