@tea-agent/loop-agent 0.16.25 → 0.17.0

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

@@ -1,8 +1,9 @@
 import path from "node:path";
-import { writeTextArtifactFile } from "../infrastructure/harness/artifact-store.js";
+import { createHash } from "node:crypto";
+import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
 import { executePiStep, } from "./pi-executor.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
-import { readGitStatusPorcelain, runPostRunWriteGuard, } from "./shell-write-guard.js";
+import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 export const DAG_PI_WRITE_TOOLS = [
     "read",
@@ -240,12 +241,15 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         };
     }
     let beforeStatus;
+    let beforePathFingerprints;
     if (isWriteTask) {
         try {
             beforeStatus = await readGitStatusPorcelain(input.cwd);
+            beforePathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, snapshotGitStatusPorcelain(beforeStatus));
         }
         catch {
             beforeStatus = undefined;
+            beforePathFingerprints = undefined;
         }
     }
     const result = await piStepFn({
@@ -278,15 +282,19 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
     }
     let writeGuardOk = true;
     let writeGuardViolations = [];
+    let changeManifestAfterStatus;
+    let changeManifestChangedFiles;
     if (beforeStatus !== undefined) {
         try {
-            const guard = await runPostRunWriteGuard({
-                rootCwd: input.cwd,
-                beforeStatus,
-                writePolicy: input.task.writePolicy,
-                writeSet: input.task.writeSet,
-                allowedPaths: input.task.allowedPaths,
-                forbiddenPaths: input.task.forbiddenPaths,
+            const afterStatus = await readGitStatusPorcelain(input.cwd);
+            const afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
+            const afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
+            const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
+            changeManifestAfterStatus = afterStatus;
+            changeManifestChangedFiles = changedFiles;
+            const guard = validateShellWriteGuardFromDiff({
+                changedFiles,
+                task: input.task,
                 concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
             });
             writeGuardOk = guard.ok;
@@ -300,6 +308,16 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         }
     }
     if (writeGuardOk) {
+        if (beforeStatus !== undefined && changeManifestChangedFiles !== undefined) {
+            await persistWriterChangeManifest({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                writerNodeId: input.task.id,
+                changedFiles: changeManifestChangedFiles,
+                beforeStatus,
+                afterStatus: changeManifestAfterStatus ?? "",
+            });
+        }
         return mapped;
     }
     const stderrParts = [mapped.stderr];
@@ -335,11 +353,18 @@ function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
         return assistantText;
     const lines = assistantText.split(/\r?\n/);
     let protocolIndex = -1;
+    let protocolNextLineIndex = -1;
     let protocolLine = "";
     for (const [index, line] of lines.entries()) {
-        const normalized = normalizeProtocolLine(line);
-        if (normalized.startsWith(firstProtocolLine)) {
+        const nextLine = lines[index + 1];
+        const normalized = normalizeProtocolLine(line, firstProtocolLine, nextLine);
+        if (normalized !== undefined) {
             protocolIndex = index;
+            if (normalizeProtocolLine(line, firstProtocolLine) === undefined &&
+                nextLine !== undefined &&
+                normalizedProtocolValue(nextLine) !== "") {
+                protocolNextLineIndex = index + 1;
+            }
             protocolLine = normalized;
             break;
         }
@@ -347,10 +372,14 @@ function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
     if (protocolIndex < 0)
         return assistantText;
     if (protocolIndex === 0) {
-        return [protocolLine, ...lines.slice(1)].join("\n");
+        const remaining = lines.slice(protocolNextLineIndex === 1 ? 2 : 1);
+        return [protocolLine, ...remaining].join("\n");
     }
     const before = lines.slice(0, protocolIndex);
     const after = lines.slice(protocolIndex + 1);
+    if (protocolNextLineIndex === protocolIndex + 1) {
+        after.shift();
+    }
     while (before.at(-1)?.trim() === "" &&
         after.at(0)?.trim() === "") {
         after.shift();
@@ -364,8 +393,81 @@ function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
         ? `${protocolLine}\n\n${bodyLines.join("\n")}`
         : protocolLine;
 }
-function normalizeProtocolLine(line) {
-    const trimmed = line.trim();
-    const emphasized = trimmed.match(/^(\*{1,3})\s*(.*?)\s*\1$/);
-    return (emphasized?.[2] ?? trimmed).trim();
+function normalizeProtocolLine(line, firstProtocolLine, nextLine) {
+    const normalizedLine = stripMarkdownLineDecorations(line);
+    if (!firstProtocolLine)
+        return normalizedLine;
+    const label = firstProtocolLine.replace(/[:：]\s*$/, "").trim();
+    const labelPattern = label
+        .split(/[_\-\s]+/)
+        .filter(Boolean)
+        .map(escapeRegExp)
+        .join("[_\\-\\s]+");
+    if (!labelPattern)
+        return undefined;
+    const direct = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
+    if (direct) {
+        const value = normalizedProtocolValue(direct[1] ?? "");
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    const splitValue = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]?\\s*$`, "i"));
+    if (splitValue && nextLine !== undefined) {
+        const value = normalizedProtocolValue(nextLine);
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
+    return undefined;
+}
+function normalizedProtocolValue(value) {
+    let normalized = stripMarkdownLineDecorations(value);
+    normalized = normalized.replace(/^[:：]\s*/, "").trim();
+    normalized = normalized.replace(/[。.!；;，,]+$/u, "").trim();
+    normalized = stripMarkdownLineDecorations(normalized);
+    return normalized;
+}
+function stripMarkdownLineDecorations(line) {
+    let trimmed = line.trim();
+    trimmed = trimmed.replace(/^(?:>\s*)+/, "");
+    trimmed = trimmed.replace(/^(?:[-*+]\s+|\d+[.)]\s+)/, "");
+    const emphasized = trimmed.match(/^(\*{1,3}|_{1,3}|`{1,3})\s*(.*?)\s*\1$/);
+    trimmed = (emphasized?.[2] ?? trimmed).trim();
+    return trimmed;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Validate the writer's observed diff against its declared write boundary.
+ * Inlined mirror of runPostRunWriteGuard that reuses the already-computed diff
+ * so the change manifest and the guard share one source of truth.
+ */
+function validateShellWriteGuardFromDiff(input) {
+    return validateShellWriteGuard({
+        changedPaths: input.changedFiles,
+        writePolicy: input.task.writePolicy,
+        writeSet: input.task.writeSet,
+        allowedPaths: input.task.allowedPaths,
+        forbiddenPaths: input.task.forbiddenPaths,
+        concurrentSiblingWriteSets: input.concurrentSiblingWriteSets,
+        allowSiblingWriteSetAttribution: input.task.writePolicy === "exclusive" &&
+            (input.concurrentSiblingWriteSets?.length ?? 0) > 0,
+    });
+}
+/**
+ * Persist the writer's actual changeset as a run-owned artifact so the
+ * project governance context resolver can attribute exactly this run's
+ * writes (not final `git status`, which may include pre-existing changes).
+ */
+async function persistWriterChangeManifest(input) {
+    const manifest = {
+        schemaVersion: 1,
+        writerNodeId: input.writerNodeId,
+        changedFiles: input.changedFiles,
+        beforeStatusSha256: createHash("sha256")
+            .update(input.beforeStatus)
+            .digest("hex"),
+        afterStatusSha256: createHash("sha256")
+            .update(input.afterStatus)
+            .digest("hex"),
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "change-manifest.json", manifest);
 }

package/dist/executors/pi-executor.js

@@ -50,6 +50,10 @@ export function extractSubagentStats(stdout) {
 export const DEFAULT_TIMEOUT_MS = 1_800_000;
 export const MAX_ALLOWED_TIMEOUT_MS = 1_800_000;
 const PI_BACKEND_ENV = 'CODE_AGENT_PI_BACKEND';
+const OUTPUT_PREVIEW_HEAD_CHARS = 64_000;
+const OUTPUT_PREVIEW_TAIL_CHARS = 64_000;
+const MAX_STREAM_JSONL_LINE_CHARS = 16_000_000;
+const MAX_ASSISTANT_TEXT_CHARS = 16_000_000;
 const PI_CLI_PACKAGE_NAMES = [
     '@earendil-works/pi-coding-agent',
     '@mariozechner/pi-coding-agent',
@@ -186,6 +190,10 @@ function resolvePiCliPath() {
         path.join(nvmBase, nodeVersion, 'lib', 'node_modules'),
     ].flatMap((nodeModulesRoot) => PI_CLI_PACKAGE_NAMES.map((packageName) => piCliPathFromPackageRoot(nodeModulesRoot, packageName)));
     const otherCandidates = [
+        // Prefer the project-local Pi dependency. `npm run` adds node_modules/.bin
+        // to PATH, but direct invocations from the DAG runner may not, so resolve
+        // the package from the current workspace explicitly.
+        ...PI_CLI_PACKAGE_NAMES.map((packageName) => piCliPathFromPackageRoot(path.resolve(process.cwd(), 'node_modules'), packageName)),
         // Global npm installation (non-nvm)
         ...PI_CLI_PACKAGE_NAMES.map((packageName) => piCliPathFromPackageRoot('/usr/local/lib/node_modules', packageName)),
         // Bun installation
@@ -327,8 +335,167 @@ function extractAssistantTextFromMessage(message) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+export class BoundedTextPreview {
+    label;
+    headMax;
+    tailMax;
+    parts = [];
+    head = '';
+    tail = '';
+    bufferedChars = 0;
+    totalChars = 0;
+    truncated = false;
+    constructor(label, headMax = OUTPUT_PREVIEW_HEAD_CHARS, tailMax = OUTPUT_PREVIEW_TAIL_CHARS) {
+        this.label = label;
+        this.headMax = headMax;
+        this.tailMax = tailMax;
+    }
+    append(chunk) {
+        if (!chunk)
+            return;
+        this.totalChars += chunk.length;
+        if (!this.truncated) {
+            if (this.bufferedChars + chunk.length <= this.headMax + this.tailMax) {
+                this.parts.push(chunk);
+                this.bufferedChars += chunk.length;
+                return;
+            }
+            const combined = this.parts.join('') + chunk;
+            this.head = combined.slice(0, this.headMax);
+            this.tail = combined.slice(-this.tailMax);
+            this.parts = [];
+            this.bufferedChars = 0;
+            this.truncated = true;
+            return;
+        }
+        this.tail = (this.tail + chunk).slice(-this.tailMax);
+    }
+    text() {
+        if (!this.truncated)
+            return this.parts.join('');
+        const omitted = Math.max(0, this.totalChars - this.head.length - this.tail.length);
+        return [
+            this.head,
+            `[${this.label} truncated: omitted ${omitted} chars; kept first ${this.head.length} and last ${this.tail.length}]`,
+            this.tail,
+        ].join('\n');
+    }
+}
+export class PiJsonlStreamCollector {
+    lineBuffer = '';
+    discardUntilNewline = false;
+    assistantText = '';
+    parsedEvents = 0;
+    tokensUsed = 0;
+    outputTooLarge = false;
+    subagentTotalCalls = 0;
+    subagentFailedCalls = 0;
+    subagentModes = new Set();
+    subagentAgents = new Set();
+    append(chunk) {
+        if (!chunk)
+            return;
+        const lines = chunk.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const part = lines[index] ?? '';
+            const isLast = index === lines.length - 1;
+            if (this.discardUntilNewline) {
+                if (!isLast)
+                    this.discardUntilNewline = false;
+                continue;
+            }
+            if (this.lineBuffer.length + part.length > MAX_STREAM_JSONL_LINE_CHARS) {
+                this.outputTooLarge = true;
+                this.lineBuffer = '';
+                if (isLast)
+                    this.discardUntilNewline = true;
+                continue;
+            }
+            this.lineBuffer += part;
+            if (!isLast) {
+                this.consumeLine(this.lineBuffer);
+                this.lineBuffer = '';
+            }
+        }
+    }
+    finish() {
+        if (!this.discardUntilNewline && this.lineBuffer.trim()) {
+            this.consumeLine(this.lineBuffer);
+        }
+        this.lineBuffer = '';
+        return {
+            assistantText: this.assistantText.trim(),
+            outputTooLarge: this.outputTooLarge,
+            parsedEvents: this.parsedEvents,
+            subagentStats: this.formatSubagentStats(),
+            tokensUsed: this.tokensUsed,
+        };
+    }
+    consumeLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        try {
+            const event = JSON.parse(trimmed);
+            this.parsedEvents += 1;
+            this.consumeEvent(event);
+        }
+        catch {
+            // tolerate non-json noise
+        }
+    }
+    consumeEvent(event) {
+        const candidate = extractAssistantTextFromEvent(event);
+        if (candidate) {
+            if (candidate.length > MAX_ASSISTANT_TEXT_CHARS) {
+                this.outputTooLarge = true;
+                this.assistantText = candidate.slice(0, MAX_ASSISTANT_TEXT_CHARS);
+            }
+            else {
+                this.assistantText = candidate;
+            }
+        }
+        const usage = extractUsageFromEvent(event);
+        if (usage !== null)
+            this.tokensUsed += usage;
+        if (event.type === 'tool_execution_start' && event.toolName === 'subagent') {
+            this.subagentTotalCalls += 1;
+            if (isRecord(event.input)) {
+                if (event.input.agent)
+                    this.subagentAgents.add(String(event.input.agent));
+                if (event.input.tasks)
+                    this.subagentModes.add('parallel');
+                if (event.input.chain)
+                    this.subagentModes.add('chain');
+                if (event.input.agent && !event.input.tasks && !event.input.chain) {
+                    this.subagentModes.add('single');
+                }
+            }
+        }
+        if (event.type === 'tool_execution_end' && event.toolName === 'subagent') {
+            if (event.isError === true)
+                this.subagentFailedCalls += 1;
+        }
+    }
+    formatSubagentStats() {
+        if (this.subagentTotalCalls === 0)
+            return 'calls=0';
+        const parts = [`calls=${this.subagentTotalCalls}`];
+        if (this.subagentFailedCalls > 0)
+            parts.push(`${this.subagentFailedCalls} failed`);
+        if (this.subagentModes.size > 0)
+            parts.push(Array.from(this.subagentModes).sort().join('+'));
+        if (this.subagentAgents.size > 0) {
+            parts.push(`agents=[${Array.from(this.subagentAgents).sort().join(',')}]`);
+        }
+        return parts.join(' | ');
+    }
+}
+export function createPiJsonlStreamCollector() {
+    return new PiJsonlStreamCollector();
+}
 function withSubagentStats(result) {
-    return { ...result, subagentStats: extractSubagentStats(result.stdout) };
+    return { ...result, subagentStats: result.subagentStats ?? extractSubagentStats(result.stdout) };
 }
 function withCliBackend(result) {
     return { ...result, backend: 'cli' };
@@ -354,7 +521,10 @@ async function runCliOrchestration(options, meta) {
         const fallbackResult = await executeSingleCliAttempt(options, primary.fallback);
         attemptedModels.push(fallbackResult.modelDisplay);
         const combinedStderr = [primaryResult.stderr, fallbackResult.stderr].filter(Boolean).join('\n--- fallback ---\n');
-        const combinedStdout = [primaryResult.stdout, fallbackResult.stdout].filter(Boolean).join('\n');
+        const combinedStdout = [primaryResult.stdout, fallbackResult.stdout].filter(Boolean).join('\n--- fallback ---\n');
+        const combinedStdoutTruncated = primaryResult.stdoutTruncated || fallbackResult.stdoutTruncated;
+        const combinedStderrTruncated = primaryResult.stderrTruncated || fallbackResult.stderrTruncated;
+        const combinedOutputTooLarge = primaryResult.outputTooLarge || fallbackResult.outputTooLarge;
         let fallbackIssues = [];
         if (fallbackResult.ok && options.validateOutput) {
             fallbackIssues = options.validateOutput(fallbackResult.assistantText);
@@ -367,6 +537,9 @@ async function runCliOrchestration(options, meta) {
                 sdkAttempted: meta?.sdkAttempted,
                 stderr: combinedStderr,
                 stdout: combinedStdout,
+                stdoutTruncated: combinedStdoutTruncated,
+                stderrTruncated: combinedStderrTruncated,
+                outputTooLarge: combinedOutputTooLarge,
             }));
         }
         if (fallbackResult.ok && fallbackIssues.length > 0) {
@@ -379,6 +552,9 @@ async function runCliOrchestration(options, meta) {
                 sdkAttempted: meta?.sdkAttempted,
                 stderr: combinedStderr + `\n[invalid-output] ${fallbackIssues.join('; ')}`,
                 stdout: combinedStdout,
+                stdoutTruncated: combinedStdoutTruncated,
+                stderrTruncated: combinedStderrTruncated,
+                outputTooLarge: combinedOutputTooLarge,
             }));
         }
         return withSubagentStats(withCliBackend({
@@ -388,6 +564,9 @@ async function runCliOrchestration(options, meta) {
             sdkAttempted: meta?.sdkAttempted,
             stderr: combinedStderr,
             stdout: combinedStdout,
+            stdoutTruncated: combinedStdoutTruncated,
+            stderrTruncated: combinedStderrTruncated,
+            outputTooLarge: combinedOutputTooLarge,
         }));
     }
     if (primaryInvalidOutput) {
@@ -516,12 +695,18 @@ async function executeSingleCliAttempt(options, modelConfig) {
             },
             stdio: ['ignore', 'pipe', 'pipe'],
         });
-        let stdout = '';
-        let stderr = '';
+        const stdoutPreview = new BoundedTextPreview('stdout');
+        const stderrPreview = new BoundedTextPreview('stderr', 16_000, 16_000);
+        const stdoutCollector = new PiJsonlStreamCollector();
         child.stdout.setEncoding('utf-8');
         child.stderr.setEncoding('utf-8');
-        child.stdout.on('data', (chunk) => { stdout += chunk; });
-        child.stderr.on('data', (chunk) => { stderr += chunk; });
+        child.stdout.on('data', (chunk) => {
+            stdoutPreview.append(chunk);
+            stdoutCollector.append(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderrPreview.append(chunk);
+        });
         child.on('error', (err) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
@@ -535,28 +720,34 @@ async function executeSingleCliAttempt(options, modelConfig) {
             if (sigkillHandle)
                 clearTimeout(sigkillHandle);
             const durationMs = Date.now() - startedAt;
-            const { assistantText, parsedEvents } = extractAssistantTextFromPiJson(stdout);
-            const tokensUsed = extractTokenUsageFromPiJson(stdout);
+            const stdout = stdoutPreview.text();
+            const stderr = stderrPreview.text();
+            const collected = stdoutCollector.finish();
             const failureCategory = classifyPiFailure({
-                assistantText,
+                assistantText: collected.assistantText,
                 exitCode: code,
                 stderr,
                 stdout,
                 timedOut,
+                outputTooLarge: collected.outputTooLarge,
             });
             resolve({
-                assistantText,
+                assistantText: collected.assistantText,
                 command: ['pi', ...piArgs],
                 durationMs,
                 exitCode: code,
                 failureCategory,
                 modelDisplay,
-                ok: code === 0 && assistantText.length > 0,
-                parsedEvents,
+                ok: code === 0 && collected.assistantText.length > 0 && !collected.outputTooLarge,
+                parsedEvents: collected.parsedEvents,
                 stderr,
                 stdout,
+                stdoutTruncated: stdoutPreview.truncated,
+                stderrTruncated: stderrPreview.truncated,
+                outputTooLarge: collected.outputTooLarge,
                 timedOut,
-                tokensUsed,
+                tokensUsed: collected.tokensUsed,
+                subagentStats: collected.subagentStats,
             });
         });
         if (timeoutMs > 0) {
@@ -585,6 +776,8 @@ export function shouldRetryWithFallback(stderr, stdout) {
 export function classifyPiFailure(input) {
     if (input.timedOut)
         return 'timeout';
+    if (input.outputTooLarge)
+        return 'output-too-large';
     if (input.exitCode === 0 && input.assistantText.trim())
         return 'success';
     const combined = `${input.stderr}\n${input.stdout}`.toLowerCase();

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

@@ -1,6 +1,6 @@
 import { appendFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
-import { classifyPiFailure, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
+import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, } from './pi-executor.js';
 import { serializeSessionEvent } from './pi-event-serializer.js';
 let sdkSessionFactoryOverride;
 let sdkImportOverrideForTests;
@@ -283,7 +283,8 @@ export async function executeSingleSdkAttempt(options) {
     const startedAt = Date.now();
     let timedOut = false;
     let stderr = '';
-    const stdoutLines = [];
+    const stdoutPreview = new BoundedTextPreview('stdout');
+    const stdoutCollector = createPiJsonlStreamCollector();
     const usageSamples = [];
     let session;
     let timeoutHandle;
@@ -307,7 +308,8 @@ export async function executeSingleSdkAttempt(options) {
             if (!shouldPersistSessionEvent(event))
                 return;
             const line = serializeSessionEvent(event);
-            stdoutLines.push(line);
+            stdoutPreview.append(`${line}\n`);
+            stdoutCollector.append(`${line}\n`);
             sessionEventAppender?.append(line, event);
         });
         const filePrefix = options.attachedFiles.map((file) => `@${file}`).join(' ');
@@ -363,13 +365,23 @@ export async function executeSingleSdkAttempt(options) {
             }
         }
     }
-    const stdout = stdoutLines.join('\n');
+    const stdout = stdoutPreview.text();
     const durationMs = Date.now() - startedAt;
-    const { assistantText, parsedEvents } = extractAssistantTextFromPiJson(stdout);
+    const collected = stdoutCollector.finish();
+    const fallbackParsed = collected.parsedEvents > 0
+        ? undefined
+        : extractAssistantTextFromPiJson(stdout);
+    const assistantText = collected.parsedEvents > 0
+        ? collected.assistantText
+        : fallbackParsed?.assistantText ?? '';
+    const parsedEvents = collected.parsedEvents > 0
+        ? collected.parsedEvents
+        : fallbackParsed?.parsedEvents ?? 0;
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
     const failureCategory = classifyPiFailure({
         assistantText,
         exitCode: timedOut ? 1 : stderr ? 1 : 0,
+        outputTooLarge: collected.outputTooLarge,
         stderr,
         stdout,
         timedOut,
@@ -382,11 +394,14 @@ export async function executeSingleSdkAttempt(options) {
         exitCode: timedOut || stderr ? 1 : 0,
         failureCategory,
         modelDisplay,
-        ok: !timedOut && !stderr && assistantText.length > 0,
+        ok: !timedOut && !stderr && assistantText.length > 0 && !collected.outputTooLarge,
         parsedEvents,
         stderr,
         stdout,
+        stdoutTruncated: stdoutPreview.truncated,
+        outputTooLarge: collected.outputTooLarge,
         timedOut,
         tokensUsed,
+        subagentStats: collected.subagentStats,
     };
 }