@mystilleef/pi-subagent 0.7.0 → 0.9.0

package/src/child/process.ts

@@ -32,12 +32,14 @@ import {
   detectMessageError,
   getPiInvocation,
   getSubagentDepth,
+  getSubagentRuntimeLimits,
   resolveAgentSkillArgs,
   subagentDepthEnv,
   truncateOutput,
   writePromptToTempFile,
 } from "../shared/utils.js";
 import {
+  type ChildEventParseResult,
   type ChildKnownEvent,
   parseChildEventLine,
   TOOL_EXECUTION_UPDATE_EVENT,
@@ -48,8 +50,6 @@ import {
   terminateChildProcess,
 } from "./termination.js";
 
-const MAX_STDERR_BYTES = 10_000;
-const AGENT_END_GRACE_MS = 250;
 export function resolveThinkingLevel(
   requested: ThinkingLevel,
   provider: string,
@@ -73,15 +73,17 @@ export function resolveThinkingLevel(
   return { level: clamped, warning: mkWarning(clamped) };
 }
 
-const MAX_SUBAGENT_DEPTH = 2;
 export const TOOL_RESULT_FAILED_MESSAGE = "Subagent tool result failed.";
 
+type RuntimeLimits = ReturnType<typeof getSubagentRuntimeLimits>;
 type RuntimeResult = SingleResult & { messages: Message[] };
 
 export class SubagentAbortError extends Error {
-  constructor(public readonly result: SingleResult) {
+  readonly result: SingleResult;
+  constructor(result: SingleResult) {
     super("Subagent was aborted");
     this.name = "SubagentAbortError";
+    this.result = result;
   }
 }
 
@@ -91,6 +93,7 @@ type PromptSetupResult = { tmpPrompt: TempPrompt | null } | { error: unknown };
 
 interface SubagentState {
   result: RuntimeResult;
+  runtimeLimits: RuntimeLimits;
   spawnError?: Error;
   wasAborted: boolean;
   agentEndGraceTimer?: ReturnType<typeof setTimeout>;
@@ -99,25 +102,41 @@ interface SubagentState {
 
 function appendWithByteLimit(
   current: string,
-  data: string,
+  data: string | Buffer,
   max: number,
 ): string {
-  if (current.length >= max) return current;
-  return current + data.slice(0, max - current.length);
+  const currentBytes = Buffer.from(current, "utf-8");
+  if (currentBytes.length >= max) return current;
+  const incomingBytes = Buffer.isBuffer(data)
+    ? data
+    : Buffer.from(data, "utf-8");
+  const combined = Buffer.concat([currentBytes, incomingBytes]);
+  if (combined.length <= max) return combined.toString("utf-8");
+  return truncateValidUtf8(combined, max);
+}
+
+function truncateValidUtf8(buffer: Buffer, max: number): string {
+  let end = Math.min(max, buffer.length);
+  while (end > 0) {
+    const candidate = buffer.subarray(0, end).toString("utf-8");
+    if (!candidate.endsWith("�")) return candidate;
+    end -= 1;
+  }
+  return "";
 }
 
 /**
- * Attempts to resolve the context window token limit for a given message's model.
  * Rationale: Subagent usage reporting needs context window awareness to provide
  * meaningful "context full" indicators to the parent.
  */
 function resolveContextWindowTokens(msg: Message): number | undefined {
   const m = msg as unknown as Record<string, unknown>;
-  if (typeof m.provider !== "string" || typeof m.model !== "string") return;
+  if (typeof m["provider"] !== "string" || typeof m["model"] !== "string")
+    return;
   try {
     const contextWindow = getModel(
-      m.provider as never,
-      m.model as never,
+      m["provider"] as never,
+      m["model"] as never,
     )?.contextWindow;
     return Number.isFinite(contextWindow) && contextWindow > 0
       ? contextWindow
@@ -134,11 +153,6 @@ function getAbortReason(signal: AbortSignal): string {
   return "abort";
 }
 
-/**
- * Verifies if the agent produced any textual output or final response.
- * Precondition: Called after process exit to distinguish between clean completion
- * and silent failures where the process exited 0 but did nothing.
- */
 function hasCompletedAgentOutput(result: RuntimeResult): boolean {
   if (result.finalOutput.trim()) return true;
   return result.messages.some(
@@ -151,7 +165,6 @@ function hasCompletedAgentOutput(result: RuntimeResult): boolean {
 }
 
 /**
- * Determines the exit code for processes terminated via the agent_end timeout.
  * Rationale: `pi` processes in JSON mode might hang after finishing their task;
  * we force-kill them after a grace period and treat it as success (0) if they
  * actually produced output.
@@ -168,7 +181,6 @@ function getAgentEndTimeoutExitCode(
 }
 
 /**
- * Orchestrates the cleanup and exit code capture of a child process.
  * Safety: Implements a dual-timer strategy (idle and hard) to ensure streams
  * are destroyed and promises settled even if the process or its pipes hang.
  */
@@ -278,8 +290,9 @@ function accumulateUsage(result: RuntimeResult, msg: Message): void {
   result.usage.cacheWrite += usage.cacheWrite || 0;
   result.usage.cost += usage.cost?.total || 0;
   result.usage.contextTokens = usage.totalTokens || 0;
-  result.usage.contextWindowTokens =
-    resolveContextWindowTokens(msg) ?? result.usage.contextWindowTokens;
+  const ctxWindowTokens = resolveContextWindowTokens(msg);
+  if (ctxWindowTokens !== undefined)
+    result.usage.contextWindowTokens = ctxWindowTokens;
 }
 
 function addMessageToResult(result: RuntimeResult, msg: Message): void {
@@ -288,7 +301,7 @@ function addMessageToResult(result: RuntimeResult, msg: Message): void {
   if (msg.role === "toolResult" && msg.isError) {
     result.errorMessage ||= TOOL_RESULT_FAILED_MESSAGE;
   } else if (result.errorMessage === TOOL_RESULT_FAILED_MESSAGE) {
-    result.errorMessage = undefined;
+    delete result.errorMessage;
   }
   if (msg.role === "assistant") {
     accumulateUsage(result, msg);
@@ -336,13 +349,14 @@ function errorForDepthLimit(
   source: "user" | "project" | "unknown",
   task: string,
   depth: number,
+  maxDepth: number,
   model?: string,
 ): SingleResult {
   return createErrorResult(
     agentName,
     source,
     task,
-    `Subagent nesting limit reached (depth ${depth}/${MAX_SUBAGENT_DEPTH}).`,
+    `Subagent nesting limit reached (depth ${depth}/${maxDepth}).`,
     model,
   );
 }
@@ -387,12 +401,6 @@ function findRecentMessagesAnchor(messages: Message[]): number {
   return -1;
 }
 
-/**
- * Derives current execution progress from accumulated messages.
- * Maps tool calls to UI-safe previews for real-time feedback.
- * Builds activeToolActivity from the most recent tool call, providing
- * a compact parent summary for subagent tools before nested child data arrives.
- */
 function deriveStreamingProgress(messages: Message[]): StreamingProgress {
   const toolCalls: { id: string; preview: string }[] = [];
   let lastToolPreview: string | undefined;
@@ -410,18 +418,15 @@ function deriveStreamingProgress(messages: Message[]): StreamingProgress {
       activeToolActivity = { toolName: part.name, inputSummary: preview };
     }
   }
+  const activityText = renderToolActivity(activeToolActivity);
   return {
     activeToolActivity,
-    activityText: renderToolActivity(activeToolActivity),
+    activityText,
     toolCalls,
     lastToolPreview,
   };
 }
 
-/**
- * Prevents leaking secrets in the CLI progress display.
- * Redacts values if the preview contains sensitive keywords.
- */
 function sanitizeProgressPreview(preview: string, toolName: string): string {
   return SENSITIVE_PATTERN.test(preview) ? toolName : preview;
 }
@@ -447,7 +452,9 @@ export function makeEmitUpdate(
     // so the parent retains nested context until newer activity arrives
     if (options?.toolResultCompleted && result.progress?.activeToolActivity) {
       progress.activeToolActivity = result.progress.activeToolActivity;
-      progress.activityText = renderToolActivity(progress.activeToolActivity);
+      const renderedText = renderToolActivity(progress.activeToolActivity);
+      if (renderedText !== undefined) progress.activityText = renderedText;
+      else delete progress.activityText;
     }
     // Handle parsed tool activity from child events
     // Merge with parent activity if this is a nested update
@@ -474,7 +481,10 @@ export function makeEmitUpdate(
       } else {
         progress.activeToolActivity = options.toolActivity;
       }
-      progress.activityText = renderToolActivity(progress.activeToolActivity);
+      const renderedActivity = renderToolActivity(progress.activeToolActivity);
+      if (renderedActivity !== undefined)
+        progress.activityText = renderedActivity;
+      else delete progress.activityText;
     }
     if (options?.toolResultCompleted) {
       progress.toolResultCompleted = true;
@@ -515,7 +525,7 @@ function makeRequestTerminator(
 function clearGraceTimer(state: SubagentState): void {
   if (!state.agentEndGraceTimer) return;
   clearTimeout(state.agentEndGraceTimer);
-  state.agentEndGraceTimer = undefined;
+  delete state.agentEndGraceTimer;
 }
 
 function handleMessageEvent(
@@ -563,12 +573,25 @@ function handleAgentEndEvent(
   }
   if (state.agentEndGraceTimer || state.terminationPromise) return;
   state.agentEndGraceTimer = setTimeout(() => {
-    state.agentEndGraceTimer = undefined;
+    delete state.agentEndGraceTimer;
     void requestTermination("agent_end_timeout");
-  }, AGENT_END_GRACE_MS);
+  }, state.runtimeLimits.agentEndGraceMs);
   state.agentEndGraceTimer.unref?.();
 }
 
+function formatUnknownEventDiagnostic(
+  line: string,
+  parseResult: Exclude<ChildEventParseResult, { kind: "known" }>,
+): string {
+  if (parseResult.kind === "invalid" && !line.trim()) {
+    return "[pi-subagent:unknown-event] blank";
+  }
+  if (parseResult.kind === "invalid") {
+    return `[pi-subagent:unknown-event] malformed: ${line}`;
+  }
+  return `[pi-subagent:unknown-event] unknown: ${JSON.stringify(parseResult.event)}`;
+}
+
 function processEventLine(
   line: string,
   state: SubagentState,
@@ -577,9 +600,17 @@ function processEventLine(
     toolResultCompleted?: boolean;
   }) => void,
   requestTermination: (reason: string) => Promise<unknown>,
+  debugEventDiagnostics: boolean,
 ): void {
   const parseResult = parseChildEventLine(line);
-  if (parseResult.kind !== "known") return;
+  if (parseResult.kind !== "known") {
+    if (debugEventDiagnostics) {
+      process.stderr.write(
+        `${formatUnknownEventDiagnostic(line, parseResult)}\n`,
+      );
+    }
+    return;
+  }
   const { event } = parseResult;
   handleMessageEvent(event, state, emitUpdate);
   handleToolExecutionUpdateEvent(event, emitUpdate);
@@ -639,28 +670,35 @@ function setupChildProcess(
     toolResultCompleted?: boolean;
   }) => void,
   requestTermination: (reason: string) => Promise<unknown>,
+  debugEventDiagnostics: boolean,
 ): void {
   proc.once("error", (error) => {
     state.spawnError = error;
     state.result.stderr = appendWithByteLimit(
       state.result.stderr,
       error.message,
-      MAX_STDERR_BYTES,
+      state.runtimeLimits.maxStderrBytes,
     );
   });
   if (proc.stdout) {
     readline
       .createInterface({ input: proc.stdout })
       .on("line", (line) =>
-        processEventLine(line, state, emitUpdate, requestTermination),
+        processEventLine(
+          line,
+          state,
+          emitUpdate,
+          requestTermination,
+          debugEventDiagnostics,
+        ),
       );
   }
   if (proc.stderr) {
-    proc.stderr.on("data", (data) => {
+    proc.stderr.on("data", (data: Buffer) => {
       state.result.stderr = appendWithByteLimit(
         state.result.stderr,
-        data.toString(),
-        MAX_STDERR_BYTES,
+        data,
+        state.runtimeLimits.maxStderrBytes,
       );
     });
   }
@@ -689,8 +727,6 @@ async function finalizeResult(
 }
 
 /**
- * Executes a single subagent task.
- *
  * Rationale: Subagents run in isolated child processes to protect the parent's
  * context window and allow specialized system prompts/tools without polluting
  * the main conversation.
@@ -716,12 +752,20 @@ export async function runSingleAgent(
   ) => SubagentDetails,
   parentModel: { provider: string; id: string } | undefined,
   parentThinking: ThinkingLevel,
+  debugEventDiagnostics = false,
 ): Promise<SingleResult> {
   const agent = agents.find((a) => a.name === agentName);
   if (!agent) return errorForUnknownAgent(agentName, agents, task);
+  const runtimeLimits = getSubagentRuntimeLimits();
   const depth = getSubagentDepth();
-  if (depth >= MAX_SUBAGENT_DEPTH) {
-    return errorForDepthLimit(agentName, agent.source, task, depth);
+  if (depth >= runtimeLimits.maxDepth) {
+    return errorForDepthLimit(
+      agentName,
+      agent.source,
+      task,
+      depth,
+      runtimeLimits.maxDepth,
+    );
   }
   const requestedThinking = agent.thinking ?? parentThinking;
   const { level: thinking, warning: thinkingWarning } = parentModel
@@ -754,6 +798,7 @@ export async function runSingleAgent(
   const startedAt = Date.now();
   const state: SubagentState = {
     result: initRuntimeResult(agentName, agent.source, task, modelDisplay),
+    runtimeLimits,
     wasAborted: false,
   };
   if (thinkingWarning) state.result.thinkingWarning = thinkingWarning;
@@ -787,7 +832,13 @@ export async function runSingleAgent(
       terminateOptions,
       state,
     );
-    setupChildProcess(proc, state, emitUpdate, requestTermination);
+    setupChildProcess(
+      proc,
+      state,
+      emitUpdate,
+      requestTermination,
+      debugEventDiagnostics,
+    );
     const onAbort = setupAbortHandler(
       signal,
       state,

package/src/child/termination.ts

@@ -4,12 +4,12 @@ export type TerminationSignal = "SIGTERM" | "SIGKILL";
 
 export type TerminationMetadata = {
   cancelRequestedAt: number;
-  cancelReason?: string;
-  terminationSignal?: TerminationSignal;
+  cancelReason?: string | undefined;
+  terminationSignal?: TerminationSignal | undefined;
   escalated: boolean;
   processTreeKilled: boolean;
   target: "direct" | "tree";
-  fallbackCause?: string;
+  fallbackCause?: string | undefined;
 };
 
 type TimerHandle = unknown;
@@ -64,7 +64,7 @@ function settleState(state: TerminationState): void {
   if (state.settled) return;
   state.settled = true;
   if (state.timer) state.clearTimeout(state.timer);
-  state.timer = undefined;
+  delete state.timer;
   state.resolve(state.metadata);
 }
 

package/src/env.d.ts

@@ -0,0 +1,13 @@
+declare namespace NodeJS {
+  interface ProcessEnv {
+    PATH?: string;
+    PI_CODING_AGENT_DIR?: string;
+    PI_SUBAGENT_DEPTH?: string;
+    PI_SUBAGENT_MAX_DEPTH?: string;
+    PI_SUBAGENT_MAX_OUTPUT_BYTES?: string;
+    PI_SUBAGENT_MAX_OUTPUT_LINES?: string;
+    PI_SUBAGENT_AGENT_END_GRACE_MS?: string;
+    PI_SUBAGENT_MAX_STDERR_BYTES?: string;
+    PI_SUBAGENT_DEBUG_ENABLED?: string;
+  }
+}

package/src/orchestration/run-registry.ts

@@ -48,7 +48,6 @@ export function cancelAllRunJobs(reason = "Cancelled"): number {
   return count;
 }
 
-export function clearRunJobsForTests(): void {
+export function resetRunRegistry(): void {
   jobs.clear();
 }
-export const resetRunRegistry = clearRunJobsForTests;

package/src/orchestration/subagent-orchestrator.ts

@@ -77,6 +77,10 @@ type DetailsBuilder = (
   options?: DetailsOptions,
 ) => SubagentDetails;
 
+function isDebugDetailsAuthorized(debugRequested: boolean): boolean {
+  return debugRequested && process.env.PI_SUBAGENT_DEBUG_ENABLED === "1";
+}
+
 interface LifecycleContext {
   pi: ExtensionAPI;
   ctx: ExtensionContext;
@@ -90,7 +94,7 @@ interface LifecycleContext {
   task: string;
   parentModel: { provider: string; id: string } | undefined;
   parentThinking: ThinkingLevel;
-  hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails>;
+  hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails> | undefined;
 }
 
 function createDetailsBuilder(
@@ -123,7 +127,7 @@ function sanitizeResultDetails(
     usage: { ...usageBase },
   };
   if (contextWindowTokens !== undefined) {
-    (sanitized.usage as Record<string, unknown>).contextWindowTokens =
+    (sanitized["usage"] as Record<string, unknown>)["contextWindowTokens"] =
       contextWindowTokens;
   }
   if (progress !== undefined) {
@@ -134,7 +138,7 @@ function sanitizeResultDetails(
       toolResultCompleted,
       ...progBase
     } = progress;
-    sanitized.progress = {
+    sanitized["progress"] = {
       toolCalls: progBase.toolCalls.map((tc) => ({
         id: tc.id,
         preview: tc.preview,
@@ -146,7 +150,7 @@ function sanitizeResultDetails(
     };
   }
   if (includeMessages) {
-    sanitized.messages = options?.recentMessages
+    sanitized["messages"] = options?.recentMessages
       ? [...options.recentMessages]
       : messages !== undefined
         ? [...messages]
@@ -154,7 +158,7 @@ function sanitizeResultDetails(
     if (includeDebugMessages && termination !== undefined) {
       const { cancelReason, terminationSignal, fallbackCause, ...termBase } =
         termination;
-      sanitized.termination = {
+      sanitized["termination"] = {
         ...termBase,
         ...(cancelReason !== undefined && { cancelReason }),
         ...(terminationSignal !== undefined && { terminationSignal }),
@@ -318,6 +322,7 @@ async function runSubagentLifecycle(
       lc.makeDetails,
       lc.parentModel,
       lc.parentThinking,
+      lc.debug,
     );
     return finishLifecycleResult(lc, result);
   } catch (error) {
@@ -358,7 +363,7 @@ type PrepareSubagentJobResult =
       lc: LifecycleContext;
       instanceName: string;
       requestProgressRender: () => void;
-      hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails>;
+      hostOnUpdate?: AgentToolUpdateCallback<SubagentDetails> | undefined;
     }
   | { kind: "not_found"; makeDetails: DetailsBuilder }
   | { kind: "cancelled"; makeDetails: DetailsBuilder }
@@ -409,7 +414,7 @@ async function prepareSubagentJob(
   const agentScope: AgentScope = params.agentScope ?? "both";
   const discovery = await getCachedAgentDiscovery(ctx.cwd, agentScope);
   const agents = discovery.agents;
-  const debug = params.debug === true;
+  const debug = isDebugDetailsAuthorized(params.debug === true);
   const makeDetails = createDetailsBuilder(
     agentScope,
     discovery.projectAgentsDir,

package/src/progress/progress-state.ts

@@ -44,21 +44,21 @@ export const STATUS_BG: Record<ProgressStatus, ThemeBg> = {
 export interface SubagentProgressState {
   requestId: string;
   agent: string;
-  instanceName?: string;
+  instanceName?: string | undefined;
   taskPreview: string;
   status: ProgressStatus;
   startTime: number;
-  durationMs?: number;
-  activeToolActivity?: ToolActivity;
-  lastToolPreview?: string;
-  toolResultCompleted?: boolean;
+  durationMs?: number | undefined;
+  activeToolActivity?: ToolActivity | undefined;
+  lastToolPreview?: string | undefined;
+  toolResultCompleted?: boolean | undefined;
   toolCount: number;
-  inputTokens?: number;
-  outputTokens?: number;
-  contextTokens?: number;
-  contextWindowTokens?: number;
-  finalOutput?: string;
-  errorText?: string;
+  inputTokens?: number | undefined;
+  outputTokens?: number | undefined;
+  contextTokens?: number | undefined;
+  contextWindowTokens?: number | undefined;
+  finalOutput?: string | undefined;
+  errorText?: string | undefined;
 }
 
 const store = new Map<string, SubagentProgressState>();
@@ -89,6 +89,23 @@ export function getAllProgressStates(): SubagentProgressState[] {
   return [...store.values()].sort((a, b) => b.startTime - a.startTime);
 }
 
+type ProgressTransientFields = Pick<
+  SubagentProgressState,
+  "activeToolActivity" | "lastToolPreview" | "toolResultCompleted"
+>;
+
+function stripTransientFields(
+  merged: SubagentProgressState,
+): Omit<SubagentProgressState, keyof ProgressTransientFields> {
+  const {
+    activeToolActivity: _a,
+    lastToolPreview: _l,
+    toolResultCompleted: _t,
+    ...base
+  } = merged;
+  return base;
+}
+
 export function patchProgressState(
   requestId: string,
   patch: Partial<SubagentProgressState>,
@@ -96,13 +113,7 @@ export function patchProgressState(
   const state = store.get(requestId);
   if (!state) return;
   if (state.status !== "running") {
-    store.set(requestId, {
-      ...state,
-      ...patch,
-      activeToolActivity: undefined,
-      lastToolPreview: undefined,
-      toolResultCompleted: undefined,
-    });
+    store.set(requestId, stripTransientFields({ ...state, ...patch }));
     return;
   }
   store.set(requestId, { ...state, ...patch });
@@ -115,7 +126,10 @@ function storeTerminalProgressState(
   const state = store.get(requestId);
   if (!state) return;
   const durationMs = state.durationMs ?? Date.now() - state.startTime;
-  store.set(requestId, { ...state, ...patch, durationMs });
+  store.set(requestId, {
+    ...stripTransientFields({ ...state, ...patch }),
+    durationMs,
+  });
 }
 
 export function finalizeProgressState(
@@ -125,9 +139,6 @@ export function finalizeProgressState(
   storeTerminalProgressState(requestId, {
     status: "success",
     finalOutput: makeProgressFinalOutput(finalOutput),
-    activeToolActivity: undefined,
-    lastToolPreview: undefined,
-    toolResultCompleted: undefined,
   });
 }
 
@@ -136,21 +147,13 @@ export function failProgressState(requestId: string, errorText: string): void {
   storeTerminalProgressState(requestId, {
     status: "error",
     errorText: sentence,
-    activeToolActivity: undefined,
-    lastToolPreview: undefined,
-    toolResultCompleted: undefined,
   });
 }
 
 export function cancelProgressState(requestId: string, reason?: string): void {
   storeTerminalProgressState(requestId, {
     status: "cancelled",
-    activeToolActivity: undefined,
-    lastToolPreview: undefined,
-    toolResultCompleted: undefined,
-    ...(reason !== undefined
-      ? { errorText: normalizeTerminalSentence(reason) }
-      : {}),
+    errorText: reason ? normalizeTerminalSentence(reason) : undefined,
   });
 }
 
@@ -235,11 +238,11 @@ function trackNewToolCall(
 
 function extractProgressFromExistingProgress(
   progress: {
-    activityText?: string;
-    activeToolActivity?: ToolActivity;
-    lastToolPreview?: string;
+    activityText?: string | undefined;
+    activeToolActivity?: ToolActivity | undefined;
+    lastToolPreview?: string | undefined;
     toolCalls: { id: string; preview: string }[];
-    toolResultCompleted?: boolean;
+    toolResultCompleted?: boolean | undefined;
   },
   seenToolCallIds: Set<string>,
   state: DetailsProgress,
@@ -317,7 +320,7 @@ function isDerivedToolCall(part: unknown): part is {
   preview: string;
 } {
   if (!isObjectWith(part)) return false;
-  return typeof part.id === "string" && typeof part.preview === "string";
+  return typeof part["id"] === "string" && typeof part["preview"] === "string";
 }
 
 export function isToolCallPart(part: unknown): part is {
@@ -328,9 +331,9 @@ export function isToolCallPart(part: unknown): part is {
 } {
   if (!isObjectWith(part)) return false;
   return (
-    part.type === "toolCall" &&
-    typeof part.id === "string" &&
-    typeof part.name === "string"
+    part["type"] === "toolCall" &&
+    typeof part["id"] === "string" &&
+    typeof part["name"] === "string"
   );
 }
 

package/src/progress/progress.ts

@@ -89,11 +89,18 @@ export function renderSubagentProgress(
 }
 
 class DynamicSubagentProgressText implements Component {
+  private readonly requestId: string;
+  private readonly options: { expanded: boolean };
+  private readonly theme: SubagentTheme;
   constructor(
-    private readonly requestId: string,
-    private readonly options: { expanded: boolean },
-    private readonly theme: SubagentTheme,
-  ) {}
+    requestId: string,
+    options: { expanded: boolean },
+    theme: SubagentTheme,
+  ) {
+    this.requestId = requestId;
+    this.options = options;
+    this.theme = theme;
+  }
   invalidate(): void {}
   render(width: number): string[] {
     const state = getProgressState(this.requestId);