@bastani/atomic 0.9.11-alpha.6 → 0.9.11-alpha.7

package/dist/builtin/workflows/src/runs/foreground/stage-delivery-activity.ts

@@ -0,0 +1,86 @@
+/**
+ * Internal stage delivery-activity channel.
+ *
+ * An accepted *idle* stage delivery starts a real backend turn long before the
+ * public `agent_start` clears the session's ordered extension event queue. The
+ * attached stage chat therefore had no signal to paint `Working` with, and the
+ * pane looked idle while the model was already running.
+ *
+ * This channel carries only that fact — "an idle delivery was admitted and is
+ * now starting a turn" — as a workflow-internal event, so the chat can start
+ * its existing Working lifecycle without fabricating SDK lifecycle events or
+ * reordering the public event stream.
+ *
+ * Streaming deliveries (`steer` / `followUp`) never emit here: they join an
+ * in-flight turn that already owns the indicator.
+ *
+ * cross-ref:
+ *   - src/runs/foreground/stage-runner-send-user-message.ts (emitter)
+ *   - src/tui/stage-chat-view-delivery-activity.ts (consumer)
+ */
+
+export type StageDeliveryActivityEvent =
+  | { readonly type: "delivery_start"; readonly deliveryId: number }
+  | { readonly type: "delivery_settled"; readonly deliveryId: number };
+
+export type StageDeliveryActivityListener = (event: StageDeliveryActivityEvent) => void;
+
+export class StageDeliveryActivity {
+  private readonly listeners = new Set<StageDeliveryActivityListener>();
+  private readonly active = new Set<number>();
+  private nextDeliveryId = 0;
+
+  /**
+   * Register `listener`, then synchronously replay every currently-active
+   * delivery as `delivery_start`.
+   *
+   * A stage chat can attach after a delivery was admitted — a late `/workflow
+   * attach`, or a remount — and would otherwise see nothing until the public
+   * `agent_start` finally arrives. Registering before replaying matters:
+   * snapshotting first would drop a start or settlement that lands in between.
+   */
+  subscribe(listener: StageDeliveryActivityListener): () => void {
+    this.listeners.add(listener);
+    for (const deliveryId of [...this.active]) {
+      if (!this.listeners.has(listener)) break;
+      listener({ type: "delivery_start", deliveryId });
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /** Report an admitted idle delivery that is about to start a turn. */
+  start(): number {
+    const deliveryId = ++this.nextDeliveryId;
+    this.active.add(deliveryId);
+    this.emit({ type: "delivery_start", deliveryId });
+    return deliveryId;
+  }
+
+  /** Keep one correlated delivery active for the full asynchronous operation. */
+  async runWithLease<T>(operation: () => Promise<T>): Promise<T> {
+    const deliveryId = this.start();
+    try {
+      return await operation();
+    } finally {
+      this.settle(deliveryId);
+    }
+  }
+
+  /** Report that a delivery finished, failed, or started no turn at all. */
+  settle(deliveryId: number | undefined): void {
+    if (deliveryId === undefined || !this.active.delete(deliveryId)) return;
+    this.emit({ type: "delivery_settled", deliveryId });
+  }
+
+  /** Settle every outstanding delivery, then drop listeners. */
+  dispose(): void {
+    for (const deliveryId of [...this.active]) this.settle(deliveryId);
+    this.listeners.clear();
+  }
+
+  private emit(event: StageDeliveryActivityEvent): void {
+    for (const listener of [...this.listeners]) listener(event);
+  }
+}

package/dist/builtin/workflows/src/runs/foreground/stage-runner-context.ts

@@ -110,8 +110,8 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       await controller.sendUserMessage(text, options);
     },
 
-    async __sendUserMessage(text, options, beforeDelivery) {
-      return controller.sendUserMessage(text, options, beforeDelivery);
+    async __sendUserMessage(text, options, beforeDelivery, preparation) {
+      return controller.sendUserMessage(text, options, beforeDelivery, preparation);
     },
 
     async steer(text) {
@@ -126,6 +126,10 @@ export function createStageContext(opts: StageRunnerOpts): InternalStageContext
       return controller.subscribe(listener);
     },
 
+    __subscribeDeliveryActivity(listener) {
+      return controller.subscribeDeliveryActivity(listener);
+    },
+
     get sessionFile() {
       return controller.currentSession?.sessionFile;
     },

package/dist/builtin/workflows/src/runs/foreground/stage-runner-controller.ts

@@ -9,8 +9,9 @@ import { structuredOutputToolErrorFromEvent } from "./stage-runner-structured-ou
 import { buildStageSessionOptions } from "./stage-runner-session-options.js";
 import { sendStageUserMessage } from "./stage-runner-send-user-message.js";
 import { StageMessageAdmission } from "./stage-runner-message-admission.js";
+import { StageDeliveryActivity, type StageDeliveryActivityListener } from "./stage-delivery-activity.js";
 import { nextResumedContextOverflowFallbackIndex, terminatingToolCallId, unresolvedContextOverflowFailure, unresolvedContextOverflowMessage } from "./stage-runner-unresolved-overflow.js";
-import type { AgentSessionConsumer, StageModelFallbackMeta, StageRunnerOpts, StageSessionCreateOptions, StageSessionCreateResult, StageSessionEvent, StageSessionRuntime, WorkflowFastModeSettingsManager } from "./stage-runner-types.js";
+import type { AgentSessionConsumer, StageModelFallbackMeta, StageRunnerOpts, StageSessionCreateOptions, StageSessionCreateResult, StageSessionEvent, StageSessionRuntime, StageUserMessagePreparation, WorkflowFastModeSettingsManager } from "./stage-runner-types.js";
 import { StageSessionReplacement } from "./stage-runner-replacement.js";
 import { StageSessionPause, type StageSessionPauseResumeResult } from "./stage-runner-pause.js";
 
@@ -44,6 +45,7 @@ export class StageSessionController {
   private sessionSettingsManager: WorkflowFastModeSettingsManager | undefined;
   private readonly replacement = new StageSessionReplacement();
   private readonly messageAdmission = new StageMessageAdmission();
+  private readonly deliveryActivity = new StageDeliveryActivity();
 
   constructor(
     private readonly opts: StageRunnerOpts,
@@ -106,21 +108,25 @@ export class StageSessionController {
     return session;
   }
 
-  async sendUserMessage(content: StageUserMessageContent, options?: StageSendUserMessageOptions, beforeDelivery?: () => void):
-    Promise<Awaited<ReturnType<typeof sendStageUserMessage>>> {
+  async sendUserMessage(content: StageUserMessageContent, options?: StageSendUserMessageOptions,
+    beforeDelivery?: () => void, preparation?: StageUserMessagePreparation): Promise<Awaited<ReturnType<typeof sendStageUserMessage>>> {
     return this.messageAdmission.run(async (release) => {
-      const pausedDelivery = this.pauseControl.deferRunnerOwnedDelivery(
-        () => this.sendUserMessage(content, options, beforeDelivery),
-      );
-      if (pausedDelivery !== undefined) {
-        release();
-        return pausedDelivery;
-      }
-      return sendStageUserMessage(
-        await this.ensureSession("prompt"), content, options, beforeDelivery, release, this.messageAdmission,
+      const pausedDelivery = this.pauseControl.deferRunnerOwnedDelivery(() =>
+        this.sendUserMessage(content, options, beforeDelivery, preparation));
+      if (pausedDelivery !== undefined) { release(); return pausedDelivery; }
+      preparation?.beforePreparation?.();
+      const sessionFile = preparation?.sessionFile;
+      const deliver = async (activity?: StageDeliveryActivity) => sendStageUserMessage(
+        sessionFile === undefined ? await this.ensureSession("prompt")
+          : await this.ensureSessionFromFile(sessionFile, "prompt"),
+        content, options, beforeDelivery, release, this.messageAdmission, activity,
       );
+      if (this.session === undefined || sessionFile !== undefined) return this.deliveryActivity.runWithLease(() => deliver());
+      return deliver(this.deliveryActivity);
     });
   }
+  /** Internal pre-stream delivery lifecycle consumed by an attached stage chat. */
+  subscribeDeliveryActivity(listener: StageDeliveryActivityListener): () => void { return this.deliveryActivity.subscribe(listener); }
 
   sealGeneration(): void {
     this.generationSealed = true;
@@ -201,7 +207,7 @@ export class StageSessionController {
     this.pendingListeners.clear();
     this.unsubscribeTerminateWatcher?.();
     this.unsubscribeTerminateWatcher = undefined;
-    this.terminatingToolCallIds.clear(); this.messageAdmission.dispose();
+    this.terminatingToolCallIds.clear(); this.messageAdmission.dispose(); this.deliveryActivity.dispose();
     await this.replacement.dispose();
     await disposeStageSession(this.session);
   }

package/dist/builtin/workflows/src/runs/foreground/stage-runner-send-user-message.ts

@@ -1,4 +1,5 @@
 import type { StageSendUserMessageOptions, StageUserMessageContent } from "../../shared/types.js";
+import type { StageDeliveryActivity } from "./stage-delivery-activity.js";
 import type { StageMessageAdmission, StageMessageTurn } from "./stage-runner-message-admission.js";
 import type { StageSessionRuntime, StageUserMessageDeliveryAction } from "./stage-runner-types.js";
 
@@ -59,6 +60,7 @@ export async function sendStageUserMessage(
   beforeDelivery?: () => void,
   promptStarted?: () => void,
   admission?: StageMessageAdmission,
+  activity?: StageDeliveryActivity,
 ): Promise<StageUserMessageDeliveryAction> {
   const streaming = activeSession.isStreaming || admission?.isOwned(activeSession) === true;
   const deliverAs = streaming ? options?.deliverAs ?? "followUp" : options?.deliverAs;
@@ -71,6 +73,9 @@ export async function sendStageUserMessage(
         ? createLocalPromptOwnershipObserver(activeSession, promptStarted)
         : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
     ownership?.arm();
+    // An admitted idle delivery owns the visible Working period from here until
+    // it settles; a streaming delivery joins a turn that already owns it.
+    const deliveryId = streaming ? undefined : activity?.start();
     try {
       const delivery = activeSession.sendUserMessage(content, {
         ...(deliverAs === undefined ? {} : { deliverAs }),
@@ -89,6 +94,7 @@ export async function sendStageUserMessage(
       throw error;
     } finally {
       ownership?.dispose();
+      activity?.settle(deliveryId);
     }
   }
   if (typeof content !== "string") throw unsupportedContentError();
@@ -102,6 +108,7 @@ export async function sendStageUserMessage(
     ? createLocalPromptOwnershipObserver(activeSession, promptStarted)
     : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
   ownership.arm();
+  const deliveryId = activity?.start();
   try {
     const turn = activeSession.prompt(content);
     ownership.observeStreaming();
@@ -113,5 +120,6 @@ export async function sendStageUserMessage(
     throw error;
   } finally {
     ownership.dispose();
+    activity?.settle(deliveryId);
   }
 }

package/dist/builtin/workflows/src/runs/foreground/stage-runner-types.ts

@@ -29,6 +29,12 @@ export type WorkflowFastModeSettingsManager = {
 
 export type StageUserMessageDeliveryAction = "prompt" | "steer" | "followUp" | "handled";
 
+/** Internal session preparation and side-effect-free eligibility boundary. */
+export interface StageUserMessagePreparation {
+  readonly sessionFile?: string;
+  readonly beforePreparation?: () => void;
+}
+
 export interface StageUserMessageDeliveryHooks {
   readonly beforeDelivery?: () => void;
   /** Releases serialized admission once an idle prompt synchronously owns the turn. */
@@ -152,7 +158,17 @@ export interface InternalStageContext extends StageContext {
     content: StageUserMessageContent,
     options?: StageSendUserMessageOptions,
     beforeDelivery?: () => void,
+    preparation?: StageUserMessagePreparation,
   ): Promise<StageUserMessageDeliveryAction>;
+  /**
+   * Internal: subscribe to workflow-owned delivery lifecycle facts for this
+   * stage. An accepted idle delivery reports `delivery_start` before the public
+   * `agent_start` reaches subscribers, so an attached chat can paint Working
+   * for the whole turn rather than only after the SDK event queue drains.
+   */
+  __subscribeDeliveryActivity(
+    listener: (event: import("./stage-delivery-activity.js").StageDeliveryActivityEvent) => void,
+  ): () => void;
   /** Internal: synchronously reject new detached traffic without waiting for active work. */
   __sealGeneration(): void;
   /** Internal: atomically stop detached traffic admission and drain admitted work. */

package/dist/builtin/workflows/src/tui/stage-chat-view-delivery-activity.ts

@@ -0,0 +1,121 @@
+/**
+ * Maps workflow-owned stage delivery lifecycle facts onto the attached chat's
+ * existing Working lifecycle.
+ *
+ * A workflow definition that auto-sends to its own retained stage starts a real
+ * backend turn well before the public `agent_start` reaches this view. Without
+ * this bridge the pane sits with `sdkBusy=false` and no requested render while
+ * the model is already running, so it looks idle.
+ *
+ * Starting the host's ordinary lifecycle here — rather than synthesising an SDK
+ * event — keeps `agent_start`, `turn_start`, `turn_end`, `agent_end`, retry,
+ * fallback, compaction, and terminal cleanup in charge of everything after
+ * startup, and lets a settled delivery that never produced a turn clean up.
+ *
+ * cross-ref: src/runs/foreground/stage-delivery-activity.ts
+ */
+import type { StageDeliveryActivityEvent } from "../runs/foreground/stage-delivery-activity.js";
+import { isTerminalStageChatState } from "./stage-chat-view-status.js";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+
+export function subscribeStageChatDeliveryActivity(
+  ctx: StageChatViewContext,
+): (() => void) | null {
+  const handle = ctx.handle;
+  if (!handle?.subscribeDeliveryActivity) return null;
+  return handle.subscribeDeliveryActivity((event) => {
+    applyStageChatDeliveryActivityEvent(ctx, event);
+  });
+}
+
+export function applyStageChatDeliveryActivityEvent(
+  ctx: StageChatViewContext,
+  event: StageDeliveryActivityEvent,
+): void {
+  if (event.type === "delivery_start") {
+    // Replaces any lifecycle this same delivery id already owned; the map keeps
+    // one live token per delivery so settlement stays correlated. A start that
+    // arrives after terminal cleanup is fresh authorization for a retained
+    // post-mortem turn, so it also lifts the stale-start fence.
+    ctx.terminalLifecycleFenced = false;
+    ctx.deliveryLifecycles.set(event.deliveryId, ctx.chatHost.beginExternalPromptLifecycle());
+    return;
+  }
+  if (!ctx.deliveryLifecycles.has(event.deliveryId)) return;
+  const generation = ctx.deliveryLifecycles.get(event.deliveryId);
+  ctx.deliveryLifecycles.delete(event.deliveryId);
+  // A pre-turn compaction reasserts one lifecycle and hands the same token to
+  // every lease still open, so several deliveries can alias one generation.
+  // Only the last owner may settle it; otherwise the first lease to finish
+  // would stop Working while another accepted delivery is still running.
+  // Distinct generations — including stale ones — keep reaching the host's own
+  // generation fence exactly as before.
+  if (!ownsStageChatLifecycleGeneration(ctx, generation)) {
+    ctx.chatHost.settleExternalPromptLifecycle(generation);
+  }
+  // The map is the reference count: overlapping leases keep authorization open,
+  // and the last one to settle on a finished stage restores stale-start
+  // suppression. Otherwise the fence stayed open forever after the first
+  // post-terminal delivery and a late start could repaint a settled chat.
+  if (!hasActiveStageChatDelivery(ctx) && isStageChatContextTerminal(ctx)) {
+    ctx.terminalLifecycleFenced = true;
+  }
+}
+
+/** True while another still-active delivery references this exact lifecycle token. */
+function ownsStageChatLifecycleGeneration(
+  ctx: StageChatViewContext,
+  generation: number | undefined,
+): boolean {
+  for (const active of ctx.deliveryLifecycles.values()) {
+    if (active === generation) return true;
+  }
+  return false;
+}
+
+/** True while at least one admitted delivery still owns this chat's Working period. */
+export function hasActiveStageChatDelivery(ctx: StageChatViewContext): boolean {
+  return ctx.deliveryLifecycles.size > 0;
+}
+
+/** True when the last observed run or stage status is terminal. */
+export function isStageChatContextTerminal(ctx: StageChatViewContext): boolean {
+  return (
+    isTerminalStageChatState(ctx.lastObservedRunStatus) ||
+    isTerminalStageChatState(ctx.lastObservedStageStatus)
+  );
+}
+
+/**
+ * Restore delivery-owned Working after a temporary overlay ended.
+ *
+ * A pre-turn `compaction_end` clears busy state and the Working lifecycle even
+ * though the accepted delivery has not started its turn yet, so the pane would
+ * sit idle until the public `agent_start`. Reassertion preserves factual status
+ * text, so a compaction error still outranks ordinary Working.
+ */
+export function reconcileStageChatDeliveryLifecycle(ctx: StageChatViewContext): void {
+  if (!hasActiveStageChatDelivery(ctx)) return;
+  if (ctx.chatHost.isStreaming() && ctx.chatHost.hasAnimationTick()) return;
+  const generation = ctx.chatHost.reassertExternalPromptLifecycle();
+  for (const deliveryId of [...ctx.deliveryLifecycles.keys()]) {
+    ctx.deliveryLifecycles.set(deliveryId, generation);
+  }
+}
+
+/**
+ * Drop every delivery lease admitted before a workflow terminal transition and
+ * arm the stale-start fence.
+ *
+ * Those turns can no longer authorize activity on this chat, and keeping them
+ * would let a queued late `agent_start` restart Working on a finished stage. A
+ * settlement for a dropped id is then an ordinary unknown settlement.
+ *
+ * The fence is armed only by an observed transition. A chat that mounts onto an
+ * already-terminal stage never cleaned up in-flight work, so a later
+ * `agent_start` there is genuine retained-session work and stays visible.
+ */
+export function invalidateStageChatDeliveryLifecycles(ctx: StageChatViewContext): void {
+  ctx.deliveryLifecycles.clear();
+  ctx.terminalLifecycleFenced = true;
+}

package/dist/builtin/workflows/src/tui/stage-chat-view-live-events.ts

@@ -1,18 +1,60 @@
 import type { AgentSessionEvent } from "@bastani/atomic";
 import type { StageChatViewContext } from "./stage-chat-view-types.js";
 import { isTerminalStageChatState } from "./stage-chat-view-status.js";
+import {
+  hasActiveStageChatDelivery,
+  reconcileStageChatDeliveryLifecycle,
+} from "./stage-chat-view-delivery-activity.js";
 
 export function applyStageChatLiveHandleEvent(
   ctx: StageChatViewContext,
   event: AgentSessionEvent,
 ): void {
+  const staleTerminalStart = isStaleTerminalLifecycleStart(ctx, event);
   ctx.chatHost.applyAgentEvent(event);
+  if (staleTerminalStart) {
+    retainTerminalCleanup(ctx);
+    return;
+  }
+  if (isCompactionEndEvent(event)) reconcileStageChatDeliveryLifecycle(ctx);
   if (!shouldCleanupAfterLiveEvent(ctx, event)) return;
+  retainTerminalCleanup(ctx);
+}
+
+function retainTerminalCleanup(ctx: StageChatViewContext): void {
   const hadAnimationTick = ctx.chatHost.hasAnimationTick();
   ctx.chatHost.clearBusyForTerminalWorkflowStage();
   if (hadAnimationTick !== ctx.chatHost.hasAnimationTick()) ctx.requestRender?.();
 }
 
+/**
+ * A turn start queued before the stage finished must not repaint Working on a
+ * settled stage.
+ *
+ * The fence is armed only when this chat actually observed a terminal
+ * transition and cleaned up in-flight work. Work admitted after that carries
+ * its own authorization and is left alone: a live workflow delivery lease
+ * (including one replayed at attach time), or a prompt this chat submitted
+ * itself, which is already busy by the time its `agent_start` arrives.
+ * `turn_start` is guarded too, otherwise it would restart the lifecycle a
+ * suppressed `agent_start` just stopped.
+ */
+function isStaleTerminalLifecycleStart(
+  ctx: StageChatViewContext,
+  event: AgentSessionEvent,
+): boolean {
+  if (!ctx.terminalLifecycleFenced) return false;
+  const type = String((event as { type?: unknown }).type ?? "");
+  if (type !== "agent_start" && type !== "turn_start") return false;
+  if (hasActiveStageChatDelivery(ctx)) return false;
+  if (ctx.chatHost.isStreaming()) return false;
+  return isCurrentRunOrStageTerminal(ctx);
+}
+
+function isCompactionEndEvent(event: AgentSessionEvent): boolean {
+  return String((event as { type?: unknown }).type ?? "") === "compaction_end";
+}
+
 function shouldCleanupAfterLiveEvent(
   ctx: StageChatViewContext,
   event: AgentSessionEvent,

package/dist/builtin/workflows/src/tui/stage-chat-view-state.ts

@@ -18,6 +18,10 @@ import {
 } from "./stage-chat-view-types.js";
 import { noticeRow, noticeSummary } from "./stage-chat-view-transcript.js";
 import { applyStageChatLiveHandleEvent } from "./stage-chat-view-live-events.js";
+import {
+  invalidateStageChatDeliveryLifecycles,
+  subscribeStageChatDeliveryActivity,
+} from "./stage-chat-view-delivery-activity.js";
 import { replayPendingToolExecutions } from "./stage-chat-view-pending-tools.js";
 import { chatHostStyle, stageChatRenderSettings } from "./stage-chat-view-render-settings.js";
 import { hexToAnsi, RESET } from "./color-utils.js";
@@ -66,8 +70,11 @@ export function initializeStageChatView(
   ctx.lastObservedStageStatus = undefined;
   ctx.lastObservedRunStatus = undefined;
   ctx.seenNoticeIds = new Set<string>();
+  ctx.deliveryLifecycles = new Map<number, number | undefined>();
+  ctx.terminalLifecycleFenced = false;
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle = null;
+  ctx._unsubscribeDeliveryActivity = null;
   ctx._unsubscribeFooterData = null;
   ctx._unregisterStageUiHost = null;
   installFocusHold(ctx);
@@ -98,6 +105,10 @@ export function initializeStageChatView(
   ctx._unsubscribeFooterData = ctx.footerData?.onBranchChange(() => ctx.requestRender?.()) ?? null;
 
   if (ctx.handle) {
+    // Delivery activity first: its replay must be in place before the SDK
+    // stream, so a synchronously replayed `agent_start` on a retained terminal
+    // stage can see that a live delivery authorizes it.
+    ctx._unsubscribeDeliveryActivity = subscribeStageChatDeliveryActivity(ctx);
     ctx._unsubscribeHandle = ctx.handle.subscribe((event) => applyStageChatLiveHandleEvent(ctx, event));
   }
   ctx.chatHost.syncAnimationTick();
@@ -209,6 +220,8 @@ function handleStoreUpdate(ctx: StageChatViewContext): void {
   }
   if (isTerminalStageChatTransition(ctx.lastObservedStageStatus, currentStageStatus) || isTerminalStageChatTransition(ctx.lastObservedRunStatus, currentRunStatus)) {
     ctx.chatHost.clearBusyForTerminalWorkflowStage();
+    // Leases admitted before this transition can no longer authorize activity.
+    invalidateStageChatDeliveryLifecycles(ctx);
     changed = true;
   }
   ctx.lastObservedRunStatus = currentRunStatus;
@@ -468,6 +481,9 @@ export function disposeStageChatView(ctx: StageChatViewContext): void {
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle?.();
   ctx._unsubscribeHandle = null;
+  ctx._unsubscribeDeliveryActivity?.();
+  ctx._unsubscribeDeliveryActivity = null;
+  ctx.deliveryLifecycles.clear();
   ctx._unsubscribeFooterData?.();
   ctx._unsubscribeFooterData = null;
   releaseMountedCustomUi(ctx);

package/dist/builtin/workflows/src/tui/stage-chat-view-types.ts

@@ -162,8 +162,12 @@ export interface StageChatViewContext {
   lastObservedStageStatus: StageStatus | undefined;
   lastObservedRunStatus: RunStatus | undefined;
   seenNoticeIds: Set<string>;
+  deliveryLifecycles: Map<number, number | undefined>;
+  /** True once this chat observed a terminal transition and cleaned up in-flight work. */
+  terminalLifecycleFenced: boolean;
   _unsubscribeStore: (() => void) | null;
   _unsubscribeHandle: (() => void) | null;
+  _unsubscribeDeliveryActivity: (() => void) | null;
   _unsubscribeFooterData: (() => void) | null;
   _unregisterStageUiHost: (() => void) | null;
 }

package/dist/modes/interactive/components/chat-session-host-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat-session-host-actions.d.ts","sourceRoot":"","sources":["../../../../src/modes/interactive/components/chat-session-host-actions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAcpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAczE,wBAAgB,oBAAoB,CAClC,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BzD;AA4BD,wBAAsB,iBAAiB,CAAC,WAAW,SAAS,uBAAuB,EACjF,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,EACxC,IAAI,GAAE,MAAM,GAAG,UAAmB,EAClC,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CA8Gf;AAoBD,wBAAsB,0BAA0B,CAC9C,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAYzD;AAED,wBAAsB,oBAAoB,CAAC,WAAW,SAAS,uBAAuB,EACpF,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAsB,+BAA+B,CACnD,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBzD;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAkBnD"}
+{"version":3,"file":"chat-session-host-actions.d.ts","sourceRoot":"","sources":["../../../../src/modes/interactive/components/chat-session-host-actions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAepE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAczE,wBAAgB,oBAAoB,CAClC,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA0BzD;AA4BD,wBAAsB,iBAAiB,CAAC,WAAW,SAAS,uBAAuB,EACjF,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,EACxC,IAAI,GAAE,MAAM,GAAG,UAAmB,EAClC,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CA8Gf;AAID,wBAAsB,0BAA0B,CAC9C,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAYzD;AAED,wBAAsB,oBAAoB,CAAC,WAAW,SAAS,uBAAuB,EACpF,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAsB,+BAA+B,CACnD,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBzD;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,SAAS,uBAAuB,EAC3C,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAC,GAAG,OAAO,CAkBnD"}

package/dist/modes/interactive/components/chat-session-host-actions.js

@@ -1,6 +1,6 @@
 import { combineQueuedMessagesForEditor } from "../chat-input-actions.js";
 import { setChatSessionEditorText } from "./chat-session-host-editor.js";
-import { decrementOptimisticUserSignature, incrementOptimisticUserSignature, isChatSessionBashRunning, isChatSessionStreaming, notifyChatSessionStatus, notifyChatSessionWarning, requiredChatSessionCommand, startChatSessionWorkingLifecycle, stopChatSessionWorkingLifecycle, syncChatSessionAnimationTick, } from "./chat-session-host-runtime.js";
+import { decrementOptimisticUserSignature, incrementOptimisticUserSignature, isChatSessionBashRunning, isChatSessionStreaming, notifyChatSessionStatus, notifyChatSessionWarning, requiredChatSessionCommand, settleChatSessionPromptLifecycle, startChatSessionWorkingLifecycle, stopChatSessionWorkingLifecycle, syncChatSessionAnimationTick, } from "./chat-session-host-runtime.js";
 import { errorMessage, parseBashInput, userMessageSignature, } from "./chat-session-host-utils.js";
 function supportsQueuedMessagePause(session) {
     return typeof session?.pauseQueuedMessages === "function"
@@ -176,19 +176,7 @@ export async function submitChatSession(state, mode = "auto", submittedText) {
         state.requestRender?.();
     }
 }
-function settleSubmittedPromptLifecycle(state, submittedGeneration) {
-    if (submittedGeneration === undefined) {
-        state.sdkBusy = false;
-        return;
-    }
-    const lifecycleWasReplaced = state.workingLifecycleGeneration !== submittedGeneration;
-    if (lifecycleWasReplaced && state.workingLifecycleActive)
-        return;
-    state.sdkBusy = false;
-    if (!lifecycleWasReplaced && !isChatSessionStreaming(state)) {
-        stopChatSessionWorkingLifecycle(state);
-    }
-}
+const settleSubmittedPromptLifecycle = settleChatSessionPromptLifecycle;
 export async function abortChatSessionCompaction(state) {
     try {
         await state.commands.abortCompaction?.();