@mystilleef/pi-subagent 0.10.2 → 0.12.0

package/src/child/prompt-contract.ts

@@ -1,12 +1,24 @@
 export const SUBAGENT_RESULT_CONTRACT = `
-- Always present results unchanged to the main agent.
-- End your final response with exactly one line:
-  - Outcome: <short, single, compact lower-case sentence>.
-  - Outcome summarizes the result of your task in a single sentence.
-  - The outcome line is for internal use by the agent.
-  - Don't present outcome line in the main agent's response.
-`;
+## Subagent Result Contract
+
+**MANDATORY**: Emit the task result upon completion.
+
+### Directives
 
-export function appendSubagentResultContract(prompt: string): string {
-  return `${prompt}\n\n${SUBAGENT_RESULT_CONTRACT}`;
-}
+- Write the complete task result as assistant text — mandatory, non-empty, and trimmed,
+  before calling \`complete\`.
+- Call \`complete\` as the final action after the result text; \`outcome\` must be a short,
+  one-sentence progress summary only, not the full result.
+- This contract applies after any amount of tool use, reading, editing, or multi-step work.
+
+### Constraints
+
+- **NEVER** omit the result text response.
+- **NEVER** emit whitespace-only, empty-string, or blank result text before \`complete\`.
+- **NEVER** wrap the entire result in a code block or code fence.
+- **NEVER** end the assistant response with text alone after tool calls; a terminal
+  \`complete\` call is required.
+- **NEVER** write assistant text after \`complete\`.
+- Call \`complete\` exactly once; multiple \`complete\` calls are not allowed.
+- \`outcome\` must be concise and contain only a progress summary.
+`;

package/src/child/prompt-setup.ts

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import type { AgentConfig } from "../agent/agents.js";
+import { writePromptToTempFile } from "../shared/utils.js";
+
+export type TempPrompt = { dir: string; filePath: string };
+
+export type PromptSetupResult =
+  | { tmpPrompt: TempPrompt | null }
+  | { error: unknown };
+
+export async function cleanupTempPrompt(tmpPrompt: TempPrompt): Promise<void> {
+  try {
+    await fs.promises.unlink(tmpPrompt.filePath);
+    await fs.promises.rmdir(tmpPrompt.dir);
+  } catch {
+    /* temp file cleanup failures are non-fatal; OS will clean up eventually */
+  }
+}
+
+export function beginPromptSetup(
+  agent: AgentConfig,
+): Promise<PromptSetupResult> {
+  if (!agent.systemPrompt.trim()) return Promise.resolve({ tmpPrompt: null });
+  return writePromptToTempFile(agent.name, agent.systemPrompt).then(
+    (tmpPrompt) => ({ tmpPrompt }),
+    (error: unknown) => ({ error }),
+  );
+}
+
+export async function cleanupPromptSetupResult(
+  setup: PromptSetupResult,
+): Promise<void> {
+  if ("tmpPrompt" in setup && setup.tmpPrompt) {
+    await cleanupTempPrompt(setup.tmpPrompt);
+  }
+}

package/src/child/result-builder.ts

@@ -0,0 +1,142 @@
+import type { Message } from "@earendil-works/pi-ai";
+import type { AgentConfig } from "../agent/agents.js";
+import {
+  type SingleResult,
+  TOOL_RESULT_FAILED_MESSAGE,
+} from "../shared/types.js";
+import {
+  extractFinalOutputFromMessages,
+  truncateOutput,
+} from "../shared/utils.js";
+import { resolveContextWindowTokens } from "./process-utils.js";
+
+export type RuntimeResult = SingleResult & { messages: Message[] };
+
+const EMPTY_USAGE = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  cost: 0,
+  contextTokens: 0,
+  turns: 0,
+};
+
+export function initRuntimeResult(
+  agentName: string,
+  source: "user" | "project" | "unknown",
+  task: string,
+  modelDisplay: string | undefined,
+): RuntimeResult {
+  return {
+    agent: agentName,
+    agentSource: source,
+    task,
+    exitCode: 0,
+    finalOutput: "",
+    messages: [],
+    stderr: "",
+    usage: { ...EMPTY_USAGE },
+    model: modelDisplay,
+  };
+}
+
+function accumulateUsage(result: RuntimeResult, msg: Message): void {
+  if (msg.role !== "assistant") return;
+  result.usage.turns++;
+  const { usage } = msg;
+  if (!usage) return;
+  result.usage.input += usage.input || 0;
+  result.usage.output += usage.output || 0;
+  result.usage.cacheRead += usage.cacheRead || 0;
+  result.usage.cacheWrite += usage.cacheWrite || 0;
+  result.usage.cost += usage.cost?.total || 0;
+  result.usage.contextTokens = usage.totalTokens || 0;
+  const ctxWindowTokens = resolveContextWindowTokens(msg);
+  if (ctxWindowTokens !== undefined)
+    result.usage.contextWindowTokens = ctxWindowTokens;
+}
+
+export function addMessageToResult(result: RuntimeResult, msg: Message): void {
+  result.messages.push(msg);
+  result.finalOutput = truncateOutput(
+    extractFinalOutputFromMessages(result.messages),
+  );
+  if (msg.role === "toolResult" && msg.isError) {
+    result.errorMessage ||= TOOL_RESULT_FAILED_MESSAGE;
+  } else if (result.errorMessage === TOOL_RESULT_FAILED_MESSAGE) {
+    delete result.errorMessage;
+  }
+  if (msg.role === "assistant") {
+    accumulateUsage(result, msg);
+    if (!result.model && msg.model) result.model = msg.model;
+    if (msg.stopReason) result.stopReason = msg.stopReason;
+    if (msg.errorMessage) result.errorMessage = msg.errorMessage;
+  }
+}
+
+export function rebuildResultFromMessages(
+  result: RuntimeResult,
+  messages: Message[],
+): void {
+  const { model } = result;
+  result.messages = [];
+  result.finalOutput = "";
+  result.usage = { ...EMPTY_USAGE };
+  result.model = model;
+  delete result.errorMessage;
+  delete result.stopReason;
+  for (const msg of messages) {
+    addMessageToResult(result, msg);
+  }
+}
+
+export function createErrorResult(
+  agent: string,
+  source: "user" | "project" | "unknown",
+  task: string,
+  error: string,
+  model?: string,
+): SingleResult {
+  return {
+    agent,
+    agentSource: source,
+    task,
+    exitCode: 1,
+    finalOutput: "",
+    stderr: error,
+    usage: { ...EMPTY_USAGE },
+    model,
+  };
+}
+
+export function errorForUnknownAgent(
+  agentName: string,
+  agents: AgentConfig[],
+  task: string,
+): SingleResult {
+  const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
+  return createErrorResult(
+    agentName,
+    "unknown",
+    task,
+    `Unknown agent: "${agentName}". Available agents: ${available}.`,
+  );
+}
+
+export function errorForDepthLimit(
+  agentName: string,
+  source: "user" | "project" | "unknown",
+  task: string,
+  depth: number,
+  maxDepth: number,
+  model?: string,
+): SingleResult {
+  return createErrorResult(
+    agentName,
+    source,
+    task,
+    `Subagent nesting limit reached (depth ${depth}/${maxDepth}).`,
+    model,
+  );
+}

package/src/child/sampling-extension.ts

@@ -0,0 +1,49 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  parseSamplingParams,
+  type SamplingParams,
+} from "../shared/sampling.js";
+
+function applySamplingParams(
+  target: Record<string, unknown>,
+  params: SamplingParams,
+  topPKey: "topP" | "top_p",
+): Record<string, unknown> {
+  const result: Record<string, unknown> = { ...target };
+  if (params.temperature !== undefined)
+    result["temperature"] = params.temperature;
+  if (params.topP !== undefined) result[topPKey] = params.topP;
+  return result;
+}
+
+export function patchPayload(
+  payload: Record<string, unknown>,
+  params: SamplingParams,
+): Record<string, unknown> {
+  if ("generationConfig" in payload) {
+    const origConfig =
+      payload["generationConfig"] &&
+      typeof payload["generationConfig"] === "object"
+        ? (payload["generationConfig"] as Record<string, unknown>)
+        : {};
+    return {
+      ...payload,
+      generationConfig: applySamplingParams(origConfig, params, "topP"),
+    };
+  }
+  return applySamplingParams(payload, params, "top_p");
+}
+
+export default function (pi: ExtensionAPI) {
+  const params = parseSamplingParams(process.env["PI_SAMPLING_PARAMS"]);
+  if (!params) return;
+  pi.on("before_provider_request", (event) => {
+    if (
+      !event.payload ||
+      typeof event.payload !== "object" ||
+      Array.isArray(event.payload)
+    )
+      return;
+    return patchPayload(event.payload as Record<string, unknown>, params);
+  });
+}

package/src/child/streaming-progress.ts

@@ -0,0 +1,138 @@
+import type { Message } from "@earendil-works/pi-ai";
+import { makeToolPreview, renderToolActivity } from "../progress/progress.js";
+import { SENSITIVE_PATTERN } from "../progress/progress-format.js";
+import { isToolCallPart } from "../progress/progress-state.js";
+import type {
+  OnUpdateCallback,
+  StreamingProgress,
+  SubagentDetails,
+  ToolActivity,
+} from "../shared/types.js";
+import { findLastAssistantTextMessage } from "../shared/utils.js";
+import type { RuntimeResult } from "./result-builder.js";
+
+function findRecentMessagesAnchor(messages: Message[]): number {
+  return findLastAssistantTextMessage(messages);
+}
+
+function sanitizeProgressPreview(preview: string, toolName: string): string {
+  return SENSITIVE_PATTERN.test(preview) ? toolName : preview;
+}
+
+function deriveStreamingProgress(messages: Message[]): StreamingProgress {
+  const toolCalls: { id: string; preview: string }[] = [];
+  let lastToolPreview: string | undefined;
+  let activeToolActivity: ToolActivity | undefined;
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (!isToolCallPart(part)) continue;
+      const preview = sanitizeProgressPreview(
+        makeToolPreview(part.name, part.arguments),
+        part.name,
+      );
+      toolCalls.push({ id: part.id, preview });
+      lastToolPreview = preview;
+      activeToolActivity = { toolName: part.name, inputSummary: preview };
+    }
+  }
+  const activityText = renderToolActivity(activeToolActivity);
+  return {
+    activeToolActivity,
+    activityText,
+    toolCalls,
+    lastToolPreview,
+  };
+}
+
+/**
+ * Merge incoming tool activity with existing progress activity.
+ * When tool names match, prefer richer inputSummary from incoming.
+ * Otherwise, replace entirely with incoming activity.
+ */
+function mergeToolActivity(
+  existing: ToolActivity | undefined,
+  incoming: ToolActivity,
+): ToolActivity {
+  if (existing && existing.toolName === incoming.toolName) {
+    const incomingSummary = incoming.inputSummary;
+    const preferIncoming =
+      incomingSummary && incomingSummary !== incoming.toolName;
+    return {
+      ...existing,
+      inputSummary: preferIncoming ? incomingSummary : existing.inputSummary,
+      instanceName: incoming.instanceName ?? existing.instanceName,
+      child: incoming.child ?? existing.child,
+    };
+  }
+  return incoming;
+}
+
+/**
+ * Apply tool activity and result completion updates to progress state.
+ * Handles merging of child events with parent activity tree.
+ */
+function applyActivityUpdates(
+  progress: StreamingProgress,
+  options: { toolActivity?: ToolActivity; toolResultCompleted?: boolean },
+  previousActivity?: ToolActivity,
+): void {
+  if (options.toolResultCompleted && previousActivity) {
+    progress.activeToolActivity = previousActivity;
+    const renderedText = renderToolActivity(previousActivity);
+    if (renderedText !== undefined) progress.activityText = renderedText;
+    else delete progress.activityText;
+  }
+  if (options.toolActivity) {
+    progress.activeToolActivity = mergeToolActivity(
+      progress.activeToolActivity,
+      options.toolActivity,
+    );
+    const renderedActivity = renderToolActivity(progress.activeToolActivity);
+    if (renderedActivity !== undefined)
+      progress.activityText = renderedActivity;
+    else delete progress.activityText;
+  }
+  if (options.toolResultCompleted) {
+    progress.toolResultCompleted = true;
+  }
+}
+
+export type EmitUpdateFn = (options?: {
+  toolActivity?: ToolActivity;
+  toolResultCompleted?: boolean;
+}) => void;
+
+export function makeEmitUpdate(
+  result: RuntimeResult,
+  onUpdate: OnUpdateCallback | undefined,
+  makeDetails: (
+    results: RuntimeResult[],
+    options?: { includeMessages?: boolean; recentMessages?: Message[] },
+  ) => SubagentDetails,
+): EmitUpdateFn {
+  return (options) => {
+    const msgs = result.messages;
+    const anchorIdx = findRecentMessagesAnchor(msgs);
+    const recentMessages =
+      anchorIdx >= 0 ? msgs.slice(anchorIdx) : msgs.slice(-5);
+    const progress = deriveStreamingProgress(msgs);
+    if (options) {
+      applyActivityUpdates(
+        progress,
+        options,
+        result.progress?.activeToolActivity,
+      );
+    }
+    result.progress = progress;
+    onUpdate?.({
+      content: [
+        { type: "text", text: progress.activityText ?? "(running...)" },
+      ],
+      details: makeDetails([result], {
+        includeMessages: true,
+        recentMessages,
+      }),
+    });
+  };
+}

package/src/orchestration/subagent-orchestrator.ts

@@ -11,14 +11,17 @@ import type {
   AgentScope,
   ThinkingLevel,
 } from "../agent/agents.js";
-import { runSingleAgent, SubagentAbortError } from "../child/process.js";
+import { runSingleAgent } from "../child/process.js";
 import { deliverNotification } from "../notification/delivery.js";
 import {
   buildNotificationRequest,
   isDesktopNotificationsEnabled,
   isPerJobNotificationEnabled,
 } from "../notification/desktop-notification.js";
-import { formatSubagentResultForParent } from "../output/summary.js";
+import {
+  formatSubagentFailureForParent,
+  formatSubagentResultForParent,
+} from "../output/summary.js";
 import {
   cancelProgressState,
   createProgressState,
@@ -31,7 +34,6 @@ import {
   type DetailsOptions,
   getFeedbackSummaryText,
   getLatestResult,
-  getResultDisplayText,
   patchProgressFromDetails,
   sanitizeDetailsForDisplay,
   sanitizeResultDetails,
@@ -198,9 +200,7 @@ function finishLifecycleFailure(
   failProgressState(lc.requestId, errorMessage);
   lc.ctx.ui?.notify(errorMessage, "error");
   const latestResult = getLatestResult(details);
-  const content = latestResult
-    ? formatSubagentResultForParent(latestResult) || "(failed)"
-    : errorMessage;
+  const content = formatSubagentFailureForParent(errorMessage, latestResult);
   sendSubagentResultMessage(lc.pi, content, displayDetails);
   return createCompletedToolResult(content, displayDetails);
 }
@@ -220,12 +220,12 @@ function finishLifecycleResult(
   const displayDetails = sanitizeDetailsForDisplay(details, lc.debug);
   const content = formatSubagentResultForParent(result) || "(no output)";
   const toolResult = createCompletedToolResult(content, displayDetails);
-  finalizeProgressState(lc.requestId, getFeedbackSummaryText(toolResult));
-  sendSubagentResultMessage(
-    lc.pi,
-    getResultDisplayText(toolResult),
-    displayDetails,
+  finalizeProgressState(
+    lc.requestId,
+    getFeedbackSummaryText(toolResult),
+    result.outcome,
   );
+  sendSubagentResultMessage(lc.pi, content, displayDetails);
   return toolResult;
 }
 
@@ -277,7 +277,7 @@ async function runSubagentLifecycle(
   };
   const timerTick = setInterval(requestProgressRender, 500);
   try {
-    const result = await runSingleAgent(
+    const outcome = await runSingleAgent(
       lc.ctx.cwd,
       lc.agents,
       lc.agentName,
@@ -289,14 +289,18 @@ async function runSubagentLifecycle(
       lc.parentThinking,
       lc.debug,
     );
-    return finishLifecycleResult(lc, result);
+    if (outcome.kind === "aborted") {
+      const details = lc.makeDetails([outcome.result]);
+      const cancelReason =
+        outcome.result.termination?.cancelReason ?? "Aborted";
+      return finishLifecycleFailure(lc, cancelReason, details);
+    }
+    return finishLifecycleResult(lc, outcome.result);
   } catch (error) {
-    const abortResult =
-      error instanceof SubagentAbortError ? error.result : undefined;
     return finishLifecycleFailure(
       lc,
       error instanceof Error ? error.message : String(error),
-      abortResult ? lc.makeDetails([abortResult]) : lc.makeDetails([]),
+      lc.makeDetails([]),
     );
   } finally {
     clearInterval(timerTick);

package/src/output/normalize.ts

@@ -58,7 +58,7 @@ export function normalizeTerminalSentence(
     "",
   );
   const withoutLabel = withoutStatusPrefix.replace(
-    /^\s*(?:status|summary|result|output|message|error|check|outcome|project summary):\s+/i,
+    /^\s*(?:status|summary|result|output|message|error|check|project summary):\s+/i,
     "",
   );
   const normalizedOnce = normalizeSummaryValue(withoutLabel);

package/src/output/summary.ts

@@ -17,7 +17,7 @@ const FEEDBACK_UI_GENERIC_CANDIDATES = new Set([
 ]);
 
 const FEEDBACK_UI_LABEL_PATTERN =
-  /^\s*(outcome|project summary|result|summary|status|output|message|error|check):\s*/i;
+  /^\s*(project summary|result|summary|status|output|message|error|check):\s*/i;
 
 export function formatSubagentResultForParent(result: SingleResult): string {
   return result.thinkingWarning
@@ -25,15 +25,31 @@ export function formatSubagentResultForParent(result: SingleResult): string {
     : result.finalOutput;
 }
 
-export function summarizeFeedbackUiFinalOutput(finalOutput: string): string {
+export function formatSubagentFailureForParent(
+  errorMessage: string,
+  result?: SingleResult,
+): string {
+  if (!result) return errorMessage;
+  const formatted = formatSubagentResultForParent(result);
+  if (!formatted.trim()) return `(failed) ${errorMessage}`;
+  return `(failed) ${errorMessage}\n\n${formatted}`;
+}
+
+export function summarizeFeedbackUiFinalOutput(
+  finalOutput: string,
+  outcome?: string,
+): string {
+  if (outcome?.trim()) {
+    return normalizeTerminalSentence(
+      outcome,
+      FEEDBACK_UI_SUMMARY_MAX_CHARS,
+    ).toLowerCase();
+  }
   const candidates = finalOutput
     .split(/\r?\n|(?<=[.!?])\s+/)
     .map((candidate) => normalizeFeedbackUiSummaryCandidate(candidate))
     .filter(({ text }) => hasSummaryValue(text));
-  const selected =
-    candidates.find(({ label }) => label === "outcome") ??
-    candidates.find(({ label }) => label) ??
-    candidates[0];
+  const selected = candidates.find(({ label }) => label) ?? candidates[0];
   return (selected?.text ?? "completed task").toLowerCase();
 }
 

package/src/output/ui.ts

@@ -1,4 +1,3 @@
-import type { Message } from "@earendil-works/pi-ai";
 import type { ThemeColor } from "@earendil-works/pi-coding-agent";
 import {
   Box,
@@ -130,19 +129,7 @@ export function formatToolCall(
   return themeFg("accent", toolName) + themeFg("dim", ` ${target}`);
 }
 
-export function getFinalOutput(messages: Message[]): string {
-  const lastAsst = messages.findLast((m) => m.role === "assistant");
-  const lastText = lastAsst?.content.findLast((p) => p.type === "text");
-  return lastText?.type === "text" ? lastText.text : "";
-}
-
-/**
- * Removes the "Outcome:" line from subagent output to avoid redundancy in result cards.
- */
-function stripOutcomeLineForResultUi(output: string): string {
-  const stripped = output.replace(/^\s*Outcome:[^\r\n]*(?:\r?\n|$)/gim, "");
-  return stripped.trim() ? stripped : output;
-}
+export { extractFinalOutputFromMessages as getFinalOutput } from "../shared/utils.js";
 
 function makeMarkdownTheme(theme: SubagentTheme): MarkdownTheme {
   const fg = (c: ThemeColor) => (text: string) => theme.fg(c, text);
@@ -191,7 +178,7 @@ export function renderSubagentToolResult(
   return renderSubagentResult(result, theme, display);
 }
 
-// Invariants: Red background = failure, green = success. Trims redundant "Outcome:" lines. Shows usage stats + duration in footer.
+// Invariants: Red background = failure, green = success. Shows usage stats + duration in footer.
 export function renderSubagentResult(
   result: { content: { type: string; text?: string }[]; details?: unknown },
   theme: SubagentTheme,
@@ -215,7 +202,7 @@ export function renderSubagentResult(
     : failed
       ? "error"
       : "success";
-  const finalOutput = r.finalOutput ?? getFinalOutput(r.messages ?? []);
+  const finalOutput = r.finalOutput ?? "";
   const title = formatSubagentTitle(r.agent, r.instanceName, theme);
   let effectiveBody = bodyOverride ?? finalOutput;
   if (display?.isPartial && !finalOutput?.trim() && !bodyOverride) {
@@ -225,14 +212,17 @@ export function renderSubagentResult(
       r.progress?.lastToolPreview ||
       "(running...)";
   }
-  const bodyText = stripOutcomeLineForResultUi(effectiveBody);
+  const bodyText = effectiveBody.trim();
   const toolCount = r.progress?.toolCalls?.length ?? 0;
-  const toolLabel = `${toolCount} ${toolCount === 1 ? "tool" : "tools"}`;
   const ctxPercent = formatContextPercent({
     contextTokens: r.usage.contextTokens,
     contextWindowTokens: r.usage.contextWindowTokens,
   });
-  const metadata = `${toolLabel} · ${ctxPercent} ctx · ${formatElapsed(r.durationMs ?? 0)}`;
+  const metadata = formatProgressMetadata(
+    toolCount,
+    ctxPercent,
+    formatElapsed(r.durationMs ?? 0),
+  );
   const usageStr = formatResultFooter(r.usage, r.model);
   return renderStatusCard(
     {
@@ -310,6 +300,15 @@ function selectRunsBoardBody(state: SubagentProgressState): string {
   );
 }
 
+function formatProgressMetadata(
+  toolCount: number,
+  ctxPercent: string,
+  elapsed: string,
+): string {
+  const toolLabel = toolCount === 1 ? "tool" : "tools";
+  return `${toolCount} ${toolLabel} · ${ctxPercent} ctx · ${elapsed}`;
+}
+
 function renderJobCard(
   state: SubagentProgressState,
   theme: SubagentTheme,
@@ -319,8 +318,7 @@ function renderJobCard(
     state.durationMs ?? Date.now() - state.startTime,
   );
   const ctxPercent = formatContextPercent(state);
-  const toolLabel = state.toolCount === 1 ? "tool" : "tools";
-  const metadata = `${state.toolCount} ${toolLabel} · ${ctxPercent} ctx · ${elapsed}`;
+  const metadata = formatProgressMetadata(state.toolCount, ctxPercent, elapsed);
   const bodyText = selectRunsBoardBody(state);
   const preview =
     bodyText.length > BODY_PREVIEW_MAX

package/src/progress/progress-state.ts

@@ -7,6 +7,7 @@ import {
   normalizeSummaryValue,
   normalizeTerminalSentence,
 } from "../output/normalize.js";
+import { summarizeFeedbackUiFinalOutput } from "../output/summary.js";
 import type {
   SingleResult,
   SubagentDetails,
@@ -133,10 +134,11 @@ function storeTerminalProgressState(
 export function finalizeProgressState(
   requestId: string,
   finalOutput: string,
+  outcome?: string,
 ): void {
   storeTerminalProgressState(requestId, {
     status: "success",
-    finalOutput: makeProgressFinalOutput(finalOutput),
+    finalOutput: makeProgressFinalOutput(finalOutput, outcome),
   });
 }
 
@@ -167,17 +169,13 @@ export function makeTaskPreview(task: string): string {
   return flat || "(agent default)";
 }
 
-function makeProgressFinalOutput(finalOutput: string): string {
-  const lines = finalOutput
-    .split(/\r?\n/)
-    .map((l) => l.trim())
-    .filter(Boolean);
-  const outcomeLine = lines.find((line) => /^Outcome:\s*/i.test(line));
-  const selected = outcomeLine ?? lines[0] ?? "";
-  const normalized = normalizeTerminalSentence(selected);
-  if (!normalized) return "";
-  if (isStatusOnlySuccess(normalized)) return "completed task";
-  return normalized;
+function makeProgressFinalOutput(
+  finalOutput: string,
+  outcome?: string,
+): string {
+  const summary = summarizeFeedbackUiFinalOutput(finalOutput, outcome);
+  if (isStatusOnlySuccess(summary)) return "completed task";
+  return summary;
 }
 
 function deriveFailureTerminalSentence(errorText: string): string {