@pellux/goodvibes-tui 2.0.21 → 2.1.0

package/src/core/session-resume-core.ts

@@ -2,22 +2,22 @@
  * session-resume-core.ts, the ONE resume routine both resume seams call.
  *
  * Two independent call sites used to duplicate (and diverge from) this
- * sequence: `/session resume` (session-workflow.ts) and the panel/session-
- * browser resume (bootstrap-hook-bridge.ts's `createResumeSessionHandler`).
+ * sequence: `/session resume` (session-workflow.ts) and the session-browser
+ * resume (bootstrap-hook-bridge.ts's `createResumeSessionHandler`).
  * Divergences found by audit:
- *   - the panel seam skipped `restoreTurnAnchors` (message-anchored /rewind
- *     silently had no anchors after a panel resume)
- *   - the panel seam skipped `conversation.resetAll()` before `fromJSON()`
- *   - the panel seam skipped the `selectModel` reselection fallback (it set
- *     `runtime.model` straight from the saved meta, never re-resolving
+ *   - the session-browser seam skipped `restoreTurnAnchors` (message-anchored
+ *     /rewind silently had no anchors after a session-browser resume)
+ *   - the session-browser seam skipped `conversation.resetAll()` before
+ *     `fromJSON()`
+ *   - the session-browser seam skipped the `selectModel` reselection fallback
+ *     (it set `runtime.model` straight from the saved meta, never re-resolving
  *     through the live provider registry)
- *   - the panel seam duplicated the panel-reopen loop WITHOUT the
- *     modal-redirect skip, so a MIGRATE-TO-MODAL id could pop a modal
- *     mid-resume
+ *   - the session-browser seam reopened saved views without the modal
+ *     redirect, so a saved view id could pop a modal mid-resume (saved views
+ *     are no longer reopened at all)
  *
- * Both seams now call this module so those four behaviors (plus the
- * panel-reopen-cap honesty note) are guaranteed identical by construction,
- * not by copy-paste discipline between two files.
+ * Both seams now call this module so those behaviors are guaranteed
+ * identical by construction, not by copy-paste discipline between two files.
  *
  * Callers own everything ABOVE and AROUND this core sequence: printing or
  * logging the outcome in their own idiom (`ctx.print` vs `conversation.log`),
@@ -30,6 +30,7 @@ import type { SessionManager, SessionMeta } from '@pellux/goodvibes-sdk/platform
 import type { SessionSurface } from '@/runtime/index.ts';
 import type { ConversationManager } from './conversation.ts';
 import { restoreTurnAnchors } from '@pellux/goodvibes-sdk/platform/rewind';
+import { restoreWorkTreeFolds } from './work-tree-wiring.ts';
 import { replayJournalForSession, type ReplayIntoConversationResult } from '@pellux/goodvibes-sdk/platform/runtime/operations';
 
 export interface SessionResumeRuntime {
@@ -38,12 +39,6 @@ export interface SessionResumeRuntime {
   provider: string;
 }
 
-export interface SessionResumePanelManager {
-  open(id: string): unknown;
-  show(): void;
-  getModalRedirect(id: string): string | undefined;
-}
-
 export interface SessionResumeDeps {
   readonly sessionManager: Pick<SessionManager, 'load' | 'save'>;
   readonly conversation: ConversationManager;
@@ -56,7 +51,6 @@ export interface SessionResumeDeps {
    * seam.
    */
   readonly surface: SessionSurface;
-  readonly panelManager: SessionResumePanelManager;
   /**
    * Reselects the saved model through the live provider registry, falling
    * back to the raw saved id on failure (a saved model may no longer exist
@@ -64,20 +58,6 @@ export interface SessionResumeDeps {
    */
   readonly selectModel?: (model: string) => Promise<{ readonly registryKey: string; readonly providerId: string }>;
   readonly hydrateSessionUsage?: () => void;
-  /**
-   * Deliberate cap on how many saved panels are reopened at once, resuming
-   * into a workspace crowded with every panel that happened to be open is
-   * its own kind of surprise. Overflow beyond the cap is reported in the
-   * outcome (`panels.notReopened`), never silently dropped. Defaults to 4.
-   */
-  readonly panelReopenLimit?: number;
-}
-
-export interface PanelReopenOutcome {
-  readonly reopened: readonly string[];
-  readonly movedToModal: readonly string[];
-  /** Saved panel ids beyond `panelReopenLimit`, not attempted, honestly reported (see /panels to open the rest). */
-  readonly notReopened: readonly string[];
 }
 
 export interface SessionResumeOutcome {
@@ -85,51 +65,18 @@ export interface SessionResumeOutcome {
   readonly resumedMessageCount: number;
   readonly restoredAnchorCount: number;
   readonly journalReplay: ReplayIntoConversationResult;
-  readonly panels: PanelReopenOutcome;
-}
-
-/**
- * Exported so both session-workflow.ts's standalone `reopenPanelsFromReturnContext`
- * (kept for its existing direct unit-test coverage, see
- * session-workflow-panel-restore.test.ts) and `resumeSessionCore` below share
- * the exact same default cap.
- */
-export const DEFAULT_PANEL_REOPEN_LIMIT = 4;
-
-export function reopenPanelsWithModalSkip(
-  panelManager: SessionResumePanelManager,
-  openPanelIds: readonly string[] | undefined,
-  limit: number,
-): PanelReopenOutcome {
-  if (!openPanelIds || openPanelIds.length === 0) return { reopened: [], movedToModal: [], notReopened: [] };
-  const within = openPanelIds.slice(0, limit);
-  const overflow = openPanelIds.slice(limit);
-  const reopened: string[] = [];
-  const movedToModal: string[] = [];
-  for (const panelId of within) {
-    // A MIGRATE-TO-MODAL id has no panel to restore, a modal is not part of
-    // the saved panel layout. Skip it (don't pop a modal mid-resume) and note
-    // it once, rather than firing open() and revealing an empty workspace.
-    if (panelManager.getModalRedirect(panelId) !== undefined) {
-      movedToModal.push(panelId);
-      continue;
-    }
-    try {
-      panelManager.open(panelId);
-      reopened.push(panelId);
-    } catch {
-      // Ignore unknown or currently unavailable panel ids during resume.
-    }
-  }
-  if (reopened.length > 0) panelManager.show();
-  return { reopened, movedToModal, notReopened: overflow };
 }
 
 /**
  * The canonical resume sequence: load, reset + restore the conversation,
  * restore rewind anchors, replay any post-snapshot journal records, hydrate
- * footer usage, reselect the model, and reopen saved panels (modal-redirect
- * aware, cap honestly reported).
+ * footer usage and reselect the model.
+ *
+ * Sessions saved by an older TUI can carry a legacy pane list in their
+ * return context (`returnContext.openPanels` plus an "Open panels: ..."
+ * line). The SDK's session loader (`loadedReturnContext`) drops both, so
+ * `meta.returnContext` here never has them, and the journal-replay rewrite
+ * below writes the session back without them.
  */
 export async function resumeSessionCore(sessionId: string, deps: SessionResumeDeps): Promise<SessionResumeOutcome> {
   const { meta, messages } = deps.sessionManager.load(sessionId);
@@ -140,6 +87,8 @@ export async function resumeSessionCore(sessionId: string, deps: SessionResumeDe
     title: meta.title,
     titleSource: meta.titleSource,
   });
+  // The work tree's folds (turns, lanes, open beads) come back with the session.
+  restoreWorkTreeFolds(deps.conversation, deps.surface.sessionsDir, sessionId);
   deps.conversation.rebuildHistory();
   deps.runtime.sessionId = sessionId;
 
@@ -190,17 +139,10 @@ export async function resumeSessionCore(sessionId: string, deps: SessionResumeDe
   }
   if (meta.provider) deps.runtime.provider = meta.provider;
 
-  const panels = reopenPanelsWithModalSkip(
-    deps.panelManager,
-    meta.returnContext?.openPanels,
-    deps.panelReopenLimit ?? DEFAULT_PANEL_REOPEN_LIMIT,
-  );
-
   return {
     meta,
     resumedMessageCount: deps.conversation.getMessageCount(),
     restoredAnchorCount,
     journalReplay,
-    panels,
   };
 }

package/src/core/stream-event-wiring.ts

@@ -38,6 +38,13 @@ export interface StreamMetrics {
    * the synthetic 'live' render id.
    */
   activeToolCallId: string | undefined;
+  /**
+   * Arguments of the tool calls received this turn, by callId (from
+   * TOOL_RECEIVED), so the throbber can name the running call's key argument.
+   * An entry is dropped when its call finishes (succeeded, failed or
+   * cancelled), and the map keeps at most 64 entries, oldest dropped first.
+   */
+  toolArgsByCallId: Map<string, Record<string, unknown>>;
   /**
    * Epoch ms of the most recent STREAM_START or STREAM_DELTA; undefined when
    * idle (no turn in flight). Read every render frame, not just on the
@@ -68,6 +75,7 @@ export function createStreamMetrics(): StreamMetrics {
   return {
     startTime: 0, deltaCount: 0, tokenSpeed: 0, ttftMs: undefined, ttftRecorded: false,
     activeToolStartedAtMs: undefined, activeToolName: undefined, activeToolCallId: undefined,
+    toolArgsByCallId: new Map(),
     lastDeltaAtMs: undefined, stallEpisode: 0,
     reconnectAttempt: undefined, reconnectMaxAttempts: undefined,
   };
@@ -194,6 +202,14 @@ export interface WireStreamEventMetricsOptions {
    * in silence on a backend the user did not choose.
    */
   readonly retryTurn?: (notice?: string) => boolean;
+  /**
+   * Called synchronously, inside the TURN_ERROR handler, when failover has
+   * re-submitted the turn (retryTurn returned true). main.ts passes
+   * turn-event-wiring's continueTurnAfterFailover, so the failed attempt is
+   * not told as its own turn: one notice per user turn, for how it finally
+   * ended.
+   */
+  readonly onFailoverRetry?: () => void;
   /**
    * Optional cost catalog for attaching per-1M-token cost information to
    * the failover notice.  When provided and both models have non-zero pricing,
@@ -352,7 +368,7 @@ export function wireStreamEventMetrics(
 ): WireStreamEventMetricsResult {
   const {
     events, metrics, orchestrator, providerRegistry,
-    systemMessageRouter, render, providerOptimizer, retryTurn, costLookup,
+    systemMessageRouter, render, providerOptimizer, retryTurn, onFailoverRetry, costLookup,
     isApprovalPending, stallThresholdMs, failoverState, getConfiguredRegistryKey,
     getConfiguredReasoningEffort,
   } = options;
@@ -636,7 +652,9 @@ export function wireStreamEventMetrics(
         // retryTurn option doc). Emitting it here instead would delete it.
         const failoverNotice = `[Failover] ${fromProvider} -> ${next.providerId} (${errorClass})${billingSuffix}${costSuffix}`
           + (effortNote ? `\n[Failover] ${effortNote}` : '');
-        if (!retryTurn(failoverNotice)) {
+        if (retryTurn(failoverNotice)) {
+          onFailoverRetry?.();
+        } else {
           // No turn to re-submit (the failed turn did not come from the
           // composer, so there is no pre-submission snapshot to roll back to).
           // The registry has still MOVED, so the switch gets narrated here and
@@ -714,6 +732,11 @@ export function wireStreamEventMetrics(
     render();
   }));
 
+  unsubs.push(events.tools.on('TOOL_RECEIVED', (ev) => {
+    // Bounded: a turn that never finishes its calls cannot grow this without limit.
+    if (metrics.toolArgsByCallId.size >= 64) metrics.toolArgsByCallId.delete(metrics.toolArgsByCallId.keys().next().value!);
+    metrics.toolArgsByCallId.set(ev.callId, ev.args ?? {});
+  }));
   unsubs.push(events.tools.on('TOOL_EXECUTING', (ev) => {
     metrics.activeToolStartedAtMs = ev.startedAt;
     metrics.activeToolName = ev.tool;
@@ -728,19 +751,22 @@ export function wireStreamEventMetrics(
   // delta), the very next frame would read msSinceLastDelta as the full
   // tool-execution duration and immediately report a stall, even though the
   // model hasn't had a chance to resume producing tokens yet.
-  unsubs.push(events.tools.on('TOOL_SUCCEEDED', () => {
+  unsubs.push(events.tools.on('TOOL_SUCCEEDED', (ev) => {
+    metrics.toolArgsByCallId.delete(ev.callId);
     metrics.activeToolStartedAtMs = undefined;
     metrics.activeToolName = undefined;
     metrics.activeToolCallId = undefined;
     metrics.lastDeltaAtMs = Date.now();
   }));
-  unsubs.push(events.tools.on('TOOL_FAILED', () => {
+  unsubs.push(events.tools.on('TOOL_FAILED', (ev) => {
+    metrics.toolArgsByCallId.delete(ev.callId);
     metrics.activeToolStartedAtMs = undefined;
     metrics.activeToolName = undefined;
     metrics.activeToolCallId = undefined;
     metrics.lastDeltaAtMs = Date.now();
   }));
-  unsubs.push(events.tools.on('TOOL_CANCELLED', () => {
+  unsubs.push(events.tools.on('TOOL_CANCELLED', (ev) => {
+    metrics.toolArgsByCallId.delete(ev.callId);
     metrics.activeToolStartedAtMs = undefined;
     metrics.activeToolName = undefined;
     metrics.activeToolCallId = undefined;

package/src/core/system-message-noise.ts

@@ -4,7 +4,7 @@
  * source these rules catch is emitted (from the SDK) through
  * SystemMessageRouter, so this one funnel is where first-run plumbing is kept
  * out of the user's stream while the information stays reachable elsewhere
- * (fleet panel, /health, /model, activity log). (item 1.)
+ * (Agents modal, /health, /model, activity log). (item 1.)
  */
 
 export interface NoiseGateDeps {
@@ -48,7 +48,7 @@ export function classifyNoise(message: string, deps: NoiseGateDeps): NoiseVerdic
   }
 
   // 1d, periodic "[Agents] N running:" status snapshot. The same live detail
-  // is shown in the fleet panel (per-agent activity) and the footer count, so
+  // is shown in the Agents modal (per-agent activity) and the footer count, so
   // the 30-second transcript churn is dropped. Meaningful lifecycle lines
   // ("[Agents] ✓ …", "[Agents] Cohort …", "[Agents] ✗ …") do not match.
   if (AGENTS_RUNNING_SNAPSHOT_RE.test(message)) {

package/src/core/system-message-router.ts

@@ -5,20 +5,19 @@
  * Delivery is resolved from the message KIND ('system' | 'wrfc' |
  * 'operational'), which maps to a configurable routing target
  * (ui.systemMessages / ui.wrfcMessages / ui.operationalMessages, each
- * 'panel' | 'conversation' | 'both'). resolveSystemMessageDelivery() turns
- * that target, plus whether a panel is attached, into a { toPanel,
- * toConversation } decision.
+ * 'panel' | 'conversation' | 'both', the SDK's target names). resolveSystemMessageDelivery()
+ * turns that target, plus whether a side surface is attached (the SDK's
+ * `hasPanel` argument), into a { toPanel, toConversation } decision.
  *
- * (the purge): the SystemMessagesPanel this router used to optionally
- * push into was DELETE-disposition (no surviving human surface, a picker
- * over the old panel registry, not something worth a dedicated console) and
- * has been removed entirely, so this router now always resolves with
+ * (the purge): the side surface this router used to optionally push into
+ * was DELETE-disposition (no surviving human surface, not something worth a
+ * dedicated console) and has been removed entirely, so this router now always resolves with
  * `hasPanel = false`. Per resolveSystemMessageDelivery's own contract that
- * means EVERY kind/target combination (including 'panel'-only) falls back
+ * means EVERY kind/target combination (including 'panel'-target) falls back
  * to `toConversation: true`, nothing this router routes can vanish; it all
  * reaches conversation.addTypedSystemMessage(), which the transcript
  * renders as a navigable system line. This is deliberate, not a regression:
- * operational chatter that used to be tucked away in a rarely-opened panel
+ * operational chatter that used to be tucked away in a rarely-opened side surface
  * now surfaces inline, same as the messages that were already forced there
  * (see FORCE_CONVERSATION_PREFIXES below).
  *
@@ -61,7 +60,7 @@ export type {
   SystemMessageTarget,
 } from '@/runtime/index.ts';
 
-/** Panel emphasis level. Panel delivery was removed in (see file doc); kept as the priority vocabulary for callers and for the SDK's delivery-resolution signature. */
+/** Emphasis level. Side-surface delivery was removed (see file doc); kept as the priority vocabulary for callers and for the SDK's delivery-resolution signature. */
 export type SystemMessagePriority = 'high' | 'low';
 
 /**
@@ -88,7 +87,7 @@ function mustReachConversation(message: string): boolean {
 
 /**
  * Routes system messages to the conversation based on priority level and
- * configured target. See file doc for the panel removal.
+ * configured target. See file doc for the side-surface removal.
  */
 export class SystemMessageRouter {
   /** Buffered provider "from last session" replay lines, folded on a microtask. */
@@ -113,7 +112,7 @@ export class SystemMessageRouter {
    *
    * @param message  - Message text.
    * @param priority - 'high' | 'low' (kept for callers; no longer changes
-   *                   delivery now that there is no panel to emphasize on).
+   *                   delivery now that there is no side surface to emphasize on).
    * @param kind     - Classification kind ('system' | 'wrfc' | 'operational');
    *                   used to resolve routing target and conversation navigability.
    */
@@ -137,7 +136,7 @@ export class SystemMessageRouter {
   /** Post-noise-gate delivery: resolve target and append to the conversation. */
   private deliver(message: string, kind: SystemMessageKind): void {
     const target = this.getTargetForKind(kind);
-    // hasPanel is always false now that panel delivery was removed, resolveSystemMessageDelivery's own
+    // hasPanel is always false now that side-surface delivery was removed, resolveSystemMessageDelivery's own
     // contract means every target ('panel' | 'conversation' | 'both')
     // resolves toConversation: true in that case (see file doc).
     const delivery = resolveSystemMessageDelivery(target, false);
@@ -227,10 +226,9 @@ export class SystemMessageRouter {
 
   /**
    * Route a message that must reach the conversation unconditionally. Skips
-   * the noise gate and the configured routing target, and marks the message
-   * `isUserReceipt` so the splash check in
-   * ConversationManager.rebuildHistory() treats it as real visible content,
-   * otherwise it would be invisible while the splash still owns the screen.
+   * the noise gate and the configured routing target. Like every system
+   * message it shows as a toast and stays in the notification history
+   * (core/notices.ts), so it is seen even while the splash owns the screen.
    *
    * Two callers qualify today:
    *   - a receipt for an explicit user action at this shell (answering the
@@ -244,7 +242,7 @@ export class SystemMessageRouter {
    *     guarantee rather than a second string match.
    */
   userReceipt(message: string): void {
-    this.conversation.addTypedSystemMessage(message, classifySystemMessageKind(message), { isUserReceipt: true });
+    this.conversation.addTypedSystemMessage(message, classifySystemMessageKind(message));
   }
 }