@gajae-code/coding-agent 0.5.0 → 0.5.2

package/src/skill-state/workflow-hud.ts

@@ -21,6 +21,8 @@ interface RalplanHudState extends WorkflowGateHudState {
 	stage?: string;
 	waiting?: string;
 	iteration?: number;
+	iterationFromIndex?: number;
+	stages?: string;
 	verdict?: string;
 	latestSummary?: string;
 	pendingApproval?: boolean;
@@ -100,6 +102,95 @@ export function buildDeepInterviewHudSummary(state: DeepInterviewHudState): Work
 	};
 }
 
+export interface DeepInterviewHudDeriveOptions {
+	phase?: string;
+	specStatus?: string;
+	updatedAt?: string;
+}
+
+function diIsPlainObject(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function latestScoredAmbiguity(rounds: unknown): number | undefined {
+	if (!Array.isArray(rounds)) return undefined;
+	for (let index = rounds.length - 1; index >= 0; index--) {
+		const round = rounds[index];
+		if (diIsPlainObject(round) && round.lifecycle === "scored" && typeof round.ambiguity === "number") {
+			return round.ambiguity;
+		}
+	}
+	return undefined;
+}
+
+function weakestDimensionFromTopology(
+	topology: Record<string, unknown>,
+	targetComponent: string | undefined,
+): string | undefined {
+	if (!Array.isArray(topology.components)) return undefined;
+	const components = topology.components.filter(diIsPlainObject);
+	const dimensionOf = (component: Record<string, unknown>): string | undefined =>
+		typeof component.weakest_dimension === "string" && component.weakest_dimension.trim()
+			? component.weakest_dimension
+			: undefined;
+	if (targetComponent) {
+		const targeted = components.find(component => component.id === targetComponent && dimensionOf(component));
+		if (targeted) return dimensionOf(targeted);
+	}
+	const active = components.find(component => component.status !== "deferred" && dimensionOf(component));
+	if (active) return dimensionOf(active);
+	const any = components.find(component => dimensionOf(component));
+	return any ? dimensionOf(any) : undefined;
+}
+
+/**
+ * Single source of deep-interview HUD derivation. Reads a complete (normalized)
+ * mode-state envelope so recorder, `gjc state write`, reconcile, seed, and handoff
+ * all produce identical chips. Topology-aware `target`/`weakest` come from
+ * `state.topology`; `legacy_missing` topology omits those chips (no synthetic values).
+ */
+export function deriveDeepInterviewHud(
+	payload: Record<string, unknown>,
+	options: DeepInterviewHudDeriveOptions = {},
+): WorkflowHudSummary {
+	const stateField = diIsPlainObject(payload.state) ? payload.state : {};
+	const isNumber = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
+	const isArray = (value: unknown): value is unknown[] => Array.isArray(value);
+	const pick = <T>(key: string, guard: (value: unknown) => value is T): T | undefined => {
+		const value = stateField[key] ?? payload[key];
+		return guard(value) ? value : undefined;
+	};
+
+	const phase = options.phase ?? (typeof payload.current_phase === "string" ? payload.current_phase : undefined);
+	const rounds = pick("rounds", isArray);
+	const ambiguity = pick("current_ambiguity", isNumber) ?? latestScoredAmbiguity(rounds);
+	const threshold = pick("threshold", isNumber);
+	const rawTopology = diIsPlainObject(stateField.topology)
+		? stateField.topology
+		: diIsPlainObject(payload.topology)
+			? payload.topology
+			: undefined;
+	// `legacy_missing` topology was never confirmed: omit target/weakest even if stale fields linger.
+	const topology = rawTopology && rawTopology.status !== "legacy_missing" ? rawTopology : undefined;
+	const targetComponent =
+		topology && typeof topology.last_targeted_component_id === "string"
+			? topology.last_targeted_component_id
+			: undefined;
+	const weakestDimension = topology ? weakestDimensionFromTopology(topology, targetComponent) : undefined;
+	const specStatus = options.specStatus ?? (typeof payload.spec_status === "string" ? payload.spec_status : undefined);
+
+	return buildDeepInterviewHudSummary({
+		phase,
+		ambiguity,
+		threshold,
+		roundCount: rounds?.length,
+		targetComponent,
+		weakestDimension,
+		specStatus,
+		updatedAt: options.updatedAt ?? new Date().toISOString(),
+	});
+}
+
 export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary {
 	const verdict = state.verdict?.toUpperCase();
 	const verdictSeverity =
@@ -118,7 +209,14 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 			...gateChips(state, 6),
 			chip("stage", state.stage, 10),
 			chip("waiting", state.waiting, 20),
-			chip("iter", state.iteration === undefined ? undefined : String(state.iteration), 30),
+			chip(
+				"iter",
+				(state.iterationFromIndex ?? state.iteration) === undefined
+					? undefined
+					: String(state.iterationFromIndex ?? state.iteration),
+				30,
+			),
+			chip("stages", state.stages, 35),
 			chip("verdict", verdict, 40, verdictSeverity),
 		]),
 		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
@@ -136,17 +234,15 @@ export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudS
 			chip("goals", `${complete}/${total}`, 10),
 			chip("current", state.currentGoal ? `${state.currentGoal.id}:${state.currentGoal.title}` : state.status, 20),
 			chip("status", state.status, 30, state.status === "complete" ? "success" : undefined),
+			chip(
+				"ledger",
+				state.latestLedgerEvent?.event
+					? [state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":")
+					: undefined,
+				35,
+			),
 			...gateChips(state, 40),
 		]),
-		details: state.latestLedgerEvent
-			? compactChips([
-					chip(
-						"ledger",
-						[state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":"),
-						100,
-					),
-				])
-			: undefined,
 		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
 	};
 }

package/src/slash-commands/builtin-registry.ts

@@ -4,6 +4,7 @@ import type { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, modelsAreEqual } from "@gajae-code/ai";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import { setProjectDir } from "@gajae-code/utils";
+import { jobElapsedMs } from "../async";
 import {
 	GJC_MODEL_ASSIGNMENT_TARGET_IDS,
 	GJC_MODEL_ASSIGNMENT_TARGETS,
@@ -506,14 +507,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			if (snapshot.running.length > 0) {
 				lines.push("", "Running Jobs");
 				for (const job of snapshot.running) {
-					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(now - job.startTime)}`);
+					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(jobElapsedMs(job, now))}`);
 					lines.push(`    ${job.label}`);
 				}
 			}
 			if (snapshot.recent.length > 0) {
 				lines.push("", "Recent Jobs");
 				for (const job of snapshot.recent) {
-					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(now - job.startTime)}`);
+					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(jobElapsedMs(job, now))}`);
 					lines.push(`    ${job.label}`);
 				}
 			}

package/src/task/executor.ts

@@ -482,11 +482,17 @@ function getUsageTokens(usage: unknown): number {
 	return firstNumberField(record, ["totalTokens", "total_tokens"]) ?? 0;
 }
 
-function createSubagentSettings(baseSettings: Settings): Settings {
+export function createSubagentSettings(baseSettings: Settings): Settings {
 	const snapshot: Partial<Record<SettingPath, unknown>> = {};
 	for (const key of Object.keys(SETTINGS_SCHEMA) as SettingPath[]) {
 		snapshot[key] = baseSettings.get(key);
 	}
+	// Subagent-scoped service-tier override: "inherit" keeps the snapshotted main
+	// session tier; any explicit value applies only to subagent sessions.
+	const taskServiceTier = baseSettings.get("task.serviceTier");
+	if (taskServiceTier !== "inherit") {
+		snapshot.serviceTier = taskServiceTier;
+	}
 	return Settings.isolated({
 		...snapshot,
 		"async.enabled": false,
@@ -1154,6 +1160,15 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					resolvedModel: model.id,
 				});
 			}
+			// Record which model the subagent actually runs on (and any auth fallback,
+			// see #985) so the subagent panel can surface it to the user.
+			if (model) {
+				AsyncJobManager.instance()?.updateSubagentModel?.(options.subagentId ?? id, {
+					requestedModel: modelSubstitutionWarning?.requested ?? resolvedModelString,
+					effectiveModel: resolvedModelString,
+					modelFellBack: authFallbackUsed === true,
+				});
+			}
 			if (model?.contextWindow && model.contextWindow > 0) {
 				progress.contextWindow = model.contextWindow;
 			}

package/src/task/render.ts

@@ -525,6 +525,10 @@ function renderAgentProgress(
 	expanded: boolean,
 	theme: Theme,
 	spinnerFrame?: number,
+	/** When true, omit wall-clock-derived displays (current-tool elapsed, retry
+	 * countdown) so the output is a pure function of `progress` — required when the
+	 * caller caches these lines (the `subagent` await panel). */
+	staticTime = false,
 ): string[] {
 	const lines: string[] = [];
 	const prefix = isLast ? theme.fg("dim", theme.tree.last) : theme.fg("dim", theme.tree.branch);
@@ -587,7 +591,7 @@ function renderAgentProgress(
 			if (toolDetail) {
 				toolLine += `: ${theme.fg("dim", truncateToWidth(replaceTabs(toolDetail), 40))}`;
 			}
-			if (progress.currentToolStartMs) {
+			if (!staticTime && progress.currentToolStartMs) {
 				const elapsed = Date.now() - progress.currentToolStartMs;
 				if (elapsed > 5000) {
 					toolLine += `${theme.sep.dot}${theme.fg("warning", formatDuration(elapsed))}`;
@@ -610,12 +614,17 @@ function renderAgentProgress(
 	// long until the next attempt. Without this, the parent UI would just
 	// keep spinning while a child sleeps on a 3-hour provider rate-limit.
 	if (progress.retryState && progress.status === "running") {
-		const remainingMs = Math.max(0, progress.retryState.startedAtMs + progress.retryState.delayMs - Date.now());
-		const waitLabel = remainingMs > 0 ? `in ${formatDuration(remainingMs)}` : "now";
 		const attemptLabel = progress.retryState.unbounded
 			? `attempt ${progress.retryState.attempt}`
 			: `${progress.retryState.attempt}/${progress.retryState.maxAttempts}`;
-		const summary = `retrying ${attemptLabel} ${waitLabel}: ${truncateToWidth(replaceTabs(progress.retryState.errorMessage), 60)}`;
+		// `staticTime` omits the wall-clock countdown so a cached await body stays a
+		// pure function of its key (the producer already drops time-only churn).
+		let waitLabel = "";
+		if (!staticTime) {
+			const remainingMs = Math.max(0, progress.retryState.startedAtMs + progress.retryState.delayMs - Date.now());
+			waitLabel = remainingMs > 0 ? ` in ${formatDuration(remainingMs)}` : " now";
+		}
+		const summary = `retrying ${attemptLabel}${waitLabel}: ${truncateToWidth(replaceTabs(progress.retryState.errorMessage), 60)}`;
 		lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("warning", summary)}`);
 	} else if (progress.retryFailure && progress.status !== "running") {
 		const summary = `auto-retry gave up after ${progress.retryFailure.attempt} attempt${
@@ -687,7 +696,7 @@ function renderAgentProgress(
 	const inflight = progress.inflightTaskDetails;
 	if (completedTaskCalls.length > 0 || inflight) {
 		const snapshots = inflight ? [...completedTaskCalls, inflight] : completedTaskCalls;
-		const nestedLines = renderNestedTaskTree(snapshots, expanded, theme, spinnerFrame);
+		const nestedLines = renderNestedTaskTree(snapshots, expanded, theme, spinnerFrame, staticTime);
 		for (const line of nestedLines) {
 			lines.push(`${continuePrefix}${line}`);
 		}
@@ -712,8 +721,9 @@ export function renderSubagentLiveProgress(
 	expanded: boolean,
 	theme: Theme,
 	spinnerFrame?: number,
+	staticTime = false,
 ): string[] {
-	return renderAgentProgress(progress, true, expanded, theme, spinnerFrame);
+	return renderAgentProgress(progress, true, expanded, theme, spinnerFrame, staticTime);
 }
 
 /**
@@ -1051,6 +1061,7 @@ function renderNestedTaskTree(
 	expanded: boolean,
 	theme: Theme,
 	spinnerFrame?: number,
+	staticTime = false,
 ): string[] {
 	const lines: string[] = [];
 	for (const details of detailsList) {
@@ -1066,7 +1077,7 @@ function renderNestedTaskTree(
 		if (inflight && inflight.length > 0) {
 			inflight.forEach((prog, index) => {
 				const isLast = index === inflight.length - 1;
-				lines.push(...renderAgentProgress(prog, isLast, expanded, theme, spinnerFrame));
+				lines.push(...renderAgentProgress(prog, isLast, expanded, theme, spinnerFrame, staticTime));
 			});
 		}
 	}

package/src/tools/ask.ts

@@ -26,7 +26,7 @@ import {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@gajae-code/tui";
-import { prompt, untilAborted } from "@gajae-code/utils";
+import { logger, prompt, untilAborted } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import {
 	formatDeepInterviewSelectorPrompt,
@@ -34,6 +34,8 @@ import {
 	renderDeepInterviewAskQuestion,
 } from "../deep-interview/render-middleware";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { appendOrMergeDeepInterviewRound } from "../gjc-runtime/deep-interview-recorder";
+import { deepInterviewStatePath } from "../gjc-runtime/deep-interview-runtime";
 import { gateAnswerToResult, questionToGate } from "../modes/shared/agent-wire/deep-interview-gate";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
@@ -41,6 +43,7 @@ import { renderStatusLine } from "../tui";
 import type { ToolSession } from ".";
 import { formatErrorMessage, formatMeta, formatTitle } from "./render-utils";
 import { ToolAbortError } from "./tool-errors";
+import { assertUltragoalAskAllowed } from "./ultragoal-ask-guard";
 
 // =============================================================================
 // Types
@@ -50,15 +53,25 @@ const OptionItem = z.object({
 	label: z.string().describe("display label"),
 });
 
+/** Optional structured deep-interview round metadata; when present the round is recorded automatically. */
+const DeepInterviewMeta = z.object({
+	round_id: z.string().describe("stable optional round identity").optional(),
+	round: z.number().int().nonnegative().describe("round number"),
+	component: z.string().min(1).describe("targeted topology component"),
+	dimension: z.string().min(1).describe("targeted clarity dimension"),
+	ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
+});
+
 const QuestionItem = z.object({
 	id: z.string().describe("question id"),
 	question: z.string().describe("question text"),
 	options: z.array(OptionItem).describe("available options"),
 	multi: z.boolean().describe("allow multiple selections").optional(),
 	recommended: z.number().describe("recommended option index").optional(),
+	deepInterview: DeepInterviewMeta.describe("optional deep-interview round metadata").optional(),
 });
 
-const askSchema = z.object({
+export const askSchema = z.object({
 	questions: z.array(QuestionItem).min(1).describe("questions to ask"),
 });
 
@@ -456,6 +469,45 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		TERMINAL.sendNotification("Waiting for input");
 	}
 
+	/**
+	 * Record a resolved deep-interview round when the question carries structured
+	 * metadata. The runtime owns durable record/merge semantics; this tool is only the
+	 * caller. Best-effort: a state-write hiccup must not break the user's answer flow.
+	 */
+	async #recordDeepInterviewRound(
+		q: AskParams["questions"][number],
+		selectedOptions: string[],
+		customInput: string | undefined,
+	): Promise<void> {
+		const meta = q.deepInterview;
+		if (!meta) return;
+		try {
+			const cwd = this.session.cwd;
+			const sessionId = this.session.getSessionId?.() ?? undefined;
+			const statePath = deepInterviewStatePath(cwd, sessionId);
+			await appendOrMergeDeepInterviewRound(
+				cwd,
+				statePath,
+				{
+					round: meta.round,
+					round_id: meta.round_id,
+					questionId: q.id,
+					questionText: q.question,
+					component: meta.component,
+					dimension: meta.dimension,
+					ambiguity: meta.ambiguity,
+					selectedOptions,
+					customInput,
+				},
+				{ sessionId },
+			);
+		} catch (error) {
+			logger.warn(
+				`ask: deep-interview round recording failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: AskParams,
@@ -463,6 +515,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<AskToolDetails>> {
+		await assertUltragoalAskAllowed(this.session.cwd);
 		const gateEmitter = this.session.getWorkflowGateEmitter?.();
 		const canUseWorkflowGate = gateEmitter?.isUnattended() === true;
 
@@ -515,6 +568,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					options: q.options,
 					multi: q.multi,
 					recommended: q.recommended,
+					deepInterview: q.deepInterview,
 				};
 				const answer = await gateEmitter.emitGate(questionToGate(gateQuestion));
 				const decoded = gateAnswerToResult(gateQuestion, answer);
@@ -582,6 +636,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 				context?.abort();
 				throw new ToolAbortError("Ask tool was cancelled by the user");
 			}
+			await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
 			const details: AskToolDetails = {
 				question: q.question,
 				options: optionLabels,
@@ -644,6 +699,8 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 				customInput,
 			};
 
+			await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
+
 			if (navAction === "back") {
 				questionIndex = Math.max(0, questionIndex - 1);
 				continue;

package/src/tools/cron.ts

@@ -391,7 +391,7 @@ export function calculateCronFireTimeMs(params: {
 }
 
 function setCronTimeout(callback: () => void, delayMs: number): CronTimerHandle {
-	let handle: ReturnType<typeof setTimeout> | undefined;
+	let handle: NodeJS.Timeout | undefined;
 	let cleared = false;
 	const schedule = (remainingMs: number) => {
 		if (cleared) return;

package/src/tools/job.ts

@@ -3,7 +3,7 @@ import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
 import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
-import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
+import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled, jobElapsedMs } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import jobDescription from "../prompts/tools/job.md" with { type: "text" };
@@ -257,6 +257,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			status: string;
 			label: string;
 			startTime: number;
+			endTime?: number;
 			resultText?: string;
 			errorText?: string;
 		}[],
@@ -270,7 +271,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 				type: latest.type,
 				status: latest.status as JobSnapshot["status"],
 				label: latest.label,
-				durationMs: Math.max(0, now - latest.startTime),
+				durationMs: jobElapsedMs(latest, now),
 				...(latest.resultText ? { resultText: latest.resultText } : {}),
 				...(latest.errorText ? { errorText: latest.errorText } : {}),
 			};

package/src/tools/monitor.ts

@@ -3,6 +3,7 @@ import { logger, prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
 import monitorDescription from "../prompts/tools/monitor.md" with { type: "text" };
+import { truncateTail } from "../session/streaming-output";
 import { BashTool } from "./bash";
 import type { ToolSession } from "./index";
 import { ToolError } from "./tool-errors";
@@ -48,6 +49,8 @@ export interface MonitorToolDetails {
 
 const MONITOR_LABEL_MAX = 120;
 const MAX_PENDING_MONITOR_NOTIFICATIONS = 3;
+const MONITOR_NOTIFICATION_LINE_MAX_BYTES = 16 * 1024;
+const MONITOR_NOTIFICATION_LINE_MAX_LINES = 20;
 
 function buildMonitorLabel(params: MonitorParams): string {
 	const base = `[monitor:${params.kind}] ${params.description}`;
@@ -55,6 +58,34 @@ function buildMonitorLabel(params: MonitorParams): string {
 	return `${base.slice(0, MONITOR_LABEL_MAX - 3)}...`;
 }
 
+function formatMonitorNotificationLine(line: string): {
+	content: string;
+	truncated: boolean;
+	totalBytes: number;
+	outputBytes: number;
+} {
+	const truncation = truncateTail(line, {
+		maxBytes: MONITOR_NOTIFICATION_LINE_MAX_BYTES,
+		maxLines: MONITOR_NOTIFICATION_LINE_MAX_LINES,
+	});
+	const outputBytes = truncation.outputBytes ?? truncation.totalBytes;
+	if (!truncation.truncated) {
+		return {
+			content: truncation.content,
+			truncated: false,
+			totalBytes: truncation.totalBytes,
+			outputBytes,
+		};
+	}
+	const notice = `[Monitor output truncated: showing last ${outputBytes} of ${truncation.totalBytes} bytes]`;
+	return {
+		content: `${truncation.content}\n${notice}`,
+		truncated: true,
+		totalBytes: truncation.totalBytes,
+		outputBytes,
+	};
+}
+
 export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolDetails> {
 	readonly name = "monitor";
 	readonly label = "Monitor";
@@ -130,7 +161,8 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 			if (controller.closed) return;
 			const notificationId = `${jobId}:${sequence}`;
 			const suffix = count > 0 ? `\n(+${count} earlier lines)` : "";
-			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${line}${suffix}\n</task-notification>`;
+			const notificationLine = formatMonitorNotificationLine(line);
+			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${notificationLine.content}${suffix}\n</task-notification>`;
 			const details = {
 				taskId: jobId,
 				kind: params.kind,
@@ -139,6 +171,9 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 				notificationId,
 				sequence,
 				coalescedCount: count,
+				outputTruncated: notificationLine.truncated,
+				outputTotalBytes: notificationLine.totalBytes,
+				outputBytes: notificationLine.outputBytes,
 			};
 			pendingNotifications += 1;
 			if (pendingNotifications > MAX_PENDING_MONITOR_NOTIFICATIONS) {