@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/tui/components/chat-log.js

@@ -4,20 +4,51 @@ import { AssistantMessageComponent } from "./assistant-message.js";
 import { ToolExecutionComponent } from "./tool-execution.js";
 import { UserMessageComponent } from "./user-message.js";
 export class ChatLog extends Container {
+    maxComponents;
     toolById = new Map();
     streamingRuns = new Map();
     toolsExpanded = false;
+    constructor(maxComponents = 180) {
+        super();
+        this.maxComponents = Math.max(20, Math.floor(maxComponents));
+    }
+    dropComponentReferences(component) {
+        for (const [toolId, tool] of this.toolById.entries()) {
+            if (tool === component) {
+                this.toolById.delete(toolId);
+            }
+        }
+        for (const [runId, message] of this.streamingRuns.entries()) {
+            if (message === component) {
+                this.streamingRuns.delete(runId);
+            }
+        }
+    }
+    pruneOverflow() {
+        while (this.children.length > this.maxComponents) {
+            const oldest = this.children[0];
+            if (!oldest) {
+                return;
+            }
+            this.removeChild(oldest);
+            this.dropComponentReferences(oldest);
+        }
+    }
+    append(component) {
+        this.addChild(component);
+        this.pruneOverflow();
+    }
     clearAll() {
         this.clear();
         this.toolById.clear();
         this.streamingRuns.clear();
     }
     addSystem(text) {
-        this.addChild(new Spacer(1));
-        this.addChild(new Text(theme.system(text), 1, 0));
+        this.append(new Spacer(1));
+        this.append(new Text(theme.system(text), 1, 0));
     }
     addUser(text) {
-        this.addChild(new UserMessageComponent(text));
+        this.append(new UserMessageComponent(text));
     }
     resolveRunId(runId) {
         return runId ?? "default";
@@ -25,7 +56,7 @@ export class ChatLog extends Container {
     startAssistant(text, runId) {
         const component = new AssistantMessageComponent(text);
         this.streamingRuns.set(this.resolveRunId(runId), component);
-        this.addChild(component);
+        this.append(component);
         return component;
     }
     updateAssistant(text, runId) {
@@ -45,7 +76,16 @@ export class ChatLog extends Container {
             this.streamingRuns.delete(effectiveRunId);
             return;
         }
-        this.addChild(new AssistantMessageComponent(text));
+        this.append(new AssistantMessageComponent(text));
+    }
+    dropAssistant(runId) {
+        const effectiveRunId = this.resolveRunId(runId);
+        const existing = this.streamingRuns.get(effectiveRunId);
+        if (!existing) {
+            return;
+        }
+        this.removeChild(existing);
+        this.streamingRuns.delete(effectiveRunId);
     }
     startTool(toolCallId, toolName, args) {
         const existing = this.toolById.get(toolCallId);
@@ -56,19 +96,21 @@ export class ChatLog extends Container {
         const component = new ToolExecutionComponent(toolName, args);
         component.setExpanded(this.toolsExpanded);
         this.toolById.set(toolCallId, component);
-        this.addChild(component);
+        this.append(component);
         return component;
     }
     updateToolArgs(toolCallId, args) {
         const existing = this.toolById.get(toolCallId);
-        if (!existing)
+        if (!existing) {
             return;
+        }
         existing.setArgs(args);
     }
     updateToolResult(toolCallId, result, opts) {
         const existing = this.toolById.get(toolCallId);
-        if (!existing)
+        if (!existing) {
             return;
+        }
         if (opts?.partial) {
             existing.setPartialResult(result);
             return;

package/dist/tui/theme/theme.js

@@ -4,20 +4,20 @@ import { createSyntaxTheme } from "./syntax-theme.js";
 const palette = {
     text: "#E8E3D5",
     dim: "#7B7F87",
-    accent: "#A855F7", // vivid purple (was gold #F6C453)
-    accentSoft: "#C084FC", // soft purple (was orange #F2A65A)
+    accent: "#F6C453",
+    accentSoft: "#F2A65A",
     border: "#3C414B",
     userBg: "#2B2F36",
     userText: "#F3EEE0",
     systemText: "#9BA3B2",
-    toolPendingBg: "#1F1F2F", // slight purple tint (was teal #1F2A2F)
+    toolPendingBg: "#1F2A2F",
     toolSuccessBg: "#1E2D23",
     toolErrorBg: "#2F1F1F",
-    toolTitle: "#A855F7", // vivid purple (was gold #F6C453)
+    toolTitle: "#F6C453",
     toolOutput: "#E1DACB",
     quote: "#8CC8FF",
     quoteBorder: "#3B4D6B",
-    code: "#D4BBFF", // light lavender (was gold #F0C987)
+    code: "#F0C987",
     codeBlock: "#1E232A",
     codeBorder: "#343A45",
     link: "#7DD3A5",
@@ -50,6 +50,7 @@ function highlightCode(code, lang) {
 }
 export const theme = {
     fg: fg(palette.text),
+    assistantText: (text) => text,
     dim: fg(palette.dim),
     accent: fg(palette.accent),
     accentSoft: fg(palette.accentSoft),
@@ -85,15 +86,16 @@ export const markdownTheme = {
     underline: (text) => chalk.underline(text),
     highlightCode,
 };
-export const selectListTheme = {
+const baseSelectListTheme = {
     selectedPrefix: (text) => fg(palette.accent)(text),
     selectedText: (text) => chalk.bold(fg(palette.accent)(text)),
     description: (text) => fg(palette.dim)(text),
     scrollInfo: (text) => fg(palette.dim)(text),
     noMatch: (text) => fg(palette.dim)(text),
 };
+export const selectListTheme = baseSelectListTheme;
 export const filterableSelectListTheme = {
-    ...selectListTheme,
+    ...baseSelectListTheme,
     filterLabel: (text) => fg(palette.dim)(text),
 };
 export const settingsListTheme = {
@@ -108,11 +110,7 @@ export const editorTheme = {
     selectList: selectListTheme,
 };
 export const searchableSelectListTheme = {
-    selectedPrefix: (text) => fg(palette.accent)(text),
-    selectedText: (text) => chalk.bold(fg(palette.accent)(text)),
-    description: (text) => fg(palette.dim)(text),
-    scrollInfo: (text) => fg(palette.dim)(text),
-    noMatch: (text) => fg(palette.dim)(text),
+    ...baseSelectListTheme,
     searchPrompt: (text) => fg(palette.accentSoft)(text),
     searchInput: (text) => fg(palette.text)(text),
     matchHighlight: (text) => chalk.bold(fg(palette.accent)(text)),

package/dist/tui/tui-command-handlers.js

@@ -1,20 +1,15 @@
-import { truncateToWidth } from "@mariozechner/pi-tui";
 import { formatThinkingLevels, normalizeUsageDisplay, resolveResponseUsageMode, } from "../auto-reply/thinking.js";
+import { formatRelativeTimestamp } from "../infra/format-time/format-relative.js";
 import { normalizeAgentId } from "../routing/session-key.js";
-import { formatRelativeTime } from "../utils/time-format.js";
 import { helpText, parseCommand } from "./commands.js";
 import { createFilterableSelectList, createSearchableSelectList, createSettingsList, } from "./components/selectors.js";
 import { formatStatusSummary } from "./tui-status-summary.js";
 export function createCommandHandlers(context) {
-    const { client, chatLog, tui, opts, state, deliverDefault, openOverlay, closeOverlay, refreshSessionInfo, loadHistory, setSession, refreshAgents, abortActive, setActivityStatus, formatSessionKey, } = context;
+    const { client, chatLog, tui, opts, state, deliverDefault, openOverlay, closeOverlay, refreshSessionInfo, loadHistory, setSession, refreshAgents, abortActive, setActivityStatus, formatSessionKey, applySessionInfoFromPatch, noteLocalRunId, forgetLocalRunId, } = context;
     const setAgent = async (id) => {
         state.currentAgentId = normalizeAgentId(id);
         await setSession("");
     };
-    // Maximum visible width for overlay item strings. The overlay has its own
-    // padding/chrome (~4 chars). We subtract a generous margin so that even
-    // after ANSI formatting, lines stay within terminal bounds.
-    const overlayItemWidth = () => Math.max(30, (tui.terminal.columns ?? 80) - 6);
     const openModelSelector = async () => {
         try {
             const models = await client.listModels();
@@ -23,21 +18,21 @@ export function createCommandHandlers(context) {
                 tui.requestRender();
                 return;
             }
-            const maxW = overlayItemWidth();
             const items = models.map((model) => ({
                 value: `${model.provider}/${model.id}`,
-                label: truncateToWidth(`${model.provider}/${model.id}`, maxW),
-                description: model.name && model.name !== model.id ? truncateToWidth(model.name, maxW) : "",
+                label: `${model.provider}/${model.id}`,
+                description: model.name && model.name !== model.id ? model.name : "",
             }));
             const selector = createSearchableSelectList(items, 9);
             selector.onSelect = (item) => {
                 void (async () => {
                     try {
-                        await client.patchSession({
+                        const result = await client.patchSession({
                             key: state.currentSessionKey,
                             model: item.value,
                         });
                         chatLog.addSystem(`model set to ${item.value}`);
+                        applySessionInfoFromPatch(result);
                         await refreshSessionInfo();
                     }
                     catch (err) {
@@ -66,10 +61,9 @@ export function createCommandHandlers(context) {
             tui.requestRender();
             return;
         }
-        const maxW = overlayItemWidth();
         const items = state.agents.map((agent) => ({
             value: agent.id,
-            label: truncateToWidth(agent.name ? `${agent.id} (${agent.name})` : agent.id, maxW),
+            label: agent.name ? `${agent.id} (${agent.name})` : agent.id,
             description: agent.id === state.agentDefaultId ? "default" : "",
         }));
         const selector = createSearchableSelectList(items, 9);
@@ -96,20 +90,21 @@ export function createCommandHandlers(context) {
                 includeLastMessage: true,
                 agentId: state.currentAgentId,
             });
-            const maxW = overlayItemWidth();
             const items = result.sessions.map((session) => {
                 const title = session.derivedTitle ?? session.displayName;
                 const formattedKey = formatSessionKey(session.key);
                 // Avoid redundant "title (key)" when title matches key
                 const label = title && title !== formattedKey ? `${title} (${formattedKey})` : formattedKey;
                 // Build description: time + message preview
-                const timePart = session.updatedAt ? formatRelativeTime(session.updatedAt) : "";
+                const timePart = session.updatedAt
+                    ? formatRelativeTimestamp(session.updatedAt, { dateFallback: true, fallback: "" })
+                    : "";
                 const preview = session.lastMessagePreview?.replace(/\s+/g, " ").trim();
                 const description = timePart && preview ? `${timePart} · ${preview}` : (preview ?? timePart);
                 return {
                     value: session.key,
-                    label: truncateToWidth(label, maxW),
-                    description: truncateToWidth(description, maxW),
+                    label,
+                    description,
                     searchText: [
                         session.displayName,
                         session.label,
@@ -176,8 +171,9 @@ export function createCommandHandlers(context) {
     };
     const handleCommand = async (raw) => {
         const { name, args } = parseCommand(raw);
-        if (!name)
+        if (!name) {
             return;
+        }
         switch (name) {
             case "help":
                 chatLog.addSystem(helpText({
@@ -194,8 +190,9 @@ export function createCommandHandlers(context) {
                     }
                     if (status && typeof status === "object") {
                         const lines = formatStatusSummary(status);
-                        for (const line of lines)
+                        for (const line of lines) {
                             chatLog.addSystem(line);
+                        }
                         break;
                     }
                     chatLog.addSystem("status: unknown response");
@@ -232,11 +229,12 @@ export function createCommandHandlers(context) {
                 }
                 else {
                     try {
-                        await client.patchSession({
+                        const result = await client.patchSession({
                             key: state.currentSessionKey,
                             model: args,
                         });
                         chatLog.addSystem(`model set to ${args}`);
+                        applySessionInfoFromPatch(result);
                         await refreshSessionInfo();
                     }
                     catch (err) {
@@ -254,11 +252,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         thinkingLevel: args,
                     });
                     chatLog.addSystem(`thinking set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -271,12 +270,13 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         verboseLevel: args,
                     });
                     chatLog.addSystem(`verbose set to ${args}`);
-                    await refreshSessionInfo();
+                    applySessionInfoFromPatch(result);
+                    await loadHistory();
                 }
                 catch (err) {
                     chatLog.addSystem(`verbose failed: ${String(err)}`);
@@ -288,11 +288,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         reasoningLevel: args,
                     });
                     chatLog.addSystem(`reasoning set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -309,11 +310,12 @@ export function createCommandHandlers(context) {
                 const current = resolveResponseUsageMode(currentRaw);
                 const next = normalized ?? (current === "off" ? "tokens" : current === "tokens" ? "full" : "off");
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         responseUsage: next === "off" ? null : next,
                     });
                     chatLog.addSystem(`usage footer: ${next}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -331,11 +333,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         elevatedLevel: args,
                     });
                     chatLog.addSystem(`elevated set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -348,11 +351,12 @@ export function createCommandHandlers(context) {
                     break;
                 }
                 try {
-                    await client.patchSession({
+                    const result = await client.patchSession({
                         key: state.currentSessionKey,
                         groupActivation: args === "always" ? "always" : "mention",
                     });
                     chatLog.addSystem(`activation set to ${args}`);
+                    applySessionInfoFromPatch(result);
                     await refreshSessionInfo();
                 }
                 catch (err) {
@@ -405,10 +409,15 @@ export function createCommandHandlers(context) {
                 deliver: deliverDefault,
                 timeoutMs: opts.timeoutMs,
             });
+            noteLocalRunId(runId);
             state.activeChatRunId = runId;
             setActivityStatus("waiting");
         }
         catch (err) {
+            if (state.activeChatRunId) {
+                forgetLocalRunId?.(state.activeChatRunId);
+            }
+            state.activeChatRunId = null;
             chatLog.addSystem(`send failed: ${String(err)}`);
             setActivityStatus("error");
         }

package/dist/tui/tui-event-handlers.js

@@ -1,36 +1,42 @@
 import { asString, extractTextFromMessage, isCommandMessage } from "./tui-formatters.js";
 import { TuiStreamAssembler } from "./tui-stream-assembler.js";
 export function createEventHandlers(context) {
-    const { chatLog, tui, state, setActivityStatus, refreshSessionInfo } = context;
+    const { chatLog, tui, state, setActivityStatus, refreshSessionInfo, loadHistory, isLocalRunId, forgetLocalRunId, clearLocalRunIds, } = context;
     const finalizedRuns = new Map();
     const sessionRuns = new Map();
     let streamAssembler = new TuiStreamAssembler();
     let lastSessionKey = state.currentSessionKey;
     const pruneRunMap = (runs) => {
-        if (runs.size <= 200)
+        if (runs.size <= 200) {
             return;
+        }
         const keepUntil = Date.now() - 10 * 60 * 1000;
         for (const [key, ts] of runs) {
-            if (runs.size <= 150)
+            if (runs.size <= 150) {
                 break;
-            if (ts < keepUntil)
+            }
+            if (ts < keepUntil) {
                 runs.delete(key);
+            }
         }
         if (runs.size > 200) {
             for (const key of runs.keys()) {
                 runs.delete(key);
-                if (runs.size <= 150)
+                if (runs.size <= 150) {
                     break;
+                }
             }
         }
     };
     const syncSessionKey = () => {
-        if (state.currentSessionKey === lastSessionKey)
+        if (state.currentSessionKey === lastSessionKey) {
             return;
+        }
         lastSessionKey = state.currentSessionKey;
         finalizedRuns.clear();
         sessionRuns.clear();
         streamAssembler = new TuiStreamAssembler();
+        clearLocalRunIds?.();
     };
     const noteSessionRun = (runId) => {
         sessionRuns.set(runId, Date.now());
@@ -42,18 +48,44 @@ export function createEventHandlers(context) {
         streamAssembler.drop(runId);
         pruneRunMap(finalizedRuns);
     };
+    const clearActiveRunIfMatch = (runId) => {
+        if (state.activeChatRunId === runId) {
+            state.activeChatRunId = null;
+        }
+    };
+    const hasConcurrentActiveRun = (runId) => {
+        const activeRunId = state.activeChatRunId;
+        if (!activeRunId || activeRunId === runId) {
+            return false;
+        }
+        return sessionRuns.has(activeRunId);
+    };
+    const maybeRefreshHistoryForRun = (runId) => {
+        if (isLocalRunId?.(runId)) {
+            forgetLocalRunId?.(runId);
+            return;
+        }
+        if (hasConcurrentActiveRun(runId)) {
+            return;
+        }
+        void loadHistory?.();
+    };
     const handleChatEvent = (payload) => {
-        if (!payload || typeof payload !== "object")
+        if (!payload || typeof payload !== "object") {
             return;
+        }
         const evt = payload;
         syncSessionKey();
-        if (evt.sessionKey !== state.currentSessionKey)
+        if (evt.sessionKey !== state.currentSessionKey) {
             return;
+        }
         if (finalizedRuns.has(evt.runId)) {
-            if (evt.state === "delta")
+            if (evt.state === "delta") {
                 return;
-            if (evt.state === "final")
+            }
+            if (evt.state === "final") {
                 return;
+            }
         }
         noteSessionRun(evt.runId);
         if (!state.activeChatRunId) {
@@ -61,98 +93,156 @@ export function createEventHandlers(context) {
         }
         if (evt.state === "delta") {
             const displayText = streamAssembler.ingestDelta(evt.runId, evt.message, state.showThinking);
-            if (!displayText)
+            if (!displayText) {
                 return;
+            }
             chatLog.updateAssistant(displayText, evt.runId);
             setActivityStatus("streaming");
         }
         if (evt.state === "final") {
+            const wasActiveRun = state.activeChatRunId === evt.runId;
+            if (!evt.message) {
+                maybeRefreshHistoryForRun(evt.runId);
+                chatLog.dropAssistant(evt.runId);
+                noteFinalizedRun(evt.runId);
+                clearActiveRunIfMatch(evt.runId);
+                if (wasActiveRun) {
+                    setActivityStatus("idle");
+                }
+                void refreshSessionInfo?.();
+                tui.requestRender();
+                return;
+            }
             if (isCommandMessage(evt.message)) {
+                maybeRefreshHistoryForRun(evt.runId);
                 const text = extractTextFromMessage(evt.message);
-                if (text)
+                if (text) {
                     chatLog.addSystem(text);
+                }
                 streamAssembler.drop(evt.runId);
                 noteFinalizedRun(evt.runId);
-                state.activeChatRunId = null;
-                setActivityStatus("idle");
+                clearActiveRunIfMatch(evt.runId);
+                if (wasActiveRun) {
+                    setActivityStatus("idle");
+                }
                 void refreshSessionInfo?.();
                 tui.requestRender();
                 return;
             }
+            maybeRefreshHistoryForRun(evt.runId);
             const stopReason = evt.message && typeof evt.message === "object" && !Array.isArray(evt.message)
                 ? typeof evt.message.stopReason === "string"
                     ? evt.message.stopReason
                     : ""
                 : "";
             const finalText = streamAssembler.finalize(evt.runId, evt.message, state.showThinking);
-            chatLog.finalizeAssistant(finalText, evt.runId);
+            const suppressEmptyExternalPlaceholder = finalText === "(no output)" && !isLocalRunId?.(evt.runId);
+            if (suppressEmptyExternalPlaceholder) {
+                chatLog.dropAssistant(evt.runId);
+            }
+            else {
+                chatLog.finalizeAssistant(finalText, evt.runId);
+            }
             noteFinalizedRun(evt.runId);
-            state.activeChatRunId = null;
-            setActivityStatus(stopReason === "error" ? "error" : "idle");
+            clearActiveRunIfMatch(evt.runId);
+            if (wasActiveRun) {
+                setActivityStatus(stopReason === "error" ? "error" : "idle");
+            }
             // Refresh session info to update token counts in footer
             void refreshSessionInfo?.();
         }
         if (evt.state === "aborted") {
+            const wasActiveRun = state.activeChatRunId === evt.runId;
             chatLog.addSystem("run aborted");
             streamAssembler.drop(evt.runId);
             sessionRuns.delete(evt.runId);
-            state.activeChatRunId = null;
-            setActivityStatus("aborted");
+            clearActiveRunIfMatch(evt.runId);
+            if (wasActiveRun) {
+                setActivityStatus("aborted");
+            }
             void refreshSessionInfo?.();
+            maybeRefreshHistoryForRun(evt.runId);
         }
         if (evt.state === "error") {
+            const wasActiveRun = state.activeChatRunId === evt.runId;
             chatLog.addSystem(`run error: ${evt.errorMessage ?? "unknown"}`);
             streamAssembler.drop(evt.runId);
             sessionRuns.delete(evt.runId);
-            state.activeChatRunId = null;
-            setActivityStatus("error");
+            clearActiveRunIfMatch(evt.runId);
+            if (wasActiveRun) {
+                setActivityStatus("error");
+            }
             void refreshSessionInfo?.();
+            maybeRefreshHistoryForRun(evt.runId);
         }
         tui.requestRender();
     };
     const handleAgentEvent = (payload) => {
-        if (!payload || typeof payload !== "object")
+        if (!payload || typeof payload !== "object") {
             return;
+        }
         const evt = payload;
         syncSessionKey();
         // Agent events (tool streaming, lifecycle) are emitted per-run. Filter against the
-        // active chat run id, not the session id.
+        // active chat run id, not the session id. Tool results can arrive after the chat
+        // final event, so accept finalized runs for tool updates.
         const isActiveRun = evt.runId === state.activeChatRunId;
-        if (!isActiveRun && !sessionRuns.has(evt.runId))
+        const isKnownRun = isActiveRun || sessionRuns.has(evt.runId) || finalizedRuns.has(evt.runId);
+        if (!isKnownRun) {
             return;
+        }
         if (evt.stream === "tool") {
+            const verbose = state.sessionInfo.verboseLevel ?? "off";
+            const allowToolEvents = verbose !== "off";
+            const allowToolOutput = verbose === "full";
+            if (!allowToolEvents) {
+                return;
+            }
             const data = evt.data ?? {};
             const phase = asString(data.phase, "");
             const toolCallId = asString(data.toolCallId, "");
             const toolName = asString(data.name, "tool");
-            if (!toolCallId)
+            if (!toolCallId) {
                 return;
+            }
             if (phase === "start") {
                 chatLog.startTool(toolCallId, toolName, data.args);
             }
             else if (phase === "update") {
+                if (!allowToolOutput) {
+                    return;
+                }
                 chatLog.updateToolResult(toolCallId, data.partialResult, {
                     partial: true,
                 });
             }
             else if (phase === "result") {
-                chatLog.updateToolResult(toolCallId, data.result, {
-                    isError: Boolean(data.isError),
-                });
+                if (allowToolOutput) {
+                    chatLog.updateToolResult(toolCallId, data.result, {
+                        isError: Boolean(data.isError),
+                    });
+                }
+                else {
+                    chatLog.updateToolResult(toolCallId, { content: [] }, { isError: Boolean(data.isError) });
+                }
             }
             tui.requestRender();
             return;
         }
         if (evt.stream === "lifecycle") {
-            if (!isActiveRun)
+            if (!isActiveRun) {
                 return;
+            }
             const phase = typeof evt.data?.phase === "string" ? evt.data.phase : "";
-            if (phase === "start")
+            if (phase === "start") {
                 setActivityStatus("running");
-            if (phase === "end")
+            }
+            if (phase === "end") {
                 setActivityStatus("idle");
-            if (phase === "error")
+            }
+            if (phase === "error") {
                 setActivityStatus("error");
+            }
             tui.requestRender();
         }
     };