@poncho-ai/harness 0.60.1 → 0.61.1

package/src/compaction.ts

@@ -9,22 +9,36 @@ const MIN_COMPACTABLE_MESSAGES = 4;
 const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
   enabled: true,
   trigger: 0.75,
-  keepRecentMessages: 4,
+  keepRecentTurns: 4,
+  keepRecentMessages: 6,
 };
-const SUMMARIZATION_MESSAGE_TRUNCATION_CHARS = 1200;
-const SUMMARIZATION_MAX_OUTPUT_TOKENS = 768;
+const SUMMARIZATION_MESSAGE_TRUNCATION_CHARS = 4000;
+const SUMMARIZATION_MAX_OUTPUT_TOKENS = 8192;
+/**
+ * Upper bound on the tokens fed INTO the summarization model call. With hundreds
+ * of compacted messages at 4000 chars each the joined transcript can exceed the
+ * summarizer's own window; we drop the oldest non-error, non-prior-summary
+ * messages first so recent context and every failure survive. Held well under a
+ * 200k window to leave room for the prompt + output.
+ */
+const SUMMARIZATION_MAX_INPUT_TOKENS = 120_000;
 
 const SUMMARIZATION_PROMPT = `Summarize the following conversation into a structured working state that allows continuation without re-asking questions. Include:
 
 1. **User intent**: What the user originally asked for and any refinements
-2. **Completed work**: What has been accomplished so far
+2. **Completed work**: What has been accomplished AND CONFIRMED so far
 3. **Key decisions**: Technical decisions made and their rationale
-4. **Errors & fixes**: Errors encountered and how they were resolved
-5. **Referenced resources**: Files, URLs, tools, or data referenced
-6. **Pending next steps**: What remains to be done
+4. **Unresolved errors & failures**: Every error, failed or uncertain tool call, and failed or incomplete subagent — recorded verbatim enough to act on. NEVER drop a failure because it is old. This section is REQUIRED whenever any failure occurred; do not omit it.
+5. **Pending promises**: Anything the assistant said it WOULD do but has not confirmed done.
+6. **Referenced resources**: Files, URLs, tools, or data referenced
+7. **Pending next steps**: What remains to be done
+
+Rules:
+- NEVER describe work as "completed", "done", or "fixed" unless the conversation contains explicit confirmation (a successful tool result or the user acknowledging it). If completion is unverified, record it under "Pending next steps" as unconfirmed.
+- Preserve identifiers verbatim — file paths, URLs, IDs, command names, tool names. Do not paraphrase or truncate them.
 
 Be concise but preserve all information needed to continue the task.
-Omit any section that has no relevant content.`;
+Omit any section that has no relevant content, EXCEPT "Unresolved errors & failures" when a failure occurred.`;
 
 /**
  * Extra instruction appended when the first compacted message is itself a
@@ -34,8 +48,13 @@ Omit any section that has no relevant content.`;
  */
 const CUMULATIVE_SUMMARY_PROMPT = `The FIRST message below (tagged [prior-summary]) is an existing working-state summary produced by an earlier compaction. Treat it as the authoritative prior working state: MERGE AND UPDATE it with the newer messages that follow it, carrying forward all still-relevant detail. Do NOT discard or re-compress information from the prior summary just because it is older — only drop it if the newer messages explicitly supersede it.`;
 
-/** Max chars of a subagent result text kept verbatim in the ledger digest. */
-const SUBAGENT_DIGEST_CHARS = 500;
+/**
+ * Max chars of a subagent result text kept verbatim in the ledger digest. Kept
+ * large (and NOT gated on outcome) so a failed subagent's own explanation
+ * survives compaction — the failing case is exactly the one that must not be
+ * clipped, and it can be mislabeled, so gating on status would be self-defeating.
+ */
+const SUBAGENT_DIGEST_CHARS = 2000;
 
 /** Heading used for the verbatim, model-proof subagent ledger block. */
 const SUBAGENT_LEDGER_HEADING = "## Subagents";
@@ -47,6 +66,8 @@ export const resolveCompactionConfig = (
   return {
     enabled: explicit.enabled ?? DEFAULT_COMPACTION_CONFIG.enabled,
     trigger: explicit.trigger ?? DEFAULT_COMPACTION_CONFIG.trigger,
+    keepRecentTurns:
+      explicit.keepRecentTurns ?? DEFAULT_COMPACTION_CONFIG.keepRecentTurns,
     keepRecentMessages:
       explicit.keepRecentMessages ??
       DEFAULT_COMPACTION_CONFIG.keepRecentMessages,
@@ -162,6 +183,71 @@ export const findSafeSplitPoint = (
   return -1;
 };
 
+/**
+ * Find the split index that preserves the last `keepRecentTurns` whole *turns*
+ * verbatim. A turn begins at a `role:"user"` message and runs until the next
+ * `user` message. Everything before the split is folded into the summary;
+ * everything from the split onward is kept as-is.
+ *
+ * Two guards make a candidate split acceptable:
+ *  1. The compacted side has at least `MIN_COMPACTABLE_MESSAGES` messages.
+ *  2. The preserved side estimates at most `maxPreservedTokens` — so keeping N
+ *     large turns can never leave the post-compaction context above the
+ *     compaction trigger (which caused re-compaction thrash / window overflow).
+ * The tool-call-orphan guard (`splitOrphansToolCalls`) is preserved: a split
+ * that would strand an assistant tool-call on the compacted side steps to an
+ * earlier user boundary (which only preserves more, always safe).
+ *
+ * We try the largest N (up to `keepRecentTurns`) first and decrement, so we
+ * keep as many turns as fit. If no turn boundary yields a safe split (e.g. a
+ * single giant turn near the window), fall back to the message-based
+ * `findSafeSplitPoint` so the middle of that turn still compacts.
+ *
+ * Returns -1 when nothing safe can be compacted.
+ */
+export const findSafeSplitPointByTurns = (
+  messages: Message[],
+  keepRecentTurns: number,
+  keepRecentMessagesFallback: number,
+  maxPreservedTokens: number,
+): number => {
+  // Indices of every user message, in order.
+  const userIdx: number[] = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i]!.role === "user") userIdx.push(i);
+  }
+
+  const maxN = Math.min(keepRecentTurns, userIdx.length);
+  for (let n = maxN; n >= 1; n--) {
+    // The Nth-from-last user message starts the preserved region.
+    let guardN = n;
+    let split = userIdx[userIdx.length - guardN]!;
+    // Orphan guard: step to an earlier user boundary if the compacted side
+    // would end on an assistant tool-call whose result moved to the preserved
+    // side. Walking earlier only preserves more, so it stays within budget
+    // checks below.
+    while (
+      splitOrphansToolCalls(messages, split) &&
+      guardN < userIdx.length
+    ) {
+      guardN++;
+      split = userIdx[userIdx.length - guardN]!;
+    }
+    if (split < MIN_COMPACTABLE_MESSAGES) continue;
+    const preservedTokens = estimateTokens(
+      messages
+        .slice(split)
+        .map((m) => getTextContent(m))
+        .join("\n"),
+    );
+    if (preservedTokens <= maxPreservedTokens) return split;
+  }
+
+  // No turn boundary fits: fall back to the legacy message-based split so a
+  // single giant turn still gets its middle compacted.
+  return findSafeSplitPoint(messages, keepRecentMessagesFallback);
+};
+
 /**
  * Whether a message is itself a prior compaction summary.
  */
@@ -175,8 +261,17 @@ const isCompactionSummary = (msg: Message): boolean =>
  * compaction summary, it is passed in FULL (not truncated to
  * SUMMARIZATION_MESSAGE_TRUNCATION_CHARS) and tagged `[prior-summary]`, and
  * the prompt instructs the model to merge-and-update rather than
- * re-summarize. All other messages keep the 1200-char truncation.
+ * re-summarize. All other messages keep the per-message truncation.
+ *
+ * Total-input budget: with many messages the joined transcript can exceed the
+ * summarizer's own window, so we cap it at SUMMARIZATION_MAX_INPUT_TOKENS and
+ * drop the OLDEST non-important lines first. A line is "important" (never
+ * dropped) if it is the prior summary or carries a failure/error signal — so
+ * every failure and the most recent context always reach the summarizer.
  */
+const FAILURE_SIGNAL_RE =
+  /\berror\b|\bfailed\b|\bfailure\b|\bexception\b|could ?n[’']?t|cannot\b|unable to|\[subagent result\]/i;
+
 const buildSummarizationMessages = (
   messagesToCompact: Message[],
   instructions?: string,
@@ -184,7 +279,12 @@ const buildSummarizationMessages = (
   const hasPriorSummary =
     messagesToCompact.length > 0 && isCompactionSummary(messagesToCompact[0]!);
 
-  const conversationLines: string[] = [];
+  interface Line {
+    text: string;
+    tokens: number;
+    important: boolean;
+  }
+  const lines: Line[] = [];
   for (let i = 0; i < messagesToCompact.length; i++) {
     const msg = messagesToCompact[i]!;
     const text = getTextContent(msg);
@@ -196,9 +296,29 @@ const buildSummarizationMessages = (
         : text.slice(0, SUMMARIZATION_MESSAGE_TRUNCATION_CHARS) +
           "\n...[truncated]";
     const tag = isPrior ? "prior-summary" : msg.role;
-    conversationLines.push(`[${tag}]: ${rendered}`);
+    const line = `[${tag}]: ${rendered}`;
+    lines.push({
+      text: line,
+      tokens: estimateTokens(line),
+      important: isPrior || FAILURE_SIGNAL_RE.test(text),
+    });
   }
 
+  // Enforce the input budget: while over, drop the oldest non-important line.
+  let total = lines.reduce((sum, l) => sum + l.tokens, 0);
+  if (total > SUMMARIZATION_MAX_INPUT_TOKENS) {
+    for (let i = 0; i < lines.length && total > SUMMARIZATION_MAX_INPUT_TOKENS; ) {
+      if (lines[i]!.important) {
+        i++;
+        continue;
+      }
+      total -= lines[i]!.tokens;
+      lines.splice(i, 1);
+    }
+  }
+
+  const conversationLines = lines.map((l) => l.text);
+
   let prompt = SUMMARIZATION_PROMPT;
   if (hasPriorSummary) prompt = `${prompt}\n\n${CUMULATIVE_SUMMARY_PROMPT}`;
   if (instructions) prompt = `${prompt}\n\nAdditional focus: ${instructions}`;
@@ -246,7 +366,15 @@ const parseSubagentCallback = (msg: Message): SubagentLedgerEntry | null => {
     typeof meta.task === "string" && meta.task
       ? meta.task
       : headerMatch?.[1] ?? "";
-  const status = headerMatch?.[3] ?? "completed";
+  // The ledger "status" is the subagent's TASK OUTCOME (succeeded/failed/
+  // partial/unknown), not its run status. Prefer the structured metadata; fall
+  // back to the header token. NEVER default to "completed" — an unparseable
+  // header must not silently assert success. `status` remains the field name
+  // for backward compat with parsePriorLedger's rendered shape.
+  const status =
+    (typeof meta.taskOutcome === "string" && meta.taskOutcome) ||
+    headerMatch?.[3] ||
+    "unknown";
 
   // Digest = the body after the header line (the result text), capped.
   const bodyStart = text.indexOf("\n\n");
@@ -338,8 +466,17 @@ const buildContinuationMessage = (summary: string): Message => ({
 
 export interface CompactMessagesOptions {
   instructions?: string;
+  /**
+   * The model's context window (tokens). Used to bound the preserved side of a
+   * turn-based split so keeping N recent turns can't leave the post-compaction
+   * context above the compaction trigger. Defaults to 200k when omitted.
+   */
+  contextWindow?: number;
 }
 
+/** Fraction of the context window the preserved (verbatim) side may occupy. */
+const MAX_PRESERVED_CONTEXT_FRACTION = 0.5;
+
 export interface CompactResult {
   compacted: boolean;
   messages: Message[];
@@ -363,7 +500,18 @@ export const compactMessages = async (
   config: CompactionConfig,
   options?: CompactMessagesOptions,
 ): Promise<CompactResult> => {
-  const splitIdx = findSafeSplitPoint(messages, config.keepRecentMessages);
+  const contextWindow = options?.contextWindow && options.contextWindow > 0
+    ? options.contextWindow
+    : 200_000;
+  const maxPreservedTokens = Math.floor(
+    contextWindow * MAX_PRESERVED_CONTEXT_FRACTION,
+  );
+  const splitIdx = findSafeSplitPointByTurns(
+    messages,
+    config.keepRecentTurns,
+    config.keepRecentMessages,
+    maxPreservedTokens,
+  );
   if (splitIdx === -1) {
     return {
       compacted: false,

package/src/harness.ts

@@ -2286,7 +2286,12 @@ export class AgentHarness {
     const modelName = agent.frontmatter.model?.name ?? "claude-opus-4-5";
     const modelInstance = this.modelProvider(modelName);
     const config = resolveCompactionConfig(agent.frontmatter.compaction);
-    return compactMessages(modelInstance, messages, config, options);
+    const contextWindow =
+      agent.frontmatter.model?.contextWindow ?? getModelContextWindow(modelName);
+    return compactMessages(modelInstance, messages, config, {
+      ...options,
+      contextWindow: options?.contextWindow ?? contextWindow,
+    });
   }
 
   async *run(input: RunInput): AsyncGenerator<AgentEvent> {
@@ -2317,7 +2322,7 @@ export class AgentHarness {
     let agent = this.parsedAgent as ParsedAgent;
     const runId = `run_${randomUUID()}`;
     const start = now();
-    const maxSteps = agent.frontmatter.limits?.maxSteps ?? 20;
+    const maxSteps = input.maxSteps ?? agent.frontmatter.limits?.maxSteps ?? 20;
     // A constructor-level override (e.g. a longer budget for background
     // subagents) takes precedence over the agent definition's limits.timeout.
     const configuredTimeout = this.runTimeoutSecOverride ?? agent.frontmatter.limits?.timeout;
@@ -3082,6 +3087,7 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
               modelInstance,
               messages,
               compactionConfig,
+              { contextWindow },
             );
             if (compactResult.compacted) {
               messages.length = 0;
@@ -3096,6 +3102,16 @@ Code is wrapped in an async IIFE — use \`return\` to return a value to the too
                   emittedMessages.pop();
                 }
               }
+              // MID-RUN COMPACTION (step > 1) intentionally emits
+              // `compactedMessages: undefined`. The live `messages` array is
+              // already rewritten in place above (so the rest of the run and
+              // the end-of-run `continuationMessages` reflect the compaction),
+              // but we do NOT drive the runner's persisted `compactedHistory`
+              // archive mid-turn: that would require a get→mutate→update on the
+              // conversation row while the turn is still in flight, which is the
+              // clobber pattern PonchOS forbids for non-terminal writers. The
+              // compacted content is preserved in the summary; only the raw
+              // pre-compaction transcript archive skips these mid-run events.
               const tokensAfterCompaction = estimateTotalTokens(systemPrompt, messages, toolDefsJsonForEstimate);
               latestContextTokens = tokensAfterCompaction;
               toolOutputEstimateSinceModel = 0;

package/src/orchestrator/index.ts

@@ -19,6 +19,9 @@ export {
   executeConversationTurn,
   normalizeApprovalCheckpoint,
   buildApprovalCheckpoints,
+  assembleCheckpointMessages,
+  buildToolResultMessage,
+  buildResumeCheckpoints,
   applyTurnMetadata,
   type StoredApproval,
   type PendingToolCall,

package/src/orchestrator/orchestrator.ts

@@ -10,6 +10,9 @@ import {
   applyTurnMetadata,
   normalizeApprovalCheckpoint,
   buildApprovalCheckpoints,
+  assembleCheckpointMessages,
+  buildToolResultMessage,
+  buildResumeCheckpoints,
   createTurnDraftState,
   recordStandardTurnEvent,
   type TurnDraftState,
@@ -107,6 +110,48 @@ export const abnormalEndResponse = (opts: {
   return opts.gathered ? `${head} ${recover}\n\n${opts.gathered}` : `${head} ${recover}`;
 };
 
+/**
+ * Machine-readable verdict a subagent is asked to append to its final message,
+ * e.g. `[[OUTCOME: failed]] reason`. Parsed deterministically — see
+ * SUBAGENT_OUTCOME_INSTRUCTION and `deriveTaskOutcome`.
+ */
+const SUBAGENT_OUTCOME_RE = /\[\[\s*OUTCOME\s*:\s*(succeeded|failed|partial)\s*\]\]/i;
+
+/** Appended to a subagent's task so it self-reports whether it succeeded. */
+export const SUBAGENT_OUTCOME_INSTRUCTION =
+  "\n\nAt the very end of your final message, on its own line, append a " +
+  "machine-readable outcome verdict for the task you were given: " +
+  "`[[OUTCOME: succeeded]]`, `[[OUTCOME: partial]]`, or `[[OUTCOME: failed]]`, " +
+  "followed by a one-line reason. Judge honestly by whether YOU actually " +
+  "accomplished the task (produced the real result / wrote the files), not by " +
+  "whether the run finished. If a tool or capability you needed was missing, " +
+  "that is `failed`.";
+
+/**
+ * Derive a subagent's task outcome (distinct from run status). Abnormal ends and
+ * empty output are `failed`; otherwise we parse the self-declared verdict and
+ * default to `unknown` when absent (never assume success).
+ */
+export const deriveTaskOutcome = (
+  gathered: string,
+  abnormal: boolean,
+): import("../state.js").SubagentTaskOutcome => {
+  if (abnormal) return "failed";
+  if (!gathered.trim()) return "failed";
+  const m = gathered.match(SUBAGENT_OUTCOME_RE);
+  if (!m) return "unknown";
+  const v = m[1]!.toLowerCase();
+  return v === "succeeded" ? "succeeded" : v === "partial" ? "partial" : "failed";
+};
+
+/**
+ * Remove the machine-readable `[[OUTCOME: …]]` verdict (and its one-line reason)
+ * from the text delivered to the parent — the outcome is carried structurally in
+ * the callback header/metadata, so the marker shouldn't leak into chat UI.
+ */
+export const stripOutcomeVerdict = (text: string): string =>
+  text.replace(/\n*\[\[\s*OUTCOME\s*:\s*(?:succeeded|failed|partial)\s*\]\].*$/is, "").trimEnd();
+
 // ── Types ──
 
 export type ActiveConversationRun = {
@@ -379,38 +424,11 @@ export class AgentOrchestrator {
     let latestRunId = conversation.runtimeRunId ?? "";
     let checkpointedRun = false;
 
-    const normalizedCheckpoint = normalizeApprovalCheckpoint(checkpoint, conversation.messages);
-    const baseMessages = normalizedCheckpoint.baseMessageCount != null
-      ? conversation.messages.slice(0, normalizedCheckpoint.baseMessageCount)
-      : [];
-    const fullCheckpointMessages = [...baseMessages, ...normalizedCheckpoint.checkpointMessages!];
-
-    let resumeToolResultMsg: Message | undefined;
-    const lastCpMsg = fullCheckpointMessages[fullCheckpointMessages.length - 1];
-    if (lastCpMsg?.role === "assistant") {
-      try {
-        const parsed = JSON.parse(typeof lastCpMsg.content === "string" ? lastCpMsg.content : "");
-        const cpToolCalls: Array<{ id: string; name: string }> = parsed.tool_calls ?? [];
-        if (cpToolCalls.length > 0) {
-          const providedMap = new Map(toolResults.map(r => [r.callId, r]));
-          resumeToolResultMsg = {
-            role: "tool",
-            content: JSON.stringify(cpToolCalls.map(tc => {
-              const provided = providedMap.get(tc.id);
-              return {
-                type: "tool_result",
-                tool_use_id: tc.id,
-                tool_name: provided?.toolName ?? tc.name,
-                content: provided
-                  ? (provided.error ? `Tool error: ${provided.error}` : JSON.stringify(provided.result ?? null))
-                  : "Tool error: Tool execution deferred (pending approval checkpoint)",
-              };
-            })),
-            metadata: { timestamp: Date.now() },
-          };
-        }
-      } catch { /* last message is not a parseable assistant-with-tools -- skip */ }
-    }
+    const fullCheckpointMessages = assembleCheckpointMessages(conversation, checkpoint);
+    const resumeToolResultMsg = buildToolResultMessage(
+      fullCheckpointMessages[fullCheckpointMessages.length - 1],
+      toolResults,
+    );
     const fullCheckpointWithResults = resumeToolResultMsg
       ? [...fullCheckpointMessages, resumeToolResultMsg]
       : fullCheckpointMessages;
@@ -463,12 +481,10 @@ export class AgentOrchestrator {
             };
             const conv = await this.conversationStore.get(conversationId);
             if (conv) {
-              conv.pendingApprovals = buildApprovalCheckpoints({
-                approvals: cpEvent.approvals,
+              conv.pendingApprovals = buildResumeCheckpoints({
+                priorMessages: fullCheckpointWithResults,
+                checkpointEvent: cpEvent,
                 runId: latestRunId,
-                checkpointMessages: [...fullCheckpointWithResults, ...cpEvent.checkpointMessages],
-                baseMessageCount: 0,
-                pendingToolCalls: cpEvent.pendingToolCalls,
               });
               conv.updatedAt = Date.now();
               await this.conversationStore.update(conv);
@@ -697,6 +713,7 @@ export class AgentOrchestrator {
       subagentId,
       task: conv.subagentMeta?.task ?? conv.title,
       status: "completed",
+      taskOutcome: deriveTaskOutcome(responseText, false),
       result: { status: "completed", response: responseText, steps: 0, tokens: { input: 0, output: 0, cached: 0 }, duration: 0 },
       timestamp: Date.now(),
     };
@@ -829,7 +846,11 @@ export class AgentOrchestrator {
       const recallParams = this.hooks?.buildRecallParams?.({ ownerId, tenantId: conversation.tenantId, excludeConversationId: childConversationId }) ?? {};
 
       for await (const event of childHarness.runWithTelemetry({
-        task,
+        // Ask the subagent to self-report a machine-readable task outcome at the
+        // end of its final message; `deriveTaskOutcome` parses it so a failed
+        // task can never be recorded as "completed". Appended only to the model
+        // input, not the stored/displayed task name.
+        task: `${task}${SUBAGENT_OUTCOME_INSTRUCTION}`,
         conversationId: childConversationId,
         tenantId: conversation.tenantId ?? undefined,
         parameters: withToolResultArchiveParam({
@@ -1040,13 +1061,16 @@ export class AgentOrchestrator {
       // the work — deliver what it gathered, tagged so the parent knows it
       // didn't finish, and build a result so it never renders as "(no result)".
       const abnormal = !runResult;
+      const taskOutcome = deriveTaskOutcome(gathered, abnormal);
+      const cleanedGathered = stripOutcomeVerdict(gathered);
       const subagentResponse = abnormal
-        ? abnormalEndResponse({ subagentId: childConversationId, gathered, runError })
-        : gathered;
+        ? abnormalEndResponse({ subagentId: childConversationId, gathered: cleanedGathered, runError })
+        : cleanedGathered;
       const pendingResult: PendingSubagentResult = {
         subagentId: childConversationId,
         task,
         status: abnormal ? "error" : "completed",
+        taskOutcome,
         result: {
           status: runResult?.status ?? "error",
           response: subagentResponse,
@@ -1096,6 +1120,7 @@ export class AgentOrchestrator {
         subagentId: childConversationId,
         task,
         status: "error",
+        taskOutcome: "failed",
         error: { code: "SUBAGENT_ERROR", message: errMsg },
         timestamp: Date.now(),
       };
@@ -1185,8 +1210,8 @@ export class AgentOrchestrator {
           : "(no result)";
       const injected: Message = {
         role: "user",
-        content: `[Subagent Result] Subagent "${pr.task}" (${pr.subagentId}) ${pr.status}:\n\n${resultBody}`,
-        metadata: { _subagentCallback: true, subagentId: pr.subagentId, task: pr.task, timestamp: pr.timestamp } as Message["metadata"],
+        content: `[Subagent Result] Subagent "${pr.task}" (${pr.subagentId}) ${pr.taskOutcome}:\n\n${resultBody}`,
+        metadata: { _subagentCallback: true, subagentId: pr.subagentId, task: pr.task, taskOutcome: pr.taskOutcome, timestamp: pr.timestamp } as Message["metadata"],
       };
       injectedCallbackMessages.push(injected);
       conversation.messages.push(injected);
@@ -1516,9 +1541,11 @@ export class AgentOrchestrator {
         if (freshSubConv) gathered = realResponseText(lastAssistantText(freshSubConv.messages));
       }
       const abnormal = !runResult;
+      const taskOutcome = deriveTaskOutcome(gathered, abnormal);
+      const cleanedGathered = stripOutcomeVerdict(gathered);
       const subagentResponse = abnormal
-        ? abnormalEndResponse({ subagentId: conversationId, gathered, runError })
-        : gathered;
+        ? abnormalEndResponse({ subagentId: conversationId, gathered: cleanedGathered, runError })
+        : cleanedGathered;
 
       const parentConv = await this.conversationStore.get(parentConversationId);
       if (parentConv) {
@@ -1526,6 +1553,7 @@ export class AgentOrchestrator {
           subagentId: conversationId,
           task,
           status: abnormal ? "error" : "completed",
+          taskOutcome,
           result: { status: runResult?.status ?? "error", response: subagentResponse, steps: runResult?.steps ?? 0, tokens: { input: 0, output: 0, cached: 0 }, duration: runResult?.duration ?? 0 },
           ...(abnormal
             ? { error: { code: runError?.code ?? "SUBAGENT_INCOMPLETE", message: runError?.message ?? "subagent ended without a result" } }
@@ -1576,6 +1604,7 @@ export class AgentOrchestrator {
           subagentId: conversationId,
           task,
           status: "error",
+          taskOutcome: "failed",
           error: { code: "CONTINUATION_ERROR", message: err instanceof Error ? err.message : String(err) },
           timestamp: Date.now(),
         };
@@ -1858,6 +1887,7 @@ export class AgentOrchestrator {
       subagentId: childConversationId,
       task,
       status: "error",
+      taskOutcome: "failed",
       error: { code: "SUBAGENT_SPAWN_FAILED", message },
       timestamp: Date.now(),
     });
@@ -1892,6 +1922,7 @@ export class AgentOrchestrator {
             subagentId: conv.conversationId,
             task: conv.subagentMeta.task,
             status: "error",
+            taskOutcome: "failed",
             error: conv.subagentMeta.error,
             timestamp: Date.now(),
           };

package/src/orchestrator/run-conversation-turn.ts

@@ -84,6 +84,12 @@ export interface RunConversationTurnOpts {
    * built with an OTLP exporter attached.
    */
   suppressTelemetry?: boolean;
+  /**
+   * Forwarded to `RunInput.maxSteps`: per-run step-ceiling override. Lets the
+   * foreground chat turn run a higher ceiling than background/job turns that
+   * share the same agent definition.
+   */
+  maxSteps?: number;
   /**
    * Forwarded to `RunInput.telemetryAttributes` — extra attributes for the
    * `invoke_agent` root span (e.g. run kind / job name for segmentation).
@@ -252,6 +258,7 @@ export const runConversationTurn = async (
         disablePromptCache: opts.disablePromptCache,
         suppressTelemetry: opts.suppressTelemetry,
         model: opts.model,
+        maxSteps: opts.maxSteps,
         volatileContext: opts.volatileContext,
         telemetryAttributes: opts.telemetryAttributes,
       },