@pellux/goodvibes-agent 1.4.4 → 1.5.0

package/src/{panels → runtime}/provider-account-snapshot.ts

@@ -1,7 +1,7 @@
 import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import type {
   ProviderAccountInspectionQuery,
-} from '../runtime/ui-service-queries.ts';
+} from './ui-service-queries.ts';
 
 export type ProviderAuthRoute = 'api-key' | 'subscription' | 'service-oauth' | 'unconfigured';
 export type ProviderAuthFreshness = 'healthy' | 'expiring' | 'expired' | 'pending' | 'unconfigured';
@@ -261,7 +261,10 @@ export async function buildProviderAccountSnapshot(
             : 'No usable auth route is configured for this provider.',
       authFreshness: freshness,
       fallbackRoute: activeRoute !== preferredRoute ? activeRoute : undefined,
-      fallbackRisk: hasSubscription && hasApiKey
+      // D7 fix: fallbackRisk is only meaningful when a fallbackRoute exists (i.e. activeRoute
+      // differs from preferredRoute). Setting it on a healthy provider where activeRoute===
+      // preferredRoute would show a spurious risk advisory with no fallback target.
+      fallbackRisk: (activeRoute !== preferredRoute) && hasSubscription && hasApiKey
         ? (isExpired(subscription?.expiresAt)
           ? 'preferred subscription path is expired; active route falls back to API key.'
           : 'Both subscription and API key are present; check route priority.')

package/src/runtime/services.ts

@@ -46,7 +46,6 @@ import { IntegrationHelperService } from '@/runtime/index.ts';
 import { VoiceProviderRegistry, VoiceService, ensureBuiltinVoiceProviders } from '@pellux/goodvibes-sdk/platform/voice';
 import { WebSearchProviderRegistry, WebSearchService } from '@pellux/goodvibes-sdk/platform/web-search';
 import { MemoryEmbeddingProviderRegistry } from '@pellux/goodvibes-sdk/platform/state';
-import { PanelManager } from '../panels/panel-manager.ts';
 import { HookActivityTracker } from '@pellux/goodvibes-sdk/platform/hooks';
 import { HookDispatcher, createHookWorkbench, type HookWorkbench } from '@pellux/goodvibes-sdk/platform/hooks';
 import { PluginManager } from '@pellux/goodvibes-sdk/platform/plugins';
@@ -388,7 +387,6 @@ export interface RuntimeServices extends SdkRuntimeServices {
   readonly runtimeBus: RuntimeEventBus;
   readonly runtimeStore: RuntimeStore;
   readonly runtimeDispatch: DomainDispatch;
-  readonly panelManager: PanelManager;
   readonly keybindingsManager: KeybindingsManager;
   readonly routeBindings: RouteBindingManager;
   readonly surfaceRegistry: SurfaceRegistry;
@@ -488,7 +486,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const featureFlags = options.featureFlags ?? createFeatureFlagManager();
   const runtimeDispatch = createDomainDispatch(options.runtimeStore);
   const gatewayMethods = new GatewayMethodCatalog();
-  const panelManager = new PanelManager();
   const keybindingsManager = new KeybindingsManager({
     configPath: shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'keybindings.json'),
   });
@@ -738,6 +735,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const tokenAuditor = new ApiTokenAuditor({ managed: false });
   const componentHealthMonitor = new ComponentHealthMonitor();
   const worktreeRegistry = createDisabledAgentWorktreeRegistry(workingDirectory);
+  // Configured and attached to the runtime bus during bootstrap when webhook URLs are present.
   const webhookNotifier = new WebhookNotifier();
   const replayEngine = new DeterministicReplayEngine(workingDirectory);
   const providerOptimizer = new ProviderOptimizer(providerRegistry, providerCapabilityRegistry, false);
@@ -761,9 +759,24 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const modeManager = new ModeManager();
   const fileUndoManager = new FileUndoManager();
   const executionLedger = new AgentExecutionLedger(options.runtimeBus);
+  // The SDK's foundation/integration contracts still expect a panel manager;
+  // the Agent shell has no panel UI (the Activity sidebar replaced it), so we
+  // satisfy those contracts with a no-op implementation.
+  const NOOP_PANEL_MANAGER = (() => {
+    const emptyPane = { panels: [], activeIndex: 0 } as const;
+    return {
+      getTopPane: () => emptyPane,
+      getBottomPane: () => emptyPane,
+      getRegisteredTypes: () => [],
+      open: () => undefined,
+      show: () => {},
+    };
+  })();
+  const panelManager = NOOP_PANEL_MANAGER;
   const integrationHelpers = new IntegrationHelperService({
     workingDirectory,
     homeDirectory,
+    panelManager,
     runtimeStore: options.runtimeStore,
     runtimeBus: options.runtimeBus,
     configManager,
@@ -774,7 +787,6 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     distributedRuntime,
     remoteRunnerRegistry,
     remoteSupervisor,
-    panelManager,
     localUserAuthManager,
     providerRegistry,
     serviceRegistry,

package/src/runtime/terminal-output-guard.ts

@@ -89,6 +89,13 @@ export function allowTerminalWrite<T>(fn: () => T): T {
 }
 
 export function installTerminalOutputGuard(options: TerminalOutputGuardOptions): TerminalOutputGuard {
+  // D6 fix: if a guard already exists and hasn't been disposed, dispose it first
+  // so the monkeypatch chain is cleanly unwound BEFORE we snapshot the originals.
+  // This ensures stdout.write is the real underlying write when we capture it below.
+  if (currentGuard !== null) {
+    currentGuard.dispose();
+  }
+
   const stdout = options.stdout;
   const stderr = options.stderr ?? process.stderr;
   const originalStdoutWriteMethod = stdout.write;

package/src/runtime/tool-permission-safety.ts

@@ -71,7 +71,7 @@ const READ_ONLY_MEMORY_ACTIONS = new Set(['', 'status', 'summary', 'posture', 'm
 const READ_ONLY_COMPUTER_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'computer', 'computer_use', 'plan', 'route', 'control_plan', 'browser_plan', 'desktop_plan', 'control', 'browser_control', 'desktop', 'desktop_control', 'screenshot', 'screen', 'screen_recording', 'observe', 'browser', 'pwa', 'cockpit', 'browser_cockpit', 'web', 'setup', 'configure', 'browser_desktop_control', 'mcp', 'tools', 'servers', 'mcp_servers']);
 const READ_ONLY_DEVICE_ACTIONS = new Set(['', 'status', 'map', 'capabilities', 'device', 'devices', 'mobile', 'phone', 'pairing', 'capability', 'route', 'pairing_route', 'show', 'inspect', 'browser', 'pwa', 'cockpit', 'browser_cockpit', 'web', 'control', 'browser_control', 'desktop', 'desktop_control', 'computer_use', 'voice', 'media', 'voice_media', 'workflows', 'provider', 'media_provider', 'voice_provider']);
 const READ_ONLY_MODELS_ACTIONS = new Set(['', 'status', 'routing', 'routes', 'models', 'model', 'readiness', 'route_readiness', 'route', 'model_route', 'inspect', 'show', 'candidate', 'endpoint', 'local', 'cookbook', 'local_cookbook', 'recipes', 'recipe', 'ollama', 'llama_cpp', 'llamacpp', 'vllm', 'local_servers', 'providers', 'provider_accounts', 'accounts', 'subscriptions', 'auth', 'logins', 'provider', 'provider_account', 'account', 'subscription', 'auth_status']);
-const READ_ONLY_WORKSPACE_ACTIONS = new Set(['', 'status', 'summary', 'home', 'workspace', 'categories', 'workspace_categories', 'actions', 'list_actions', 'workspace_actions', 'tasks', 'action', 'show', 'inspect', 'workspace_action', 'surfaces', 'ui_surfaces', 'screens', 'views', 'surface', 'ui_surface', 'screen', 'view', 'panels', 'panes', 'panel', 'pane', 'shortcuts', 'shortcut_help', 'help', 'keybindings', 'bindings', 'keys', 'keybinding', 'binding', 'key', 'commands', 'slash_commands', 'command_catalog', 'command', 'slash_command', 'inspect_command', 'cli_commands', 'cli_catalog', 'cli_command', 'inspect_cli_command']);
+const READ_ONLY_WORKSPACE_ACTIONS = new Set(['', 'status', 'summary', 'home', 'workspace', 'categories', 'workspace_categories', 'actions', 'list_actions', 'workspace_actions', 'tasks', 'action', 'show', 'inspect', 'workspace_action', 'surfaces', 'ui_surfaces', 'screens', 'views', 'surface', 'ui_surface', 'screen', 'view', 'shortcuts', 'shortcut_help', 'help', 'keybindings', 'bindings', 'keys', 'keybinding', 'binding', 'key', 'commands', 'slash_commands', 'command_catalog', 'command', 'slash_command', 'inspect_command', 'cli_commands', 'cli_catalog', 'cli_command', 'inspect_cli_command']);
 const READ_ONLY_AUTONOMY_ACTIONS = new Set(['', 'intake', 'request', 'route', 'plan', 'triage', 'autonomy_intake', 'queue', 'list', 'work', 'ongoing', 'autonomy_queue', 'item', 'card', 'show', 'inspect', 'autonomy_queue_item', 'status', 'summary', 'overview']);
 const READ_ONLY_DELEGATION_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'policy', 'decision', 'decisions', 'delegation_posture', 'routes', 'list', 'catalog', 'posture', 'route', 'item', 'card', 'show', 'inspect', 'delegation_route']);
 const READ_ONLY_EXECUTION_ACTIONS = new Set(['', 'status', 'summary', 'overview', 'routes', 'posture', 'execution_posture', 'route', 'show_route', 'inspect_route', 'execution_route', 'history', 'activity', 'records', 'execution_history', 'record', 'item', 'show', 'inspect', 'execution_history_item', 'processes', 'background', 'backgrounds', 'background_processes', 'capabilities', 'process_capabilities', 'process', 'background_process', 'recovery', 'file_recovery', 'undo_redo']);

package/src/runtime/ui/model-picker/data-provider.ts

@@ -84,7 +84,7 @@ export class ModelPickerDataProvider {
    */
   public subscribe(callback: () => void): () => void {
     this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
+    return () => { this._subscribers.delete(callback); };
   }
 
   /**

package/src/runtime/ui/model-picker/health-enrichment.ts

@@ -18,7 +18,7 @@ import type {
   ProviderHealthContext,
   CapabilityFlags,
   ProviderLatencyStats,
-} from '@/runtime/index.ts';
+} from './types.ts';
 
 /** Status sort priority (lower = shown first). */
 const STATUS_ORDER: Record<string, number> = {
@@ -46,7 +46,7 @@ function buildHealthContext(record: ProviderHealthRecord | undefined): ProviderH
   if (record.stats.totalCalls > 0) {
     latency = {
       avgMs: record.stats.avgLatencyMs,
-      p95Ms: record.stats.maxLatencyMs,
+      maxMs: record.stats.maxLatencyMs,
       minMs: record.stats.minLatencyMs,
     };
   }

package/src/runtime/ui/model-picker/types.ts

@@ -32,8 +32,8 @@ export interface CapabilityFlags {
 export interface ProviderLatencyStats {
   /** Moving average latency in ms (last N calls). */
   readonly avgMs: number;
-  /** Approximate 95th-percentile latency in ms (max of recent observations). */
-  readonly p95Ms: number;
+  /** Maximum observed latency in ms (max of recent observations). */
+  readonly maxMs: number;
   /** Minimum observed latency in ms. */
   readonly minMs: number;
 }

package/src/runtime/ui/provider-health/data-provider.ts

@@ -15,7 +15,7 @@ import type {
   ProviderHealthEntry,
   HealthTimeline,
   HealthTimelinePoint,
-} from '@/runtime/index.ts';
+} from './types.ts';
 
 /**
  * Number of timeline points retained per provider.
@@ -87,7 +87,7 @@ export class ProviderHealthDataProvider {
    */
   public subscribe(callback: () => void): () => void {
     this._subscribers.add(callback);
-    return () => this._subscribers.delete(callback);
+    return () => { this._subscribers.delete(callback); };
   }
 
   /**
@@ -196,7 +196,7 @@ export class ProviderHealthDataProvider {
         isConfigured: record.isConfigured,
         successRate,
         errorRate,
-        p95LatencyMs: record.stats.maxLatencyMs,
+        maxLatencyMs: record.stats.maxLatencyMs,
         avgLatencyMs: record.stats.avgLatencyMs,
         totalCalls: total,
         // cacheHitRate is populated only when cache-capability is wired to the provider record.

package/src/runtime/ui/provider-health/types.ts

@@ -59,8 +59,8 @@ export interface ProviderHealthEntry {
   readonly successRate: number;
   /** Error rate (0–1), derived from totalCalls and errorCalls. */
   readonly errorRate: number;
-  /** Approximate p95 latency in ms (max of recent observations). */
-  readonly p95LatencyMs: number;
+  /** Maximum observed latency in ms (max of recent observations). */
+  readonly maxLatencyMs: number;
   /** Moving average latency in ms. */
   readonly avgLatencyMs: number;
   /** Total API calls recorded. */

package/src/runtime/ui-services.ts

@@ -19,7 +19,6 @@ export interface UiEnvironmentServices {
 
 export interface UiShellServices {
   readonly keybindingsManager: RuntimeServices['keybindingsManager'];
-  readonly panelManager: RuntimeServices['panelManager'];
   readonly processManager: RuntimeServices['processManager'];
   readonly profileManager: RuntimeServices['profileManager'];
   readonly bookmarkManager: RuntimeServices['bookmarkManager'];
@@ -135,7 +134,6 @@ export function createUiRuntimeServices(
     },
     shell: {
       keybindingsManager: runtimeServices.keybindingsManager,
-      panelManager: runtimeServices.panelManager,
       processManager: runtimeServices.processManager,
       profileManager: runtimeServices.profileManager,
       bookmarkManager: runtimeServices.bookmarkManager,

package/src/shell/agent-workspace-fullscreen.ts

@@ -28,7 +28,6 @@ export function createFullscreenCompositeFromLines(
     viewport: normalizeFullscreenViewport(lines, width, height),
     footer: [],
     forceFullRedraw: true,
-    panelWidth: 0,
   };
 }
 

package/src/shell/autonomy-surfacing.ts

@@ -0,0 +1,272 @@
+/**
+ * Ambient autonomy surfacing module.
+ *
+ * HISTORY: this factory was extracted from main.ts to keep that file under the
+ * 800-line cap. After extraction it gained two capabilities:
+ *   1. Calendar merging — listCalendarEvents callback merges upcoming events
+ *      into the Coming-up sidebar alongside scheduled jobs (buildCalendarEventsLister).
+ *   2. Skill-draft accrual — onAwayDigest callback runs skill-draft proposal
+ *      once per away-digest pass and appends a feed line when drafts are created
+ *      (buildSkillDraftProposer).
+ * These additions are NOT "no behavior change" refactors; they add real surface.
+ */
+
+import { buildAwayDigest, formatDigestTime, formatRelativeTime } from '../core/away-digest.ts';
+import { LastSeenStore } from '../core/last-seen-store.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { AgentCalendarRegistry } from '../agent/calendar-registry.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import { runSkillDraftProposer } from '../agent/skill-draft-runner.ts';
+import type { CommandContext } from '../input/command-registry.ts';
+
+interface AutomationJobLike {
+  readonly name: string;
+  readonly enabled: boolean;
+  readonly nextRunAt?: number;
+  readonly lastRunAt?: number;
+  readonly runCount?: number;
+}
+
+interface ApprovalLike {
+  readonly status: string;
+}
+
+interface AutonomyMessageRouter {
+  high(message: string): void;
+  getFeed(): { push(text: string, priority?: 'high' | 'low', kind?: string): void } | null;
+}
+
+export interface AutonomySurfacingOptions {
+  readonly shellPaths: Parameters<typeof LastSeenStore.fromShellPaths>[0];
+  readonly listAutomationJobs: () => readonly AutomationJobLike[];
+  readonly listApprovals: () => readonly ApprovalLike[];
+  readonly getTasksSnapshot: () => readonly unknown[];
+  readonly router: AutonomyMessageRouter;
+  readonly render: () => void;
+  /**
+   * Optional callback to list upcoming local calendar events.
+   * Each item carries a formatted label and a numeric sort key (ms since epoch)
+   * so the Coming up section merges calendar and job entries chronologically.
+   */
+  readonly listCalendarEvents?: () => readonly { label: string; start: number }[];
+  /**
+   * Optional callback invoked once per announceAwayDigest pass.
+   * Should run skill draft proposal and return the count of drafts created.
+   * When > 0, a line is appended to the digest feed.
+   */
+  readonly onAwayDigest?: () => number;
+}
+
+const COMING_UP_TTL_MS = 60_000;
+const FETCH_TIMEOUT_MS = 2500;
+const LAST_SEEN_REFRESH_MS = 5 * 60_000;
+
+/**
+ * Ambient autonomy surfacing for the shell: the launch "While you were away"
+ * digest and the sidebar's Coming up entries. Everything here is best-effort
+ * and offline-tolerant — failures are silent and renders are never blocked.
+ */
+export function createAutonomySurfacing(options: AutonomySurfacingOptions) {
+  const lastSeenStore = LastSeenStore.fromShellPaths(options.shellPaths);
+
+  // Refresh lastSeenAt every 5 minutes so rapid restarts still detect activity.
+  const lastSeenRefreshInterval = setInterval(() => {
+    lastSeenStore.save();
+  }, LAST_SEEN_REFRESH_MS);
+  lastSeenRefreshInterval.unref();
+
+  const comingUpCache: { items: string[]; fetchedAt: number | null; fetching: boolean } = {
+    items: [],
+    fetchedAt: null,
+    fetching: false,
+  };
+
+  function refreshComingUp(): void {
+    if (comingUpCache.fetching) return;
+    const now = Date.now();
+    if (comingUpCache.fetchedAt !== null && now - comingUpCache.fetchedAt < COMING_UP_TTL_MS) return;
+    comingUpCache.fetching = true;
+    Promise.resolve().then(() => {
+      try {
+        const jobs = options.listAutomationJobs();
+        const jobItems: Array<{ label: string; sortKey: number }> = jobs
+          .filter((job) => job.enabled && job.nextRunAt !== undefined && job.nextRunAt > now)
+          .sort((a, b) => (a.nextRunAt ?? 0) - (b.nextRunAt ?? 0))
+          .map((job) => {
+            const when = job.nextRunAt ? formatRelativeTime(job.nextRunAt, now) : '';
+            const name = job.name.length > 22 ? `${job.name.slice(0, 20)}…` : job.name;
+            return { label: when ? `${name} — ${when}` : name, sortKey: job.nextRunAt ?? 0 };
+          });
+
+        const calItems: Array<{ label: string; sortKey: number }> = [];
+        if (options.listCalendarEvents) {
+          try {
+            for (const ev of options.listCalendarEvents()) {
+              calItems.push({ label: ev.label, sortKey: ev.start });
+            }
+          } catch {
+            // Calendar unavailable — skip silently.
+          }
+        }
+
+        comingUpCache.items = [...jobItems, ...calItems]
+          .sort((a, b) => a.sortKey - b.sortKey)
+          .slice(0, 3)
+          .map((item) => item.label);
+        comingUpCache.fetchedAt = Date.now();
+      } catch {
+        // Offline or manager unavailable — leave cache as-is.
+      } finally {
+        comingUpCache.fetching = false;
+      }
+    }).catch(() => {
+      comingUpCache.fetching = false;
+    });
+  }
+
+  function announceAwayDigest(): void {
+    void (async () => {
+      try {
+        const lastSeenAt = lastSeenStore.read();
+        const withTimeout = <T>(get: () => T) => Promise.race([
+          Promise.resolve(get()),
+          new Promise<never>((_, reject) => setTimeout(() => reject(new Error('timeout')), FETCH_TIMEOUT_MS)),
+        ]);
+
+        const [jobsResult, tasksResult] = await Promise.allSettled([
+          withTimeout(options.listAutomationJobs),
+          withTimeout(options.getTasksSnapshot),
+        ]);
+        const jobs = jobsResult.status === 'fulfilled' ? jobsResult.value : [];
+        const allTasks = tasksResult.status === 'fulfilled' ? tasksResult.value : [];
+
+        const firedSchedules = lastSeenAt !== null
+          ? jobs
+            .filter((job) => job.lastRunAt !== undefined && job.lastRunAt > lastSeenAt)
+            .map((job) => ({ name: job.name, lastRunAt: job.lastRunAt, runCount: job.runCount ?? 0 }))
+          : [];
+
+        const changedTasks = lastSeenAt !== null
+          ? allTasks
+            .filter((task) => {
+              const completedAt = (task as { completedAt?: number }).completedAt;
+              return completedAt !== undefined ? completedAt > lastSeenAt : false;
+            })
+            .map((task) => ({
+              title: (task as { title?: string; name?: string }).title
+                ?? (task as { name?: string }).name
+                ?? 'Task',
+              status: (task as { status?: string }).status ?? 'done',
+              completedAt: (task as { completedAt?: number }).completedAt,
+            }))
+          : [];
+
+        const pendingApprovals = options.listApprovals()
+          .filter((approval) => approval.status === 'pending').length;
+
+        const digest = buildAwayDigest({
+          lastSeenAt,
+          schedules: firedSchedules,
+          tasks: changedTasks,
+          pendingApprovals,
+        });
+
+        if (digest !== null) {
+          const full = [digest.headline, ...digest.lines].join('\n  ');
+          options.router.high(`[Status] ${full}`);
+          for (const line of digest.lines) {
+            options.router.getFeed()?.push(`[Status] ${line}`, 'low', 'schedule');
+          }
+          options.render();
+        }
+
+        // Invoke optional skill-draft hook once per pass.
+        if (options.onAwayDigest) {
+          try {
+            const drafted = options.onAwayDigest();
+            if (drafted > 0) {
+              options.router.getFeed()?.push(
+                `[Status] I drafted ${drafted} skill${drafted !== 1 ? 's' : ''} from recent work — review them under Memory`,
+                'low',
+                'schedule',
+              );
+            }
+          } catch {
+            // Skill draft hook failed — skip silently.
+          }
+        }
+      } catch (err) {
+        logger.debug('away-digest failed (non-fatal)', { error: err instanceof Error ? err.message : String(err) });
+      }
+    })();
+  }
+
+  function stop(): void {
+    clearInterval(lastSeenRefreshInterval);
+    lastSeenStore.save();
+  }
+
+  return {
+    refreshComingUp,
+    announceAwayDigest,
+    stop,
+    // Return a defensive copy so callers cannot mutate internal cache state.
+    comingUpItems: (): readonly string[] => [...comingUpCache.items],
+  };
+}
+
+/**
+ * Build the onAwayDigest callback for the given shellPaths and command context.
+ * Extracted so main.ts can pass a single symbol instead of an inline lambda.
+ * (See module-header note for history.)
+ */
+export function buildSkillDraftProposer(
+  shellPaths: Parameters<typeof AgentSkillRegistry.fromShellPaths>[0],
+  context: CommandContext,
+): () => number {
+  return () =>
+    runSkillDraftProposer(
+      context,
+      AgentSkillRegistry.fromShellPaths(shellPaths),
+    ).proposed;
+}
+
+/**
+ * Build the listCalendarEvents callback for the given shellPaths.
+ * Extracts the closure that was previously inlined in main.ts so that
+ * file stays under the 800-line cap.
+ *
+ * The optional `upcomingEvents` parameter is a testability seam: when provided,
+ * it replaces the `registry.upcoming(7)` call so unit tests can inject a
+ * deterministic event set without mocking the module. Production callers omit
+ * this parameter; the default is the real registry lookup.
+ */
+export function buildCalendarEventsLister(
+  shellPaths: Parameters<typeof LastSeenStore.fromShellPaths>[0],
+  upcomingEvents?: () => readonly import('../agent/calendar-registry.ts').AgentCalendarEvent[],
+): () => readonly { label: string; start: number }[] {
+  return () => {
+    const now = Date.now();
+    const registry = AgentCalendarRegistry.fromShellPaths(shellPaths);
+    return (upcomingEvents ?? (() => registry.upcoming(7)))()
+      .map((e) => {
+        const allDay = e.allDay;
+        // Sort key: use local midnight for all-day events so they sort at the
+        // correct local calendar date rather than UTC midnight (which would land
+        // the previous day for timezones east of UTC).
+        // Timed events: parse the ISO string directly; Date.parse handles
+        // offset-bearing strings correctly.
+        const startMs = allDay
+          ? new Date(`${e.start}T00:00:00`).getTime()   // no tz suffix ⇒ local time
+          : Date.parse(e.start);
+        const sortMs = isNaN(startMs) ? now : startMs;
+        // Display: format via local Date methods so the user sees their own
+        // timezone, never a raw stored offset or UTC-shifted string.
+        const label = e.title.length > 22 ? `${e.title.slice(0, 20)}…` : e.title;
+        const when = allDay
+          ? e.start   // date-only string, no time component to misformat
+          : formatDigestTime(startMs, now);
+        return { label: `${label} — ${when}`, start: sortMs };
+      });
+  };
+}

package/src/shell/session-continuity-hints.ts

@@ -18,15 +18,10 @@ interface ShellRemoteSnapshot {
   readonly contracts: readonly ShellRemoteContract[];
 }
 
-interface ShellPanelRecord {
-  readonly id: string;
-}
-
 export function buildShellSessionContinuityHints(
   sessionSnapshot: ShellSessionSnapshot,
   tasksSnapshot: ShellTaskSnapshot,
   remoteSnapshot: ShellRemoteSnapshot,
-  openPanels: readonly ShellPanelRecord[],
 ) {
   return {
     pendingApprovals: sessionSnapshot.pendingApproval ? 1 : 0,
@@ -34,6 +29,5 @@ export function buildShellSessionContinuityHints(
     blockedTasks: tasksSnapshot.tasks.filter((task) => task.status === 'blocked').length,
     remoteContracts: remoteSnapshot.contracts.length,
     remoteRunners: remoteSnapshot.contracts.slice(0, 4).map((contract) => contract.runnerId),
-    openPanels: openPanels.map((panel) => panel.id),
   };
 }