openclaw-lark-multi-agent 1.8.13 → 1.8.15

package/dist/live-status.js

@@ -12,6 +12,22 @@ const DEFAULT_TICK_MS = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS
 // freeze the live-status card for the rest of a long run. We skip the failed
 // tick, keep the ticker alive, and only disable after this many in a row.
 const MAX_CONSECUTIVE_EDIT_FAILURES = Number(process.env.OPENCLAW_LARK_MULTI_AGENT_LIVE_STATUS_MAX_EDIT_FAILURES || 5);
+/** A transport/observation error is not proof that a platform effect failed. */
+export class LiveStatusEffectUnknownError extends Error {
+    cause;
+    constructor(cause) {
+        super("live status effect outcome unknown");
+        this.cause = cause;
+        this.name = "LiveStatusEffectUnknownError";
+    }
+}
+/** Only a definitive platform rejection is safe for the terminal retry loop. */
+export class LiveStatusEffectRejectedError extends Error {
+}
+/** Proven local no-effect suppression (settings/epoch/lease), not an unknown
+ * transport outcome and not permission to retry an attempted SDK operation. */
+export class LiveStatusEffectSuppressedError extends Error {
+}
 export class LiveStatusController {
     callbacks;
     opts;
@@ -23,7 +39,19 @@ export class LiveStatusController {
     createTimer;
     tickTimer;
     createPromise;
+    createSuppressed = false;
+    waitingCreateAllowed = false;
     finalized = false;
+    terminalOutcome = false;
+    disposed = false;
+    generation = 0;
+    /** Frozen/terminal presentation wins over every older progress snapshot. */
+    pinnedView;
+    terminalOwner;
+    pendingEdit;
+    editPump;
+    /** Timed-out SDK effects retain receipt ownership, but must not be replayed. */
+    unknownEdits = new Set();
     waitingForResult = false;
     updatesFrozen = false;
     disabled = false;
@@ -34,6 +62,7 @@ export class LiveStatusController {
      *  A success resets the counter. */
     consecutiveEditFailures = 0;
     state = "running";
+    blockedEdits = false;
     /** Total tool calls (tool_start events) seen during the run, for the summary. */
     toolCallCount = 0;
     /** True when finished via noReply(): show a "no content" summary. */
@@ -41,23 +70,116 @@ export class LiveStatusController {
     constructor(callbacks, opts) {
         this.callbacks = callbacks;
         this.opts = opts;
+        if (opts.initialPhase)
+            this.state = opts.initialPhase;
+        const restored = opts.restore;
+        if (restored) {
+            this.messageId = restored.messageId;
+            this.startedAt = restored.startedAt;
+            this.blockedEdits = restored.blockEdits;
+            if (restored.view) {
+                this.state = restored.view.state;
+                this.lines = restored.view.lines.map(line => ({ ...line }));
+                this.toolCallCount = restored.view.toolCalls;
+                this.noReplyResult = restored.view.noReply;
+                this.waitingForResult = restored.view.phase === "waiting";
+                this.updatesFrozen = this.waitingForResult;
+            }
+            // Attempted/unknown create survives process loss as a no-create fence.
+            if (restored.blockCreate && !this.messageId)
+                this.disabled = true;
+        }
+    }
+    /** Receipt is durable locally, NOT Gateway admission. */
+    received(detail) {
+        if (this.finalized || this.disposed)
+            return;
+        this.pushLine("lifecycle", detail);
+        this.callbacks.desired?.(this.buildView());
+        void this.safeEdit(this.buildView());
+    }
+    /** A proven never-attempted ordinary recovery may reuse its queued card.
+     * Merely observing an expected root never calls this method. */
+    resumeQueued() {
+        if (this.disposed || this.terminalOutcome)
+            return;
+        this.finalized = false;
+        this.updatesFrozen = false;
+        this.waitingForResult = false;
+        this.waitingCreateAllowed = false;
+        this.state = "queued";
+        this.generation++;
+        this.pinnedView = undefined;
+        this.pendingEdit = undefined;
+        this.callbacks.desired?.(this.buildView());
+        if (this.messageId) {
+            this.startTicker();
+            void this.safeEdit(this.buildView());
+        }
+        else
+            this.start();
+    }
+    /** Enqueue/local receipt remains waiting, not actual-owner/model evidence.
+     * Keep one latest pinned view while allowing another input to coalesce. */
+    async showInputWaiting(detail, title) {
+        if (this.disposed || this.terminalOutcome)
+            return;
+        this.updatesFrozen = true;
+        this.waitingForResult = true;
+        this.waitingCreateAllowed = !this.messageId && !this.disabled;
+        this.pushLine("lifecycle", detail);
+        this.stopTimers();
+        const view = this.buildView();
+        if (title)
+            view.title = title;
+        // A quick enqueue receipt must not cancel the only queued card before it
+        // ever existed. Still exactly one create flight, with the normal unknown
+        // fence and effect-time settings/lease checks, never a terminal retry.
+        if (!this.messageId && !this.createPromise && !this.disabled) {
+            this.pinView(view);
+            this.createPromise = this.ensureCreated();
+        }
+        await this.finishView(view);
+    }
+    /** Only the exact ACK owner calls this; admission is not model execution. */
+    async admitted(successor = false) {
+        if (this.finalized || this.disposed || (!successor && this.state !== "queued"))
+            return;
+        this.waitingForResult = false;
+        this.state = "admitted";
+        this.pushLine("lifecycle", this.opts.locale === "en" ? "Gateway accepted; waiting for activity" : "Gateway 已接收，等待执行活动");
+        this.callbacks.desired?.(this.buildView());
+        await this.safeEdit(this.buildView());
     }
     get id() { return this.messageId; }
     start(initialDetail) {
-        if (this.disabled || this.finalized || this.updatesFrozen || this.createTimer || this.messageId)
+        if (this.createSuppressed) {
+            this.createPromise = undefined;
+            this.createSuppressed = false;
+        }
+        if (this.disabled || this.finalized || (this.updatesFrozen && !this.waitingCreateAllowed) || this.createTimer || this.createPromise || this.messageId)
             return;
-        this.startedAt = Date.now();
+        if (!this.opts.restore)
+            this.startedAt = Date.now();
         // Presentation may start before chat.send admission. Only the collector's
         // effective-activity idle decision (or confirmed yield) freezes this card;
         // elapsed ticks are presentation, never evidence of task progress.
         if (initialDetail && initialDetail.trim()) {
             this.pushLine("lifecycle", initialDetail.trim());
         }
+        this.callbacks.desired?.(this.buildView());
         this.createTimer = setTimeout(() => {
             this.createTimer = undefined;
             this.createPromise = this.ensureCreated();
         }, this.opts.delayMs ?? DEFAULT_DELAY_MS);
     }
+    setMetadata(model, thinkingLevel) {
+        if (this.disposed || this.finalized)
+            return;
+        this.opts.model = model;
+        this.opts.thinkingLevel = thinkingLevel;
+        this.callbacks.desired?.(this.buildView());
+    }
     async progress(event) {
         if (this.disabled || this.finalized)
             return;
@@ -108,6 +230,8 @@ export class LiveStatusController {
             return; // lifecycle ticks: ignore (footer timer already advances)
         }
         this.waitingForResult = false;
+        this.state = "running";
+        this.callbacks.desired?.(this.buildView());
         await this.ensureCreatedNow();
         await this.safeEdit(this.buildView());
     }
@@ -120,11 +244,7 @@ export class LiveStatusController {
         this.waitingForResult = true;
         this.pushLine("lifecycle", detail);
         this.stopTimers();
-        if (this.createPromise)
-            await this.createPromise.catch(() => { });
-        this.stopTimers();
-        if (this.messageId && !this.disabled)
-            await this.safeEditFinal(this.buildView());
+        await this.finishView(this.buildView());
     }
     /** Release only local observation of a now-idle session, without claiming
      * the previous task succeeded or was aborted. Normal progress is unchanged. */
@@ -132,39 +252,62 @@ export class LiveStatusController {
         if (this.finalized)
             return;
         this.pushLine("lifecycle", detail);
+        this.waitingForResult = true;
         this.finalized = true;
         this.stopTimers();
-        if (this.createPromise)
-            await this.createPromise.catch(() => { });
-        if (!this.messageId || this.disabled)
-            return;
         const view = this.buildView();
         view.title = title || (this.opts.locale === "en" ? `${this.opts.botName} result unconfirmed` : `${this.opts.botName} 结果未确认`);
-        await this.safeEditFinal(view);
+        await this.finishView(view);
     }
     async complete() {
+        if (this.disposed || this.terminalOutcome)
+            return;
+        const pending = this.callbacks.unconfirmedInputs?.("done");
+        if (pending) {
+            await this.showInputWaiting(pending.detail, pending.title);
+            return;
+        }
+        this.terminalOutcome = true;
         this.state = "done";
         this.finalized = true;
         this.stopTimers();
-        if (this.createPromise)
-            await this.createPromise.catch(() => { });
-        if (!this.messageId || this.disabled)
-            return;
-        await this.safeEditFinal(this.buildView());
+        await this.finishView(this.buildView());
     }
     /**
      * Freeze any successful terminal state (text, attachment-only, or NO_REPLY)
      * without first emitting the compact done patch. The caller persists this
      * metadata in the outbox, which owns the final patch/cleanup. If no card was
-     * created, the caller falls back to normal new-message delivery.
+     * created, the caller falls back to normal new-message delivery. Metadata is
+     * a target/execution snapshot, never a receipt. B2/outbox callers that may own
+     * an unknown or same-card final should supply owner BEFORE attempting it;
+     * late IDs/stale effects then delegate reconciliation instead of patching.
      */
-    async prepareTerminalDelivery(noReply = false) {
-        this.state = "done";
-        this.noReplyResult = noReply;
-        this.finalized = true;
+    async prepareTerminalDelivery(noReply = false, owner) {
+        if (this.disposed || (this.terminalOutcome && this.state !== "done"))
+            return undefined;
+        const pending = this.callbacks.unconfirmedInputs?.("done");
+        if (pending) {
+            await this.showInputWaiting(pending.detail, pending.title);
+            return undefined;
+        }
+        if (owner) {
+            this.terminalOwner = owner;
+            this.generation++; // retire any queued controller-owned terminal effect
+            this.pendingEdit = undefined;
+        }
+        if (!this.terminalOutcome) {
+            this.terminalOutcome = true;
+            this.state = "done";
+            this.noReplyResult = noReply;
+            this.finalized = true;
+            this.pinView(this.buildView()); // retire queued progress before handing off
+        }
         this.stopTimers();
         if (this.createPromise)
             await this.createPromise.catch(() => { });
+        return this.finalMeta();
+    }
+    finalMeta() {
         if (!this.messageId)
             return undefined;
         return {
@@ -174,21 +317,25 @@ export class LiveStatusController {
             model: this.opts.model,
             thinkingLevel: this.opts.thinkingLevel,
             locale: this.opts.locale === "en" ? "en" : "zh",
-            noReply,
+            noReply: this.noReplyResult,
         };
     }
-    async prepareFinalDelivery() {
-        return this.prepareTerminalDelivery(false);
+    async prepareFinalDelivery(owner) {
+        return this.prepareTerminalDelivery(false, owner);
     }
     async fail() {
+        if (this.disposed || this.terminalOutcome)
+            return;
+        const pending = this.callbacks.unconfirmedInputs?.("failed");
+        if (pending) {
+            await this.showInputWaiting(pending.detail, pending.title);
+            return;
+        }
+        this.terminalOutcome = true;
         this.state = "failed";
         this.finalized = true;
         this.stopTimers();
-        if (this.createPromise)
-            await this.createPromise.catch(() => { });
-        if (!this.messageId || this.disabled)
-            return;
-        await this.safeEditFinal(this.buildView());
+        await this.finishView(this.buildView());
     }
     /**
      * Finish when the model explicitly produced no reply (NO_REPLY) or an empty
@@ -196,20 +343,60 @@ export class LiveStatusController {
      * activity window, so the user understands the run finished without output.
      */
     async noReply() {
+        if (this.disposed || this.terminalOutcome)
+            return;
+        const pending = this.callbacks.unconfirmedInputs?.("done");
+        if (pending) {
+            await this.showInputWaiting(pending.detail, pending.title);
+            return;
+        }
+        this.terminalOutcome = true;
         this.state = "done";
         this.noReplyResult = true;
         this.finalized = true;
         this.stopTimers();
-        if (this.createPromise)
-            await this.createPromise.catch(() => { });
-        if (!this.messageId || this.disabled)
-            return;
-        await this.safeEditFinal(this.buildView());
+        await this.finishView(this.buildView());
     }
     dispose() {
+        this.disposed = true;
         this.finalized = true;
+        this.generation++;
+        this.pendingEdit = undefined;
         this.stopTimers();
     }
+    pinView(view) {
+        this.generation++;
+        this.callbacks.desired?.(view);
+        this.pinnedView = view;
+        this.pendingEdit = undefined;
+    }
+    async finishView(view) {
+        // Pin BEFORE awaiting creation: a create already in flight may finish late.
+        this.pinView(view);
+        if (this.createPromise)
+            await this.createPromise.catch(() => { });
+        if (this.messageId && !this.disposed)
+            await this.reconcilePinnedView();
+    }
+    async reconcilePinnedView(force = false) {
+        if (!this.pinnedView || this.disposed)
+            return;
+        if (!this.terminalOwner) {
+            await this.queueEdit(this.pinnedView, true, force);
+            return;
+        }
+        const meta = this.finalMeta();
+        if (!meta)
+            return;
+        try {
+            // This is a custody signal, NOT retry authority. The owner must retain
+            // attempted/unknown effects and reconcile its own desired final payload.
+            await this.terminalOwner.onReconcileNeeded(meta);
+        }
+        catch (err) {
+            this.callbacks.warn?.("live status external reconciliation failed (not replayed)", err);
+        }
+    }
     /**
      * Intermediate assistant text arrives as incremental fragments (each flush
      * sends only the newly-added slice). Consecutive fragments with no tool event
@@ -270,25 +457,61 @@ export class LiveStatusController {
     async ensureCreated() {
         if (this.disabled || this.finalized || this.messageId)
             return;
-        const view = this.buildView();
-        try {
-            const id = await this.callbacks.create(view);
+        const view = this.pinnedView || this.buildView();
+        let started = false;
+        let settled = false;
+        const accept = (id) => {
+            if (settled)
+                return;
+            settled = true;
             if (!id) {
                 this.disabled = true;
                 return;
             }
             this.messageId = id;
             this.lastSentSignature = this.signature(view);
-            this.startTicker();
+            if (this.pinnedView && !this.disposed) {
+                void this.reconcilePinnedView();
+            }
+            else
+                this.startTicker();
+        };
+        const effect = {
+            run: async (send) => {
+                // A create waiting behind another chat send is no longer needed once
+                // the task finished. Do not create a stale running card at effect time.
+                if (this.finalized || (this.updatesFrozen && !this.waitingCreateAllowed) || this.disposed) {
+                    settled = true;
+                    return undefined;
+                }
+                started = true;
+                const id = await send();
+                accept(id); // do not attach receipt ownership to the deadline promise
+                return id;
+            },
+        };
+        try {
+            const id = await this.callbacks.create(view, effect);
+            if (!settled)
+                accept(id); // direct/non-queued callbacks remain supported
         }
         catch (err) {
-            this.disabled = true;
-            this.callbacks.warn?.("live status create failed", err);
+            // No duplicate create, including when the outer deadline expired. The
+            // original effect context still adopts a late successful message ID.
+            if (err instanceof LiveStatusEffectSuppressedError) {
+                this.createSuppressed = true;
+                this.createPromise = undefined;
+                this.callbacks.warn?.("live status create locally suppressed before transport", err);
+                return;
+            }
+            if (!started)
+                this.disabled = true;
+            this.callbacks.warn?.("live status create failed (not replayed)", err);
         }
     }
     /** Refresh the elapsed-time footer periodically even with no new activity. */
     startTicker() {
-        if (this.tickTimer || this.disabled || this.finalized || this.updatesFrozen)
+        if (this.tickTimer || this.disabled || this.finalized || this.updatesFrozen || this.blockedEdits)
             return;
         const tickMs = this.opts.tickMs ?? DEFAULT_TICK_MS;
         this.tickTimer = setInterval(() => {
@@ -298,58 +521,136 @@ export class LiveStatusController {
         }, tickMs);
         this.tickTimer.unref?.();
     }
-    async safeEdit(view, force = false) {
-        if (!this.messageId || this.disabled)
-            return false;
-        if (!force && (this.finalized || this.updatesFrozen))
+    async safeEdit(view) {
+        if (!this.messageId || this.disabled || this.finalized || this.updatesFrozen)
+            return;
+        await this.queueEdit(view, false);
+    }
+    /** One flight + one latest pending snapshot, regardless of tick/event rate. */
+    queueEdit(view, priority, force = false) {
+        this.callbacks.desired?.(view);
+        if (this.blockedEdits)
+            return Promise.resolve();
+        if (!this.messageId || this.disposed || (priority && view !== this.pinnedView)
+            || (!priority && (this.disabled || this.finalized || this.updatesFrozen)))
+            return Promise.resolve();
+        if (!priority)
+            this.generation++;
+        this.pendingEdit = { view, generation: this.generation, priority, force, started: false, settled: false, accepted: false };
+        return this.flushEdits();
+    }
+    canRunPendingEdit() {
+        const request = this.pendingEdit;
+        if (!request || this.disposed)
             return false;
-        const sig = this.signature(view);
-        if (!force && sig === this.lastSentSignature)
-            return true;
-        try {
-            await this.callbacks.edit(this.messageId, view);
-            this.lastSentSignature = sig;
-            this.consecutiveEditFailures = 0; // recovered
-            return true;
-        }
-        catch (err) {
-            // A single transient Feishu error (e.g. card patch code=2200 "Internal
-            // Error", rate limit, network blip) must NOT permanently freeze the card.
-            // Skip this tick and keep the ticker running so the next patch recovers it.
-            // Only give up after several CONSECUTIVE failures (a persistent problem,
-            // e.g. the message was deleted or we truly lost access).
-            this.consecutiveEditFailures++;
-            const giveUp = this.consecutiveEditFailures >= MAX_CONSECUTIVE_EDIT_FAILURES;
-            this.callbacks.warn?.(`live status edit failed (${this.consecutiveEditFailures}/${MAX_CONSECUTIVE_EDIT_FAILURES}${giveUp ? ", disabling" : ", will retry next tick"})`, err);
-            if (giveUp) {
-                this.disabled = true;
-                this.stopTimers();
+        // An unknown progress is not retried by ticking. A new terminal/frozen
+        // view may supersede it once; an unknown terminal is never blind retried.
+        return ![...this.unknownEdits].some(old => !request.priority
+            || (old.priority && old.generation >= request.generation));
+    }
+    flushEdits() {
+        if (this.editPump)
+            return this.editPump;
+        // Start on a microtask so editPump is installed before callbacks/receipts
+        // can re-enter, including immediately resolved test/SDK implementations.
+        const pump = Promise.resolve().then(async () => {
+            while (this.canRunPendingEdit()) {
+                const request = this.pendingEdit;
+                this.pendingEdit = undefined;
+                if (!request.force && this.signature(request.view) === this.lastSentSignature)
+                    continue;
+                await this.performEdit(request);
             }
-            return false;
-        }
+        });
+        const owned = pump.finally(() => {
+            if (this.editPump === owned)
+                this.editPump = undefined;
+            // queueEdit can arrive after the loop's last check, while it still sees
+            // this flight. Hand runnable work to a NEW owner and adopt its promise:
+            // callers awaiting the old flight must also await the terminal handoff.
+            // Do not restart blocked unknown work: that would spin microtasks forever.
+            if (this.canRunPendingEdit())
+                return this.flushEdits();
+        });
+        this.editPump = owned;
+        return owned;
     }
-    /**
-     * Terminal edits (complete/fail/noReply) are one-shot — there is no next tick to
-     * recover them — so a transient Feishu error (code=2200 etc.) would leave the
-     * card stuck on "running". Retry the final patch a few times with small backoff
-     * so the card reliably reaches its terminal state.
-     */
-    async safeEditFinal(view) {
-        if (!this.messageId || this.disabled)
-            return;
-        const attempts = Math.max(1, MAX_CONSECUTIVE_EDIT_FAILURES);
-        for (let i = 0; i < attempts; i++) {
+    async performEdit(request) {
+        const current = () => !this.disposed && request.generation === this.generation;
+        const accept = () => {
+            if (request.settled)
+                return;
+            request.settled = true;
+            request.accepted = true;
+            this.unknownEdits.delete(request);
+            if (current()) {
+                this.lastSentSignature = this.signature(request.view);
+                this.consecutiveEditFailures = 0;
+            }
+            else if (this.pinnedView && !this.disposed) {
+                // A deadline frees the ordered chain, not the SDK operation. If old
+                // progress applies AFTER done/frozen, repair it on this same card.
+                void this.reconcilePinnedView(true);
+            }
+            void this.flushEdits();
+        };
+        const effect = {
+            run: async (send) => {
+                if (!current()) {
+                    request.settled = true;
+                    return;
+                }
+                request.started = true;
+                try {
+                    await send();
+                    accept();
+                }
+                catch (err) {
+                    if (err instanceof LiveStatusEffectRejectedError) {
+                        request.settled = true;
+                        request.rejection = err;
+                        this.unknownEdits.delete(request);
+                        // A late definitive rejection also releases the unknown gate.
+                        void this.flushEdits();
+                    }
+                    throw err;
+                }
+            },
+        };
+        const attempts = request.priority ? Math.max(1, MAX_CONSECUTIVE_EDIT_FAILURES) : 1;
+        for (let i = 0; i < attempts && current(); i++) {
             try {
-                await this.callbacks.edit(this.messageId, view);
-                this.lastSentSignature = this.signature(view);
+                await this.callbacks.edit(this.messageId, request.view, effect);
+                if (!request.settled)
+                    accept(); // direct/non-queued callback
                 return;
             }
             catch (err) {
-                const last = i === attempts - 1;
-                this.callbacks.warn?.(`live status final edit failed (${i + 1}/${attempts}${last ? ", giving up" : ", retrying"})`, err);
-                if (last)
+                // The low-level receipt can beat this catch even if the outer race
+                // already chose its deadline. Never retain "unknown" after acceptance.
+                if (request.accepted)
+                    return;
+                const failure = request.rejection ?? err;
+                if (failure instanceof LiveStatusEffectSuppressedError)
+                    return;
+                const unknown = !(failure instanceof LiveStatusEffectRejectedError);
+                if (unknown) {
+                    this.unknownEdits.add(request);
+                    this.callbacks.warn?.("live status edit outcome unknown (not replayed)", failure);
                     return;
-                await new Promise((r) => setTimeout(r, 300 * (i + 1)));
+                }
+                this.consecutiveEditFailures++;
+                this.callbacks.warn?.("live status edit failed", failure);
+                if (request.priority && i + 1 < attempts) {
+                    await new Promise(resolve => setTimeout(resolve, 300 * (i + 1)));
+                    request.started = false;
+                    request.settled = false;
+                    request.rejection = undefined;
+                }
+                else if (!request.priority && this.consecutiveEditFailures >= MAX_CONSECUTIVE_EDIT_FAILURES) {
+                    this.disabled = true;
+                    this.stopTimers();
+                }
             }
         }
     }
@@ -384,17 +685,21 @@ export class LiveStatusController {
             title = en ? `\u26A0\uFE0F ${this.opts.botName} stopped` : `\u26A0\uFE0F ${this.opts.botName} \u6267\u884c\u4e2d\u65ad`;
         else if (this.waitingForResult)
             title = en ? `${this.opts.botName} waiting (card frozen)` : `${this.opts.botName} 等待后续结果（已停止刷新）`;
+        else if (this.state === "queued")
+            title = en ? `${this.opts.botName} received · queued` : `${this.opts.botName} 已收件 · 排队等待`;
+        else if (this.state === "admitted")
+            title = en ? `${this.opts.botName} accepted · waiting` : `${this.opts.botName} 已接收 · 等待活动`;
         else
             title = en ? `${this.opts.botName} is working` : `${this.opts.botName} \u6b63\u5728\u6267\u884c`;
         // On a clean finish (done / NO_REPLY) show only the compact summary. On a
         // failure (error / killed / timeout) keep the recent activity window too, so
         // the last few steps before the failure are visible for debugging.
         let lines;
-        if (this.state === "running") {
-            lines = [...this.lines];
+        if (this.state !== "done" && this.state !== "failed") {
+            lines = this.lines.map(line => ({ ...line }));
         }
         else if (this.state === "failed") {
-            lines = [...this.lines, this.buildSummaryLine(en)];
+            lines = [...this.lines.map(line => ({ ...line })), this.buildSummaryLine(en)];
         }
         else {
             lines = [this.buildSummaryLine(en)];
@@ -408,6 +713,7 @@ export class LiveStatusController {
             toolCalls: this.toolCallCount,
             noReply: this.noReplyResult,
             state: this.state,
+            phase: this.state === "done" || this.state === "failed" ? this.state : this.waitingForResult ? "waiting" : this.state === "running" ? "working" : this.state,
         };
     }
     buildSummaryLine(en) {