vibepulse 0.2.1 → 0.3.0-beta.0

package/.next/standalone/src/components/opencode-config/AgentConfigForm.test.tsx

@@ -69,4 +69,32 @@ describe('AgentConfigForm - echo bug fix', () => {
     });
   });
 
+  it('shows the upstream hephaestus fallback chain when no model is configured', async () => {
+    mockFetch
+      .mockResolvedValueOnce(
+        jsonResponse({
+          agents: {},
+          categories: {},
+        })
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          models: [],
+          source: 'test',
+        })
+      );
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <AgentConfigForm agentName="hephaestus" />
+      </QueryClientProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText(/using default fallback chain/i)).toBeInTheDocument();
+    });
+
+    expect(screen.getByText('openai/gpt-5.4')).toBeInTheDocument();
+  });
+
 });

package/.next/standalone/src/components/opencode-config/AgentConfigForm.tsx

@@ -55,15 +55,15 @@ interface AgentConfigFormProps {
 }
 
 const AGENT_FALLBACK_CHAINS: Record<string, string[]> = {
-  sisyphus: ['anthropic/claude-opus-4-6', 'glm-5', 'big-pickle'],
-  prometheus: ['anthropic/claude-opus-4-6', 'openai/gpt-5.4', 'google/gemini-3.1-pro'],
-  metis: ['anthropic/claude-opus-4-6', 'openai/gpt-5.4', 'google/gemini-3.1-pro'],
-  atlas: ['anthropic/claude-sonnet-4-6', 'openai/gpt-5.4'],
-  hephaestus: ['openai/gpt-5.3-codex'],
-  oracle: ['openai/gpt-5.4', 'google/gemini-3.1-pro', 'anthropic/claude-opus-4-6'],
-  momus: ['openai/gpt-5.4', 'anthropic/claude-opus-4-6', 'google/gemini-3.1-pro'],
-  explore: ['github-copilot/grok-code-fast-1', 'minimax-m2.5-free', 'anthropic/claude-haiku-4-5', 'opencode/gpt-5-nano'],
-  librarian: ['google/gemini-3-flash', 'minimax-m2.5-free', 'big-pickle'],
+  sisyphus: ['anthropic/claude-opus-4-6', 'kimi-k2.5', 'openai/gpt-5.4', 'glm-5', 'big-pickle'],
+  prometheus: ['anthropic/claude-opus-4-6', 'openai/gpt-5.4', 'glm-5', 'google/gemini-3.1-pro'],
+  metis: ['anthropic/claude-opus-4-6', 'openai/gpt-5.4', 'glm-5', 'k2p5'],
+  atlas: ['anthropic/claude-sonnet-4-6', 'kimi-k2.5', 'openai/gpt-5.4', 'minimax-m2.7'],
+  hephaestus: ['openai/gpt-5.4'],
+  oracle: ['openai/gpt-5.4', 'google/gemini-3.1-pro', 'anthropic/claude-opus-4-6', 'glm-5'],
+  momus: ['openai/gpt-5.4', 'anthropic/claude-opus-4-6', 'google/gemini-3.1-pro', 'glm-5'],
+  explore: ['grok-code-fast-1', 'minimax-m2.7-highspeed', 'minimax-m2.7', 'anthropic/claude-haiku-4-5', 'gpt-5-nano'],
+  librarian: ['minimax-m2.7', 'minimax-m2.7-highspeed', 'anthropic/claude-haiku-4-5', 'gpt-5-nano'],
   default: ['anthropic/claude-opus-4-6', 'openai/gpt-5.4'],
 };
 

package/.next/standalone/src/components/opencode-config/ConfigButton.tsx

@@ -5,7 +5,7 @@ import { Settings } from 'lucide-react';
 
 interface OpencodeConfigStatus {
   hasConfig: boolean;
-  hasPlugin: boolean;
+  hasOpenCodeCli: boolean;
   path?: string;
 }
 
@@ -25,7 +25,7 @@ export function ConfigButton({ onClick }: ConfigButtonProps) {
     },
   });
 
-  if (!status?.hasPlugin) {
+  if (!status?.hasOpenCodeCli) {
     return null;
   }
 
@@ -34,8 +34,8 @@ export function ConfigButton({ onClick }: ConfigButtonProps) {
       type="button"
       onClick={onClick}
       className="inline-flex items-center justify-center w-9 h-9 rounded-lg text-gray-500 hover:text-gray-700 hover:bg-gray-100 dark:text-gray-400 dark:hover:text-gray-200 dark:hover:bg-zinc-800 transition-colors duration-200"
-      aria-label="OpenCode Settings"
-      title="OpenCode Settings"
+      aria-label="Oh My OpenAgent Settings"
+      title="Oh My OpenAgent Settings"
     >
       <Settings className="w-5 h-5" />
     </button>

package/.next/standalone/src/components/opencode-config/categories/CategoriesList.tsx

@@ -35,13 +35,13 @@ interface CategoryDefinition {
 
 const CATEGORY_FALLBACK_CHAINS: Record<string, string[]> = {
   'visual-engineering': ['google/gemini-3.1-pro', 'glm-5', 'anthropic/claude-opus-4-6'],
-  ultrabrain: ['openai/gpt-5.3-codex', 'google/gemini-3.1-pro', 'anthropic/claude-opus-4-6'],
-  deep: ['openai/gpt-5.3-codex', 'anthropic/claude-opus-4-6', 'google/gemini-3.1-pro'],
+  ultrabrain: ['openai/gpt-5.4', 'google/gemini-3.1-pro', 'anthropic/claude-opus-4-6', 'glm-5'],
+  deep: ['openai/gpt-5.4', 'anthropic/claude-opus-4-6', 'google/gemini-3.1-pro'],
   artistry: ['google/gemini-3.1-pro', 'anthropic/claude-opus-4-6', 'openai/gpt-5.4'],
-  quick: ['anthropic/claude-haiku-4-5', 'google/gemini-3-flash', 'opencode/gpt-5-nano'],
-  'unspecified-low': ['anthropic/claude-sonnet-4-6', 'openai/gpt-5.3-codex', 'google/gemini-3-flash'],
-  'unspecified-high': ['openai/gpt-5.4', 'anthropic/claude-opus-4-6', 'glm-5', 'kimi-for-coding/k2p5'],
-  writing: ['google/gemini-3-flash', 'anthropic/claude-sonnet-4-6'],
+  quick: ['openai/gpt-5.4-mini', 'anthropic/claude-haiku-4-5', 'google/gemini-3-flash', 'minimax-m2.7', 'gpt-5-nano'],
+  'unspecified-low': ['anthropic/claude-sonnet-4-6', 'openai/gpt-5.3-codex', 'kimi-k2.5', 'google/gemini-3-flash', 'minimax-m2.7'],
+  'unspecified-high': ['anthropic/claude-opus-4-6', 'openai/gpt-5.4', 'glm-5', 'k2p5', 'kimi-k2.5'],
+  writing: ['google/gemini-3-flash', 'kimi-k2.5', 'anthropic/claude-sonnet-4-6', 'minimax-m2.7'],
 };
 
 const BUILT_IN_CATEGORIES: CategoryDefinition[] = [
@@ -149,6 +149,8 @@ function CategoryCard({
   const info = getCategoryInfo(categoryKey);
   const hasConfig = !!(config.model || config.variant);
   const isModelInvalid = config.model && availableModels && availableModels.size > 0 && !availableModels.has(config.model);
+  const fallbackModel = !hasConfig ? CATEGORY_FALLBACK_CHAINS[categoryKey]?.[0] : undefined;
+  const displayModel = config.model || fallbackModel;
   
   // Dynamic border/bg classes based on status
   let cardStateClasses = hasConfig
@@ -201,11 +203,11 @@ function CategoryCard({
         <div className="mt-2 flex items-center gap-3 text-xs">
           <span className="text-zinc-600 dark:text-zinc-400">
             <span className="text-zinc-400 dark:text-zinc-500">Provider:</span>{' '}
-            {formatProvider(config.model)}
+            {formatProvider(displayModel)}
           </span>
           <span className="text-zinc-600 dark:text-zinc-400">
             <span className="text-zinc-400 dark:text-zinc-500">Model:</span>{' '}
-            {formatModel(config.model)}
+            {formatModel(displayModel)}
           </span>
           {config.variant && (
             <span className="text-zinc-600 dark:text-zinc-400">

package/.next/standalone/src/components/opencode-config/categories/CategoriesManager.test.tsx

@@ -57,7 +57,35 @@ describe('CategoriesManager', () => {
     });
 
     expect(screen.getAllByText('Provider:').length).toBeGreaterThan(0);
-    expect(screen.getByText('google')).toBeInTheDocument();
+    expect(screen.getAllByText('google').length).toBeGreaterThan(0);
+  });
+
+  it('shows the aligned built-in fallback model for unconfigured quick category cards', async () => {
+    mockFetch
+      .mockResolvedValueOnce(
+        jsonResponse({
+          agents: {},
+          categories: {},
+        })
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          models: [],
+          source: 'test',
+        })
+      );
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <CategoriesManager />
+      </QueryClientProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('Quick')).toBeInTheDocument();
+    });
+
+    expect(screen.getByText('gpt-5.4-mini')).toBeInTheDocument();
   });
 
   it('should save category correctly after editing', async () => {

package/.next/standalone/src/components/opencode-config/categories/CategoryConfigForm.test.tsx

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { CategoryConfigForm } from './CategoryConfigForm';
+
+const mockFetch = vi.fn<typeof fetch>();
+global.fetch = mockFetch;
+
+function jsonResponse(data: unknown): Response {
+  return {
+    ok: true,
+    status: 200,
+    json: async () => data,
+  } as Response;
+}
+
+describe('CategoryConfigForm', () => {
+  let queryClient: QueryClient;
+
+  beforeEach(() => {
+    queryClient = new QueryClient({
+      defaultOptions: {
+        queries: { staleTime: 0 },
+      },
+    });
+    vi.clearAllMocks();
+  });
+
+  it('shows the upstream quick fallback chain when no model is configured', async () => {
+    mockFetch.mockResolvedValueOnce(
+      jsonResponse({
+        models: [],
+        source: 'test',
+      })
+    );
+
+    render(
+      <QueryClientProvider client={queryClient}>
+        <CategoryConfigForm categoryName="quick" onSave={() => {}} onCancel={() => {}} />
+      </QueryClientProvider>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText(/using built-in fallback chain/i)).toBeInTheDocument();
+    });
+
+    expect(screen.getByText('openai/gpt-5.4-mini')).toBeInTheDocument();
+  });
+});

package/.next/standalone/src/components/opencode-config/categories/CategoryConfigForm.tsx

@@ -36,13 +36,13 @@ interface CategoryConfigFormProps {
 
 const CATEGORY_FALLBACK_CHAINS: Record<string, string[]> = {
   'visual-engineering': ['google/gemini-3.1-pro', 'glm-5', 'anthropic/claude-opus-4-6'],
-  ultrabrain: ['openai/gpt-5.3-codex', 'google/gemini-3.1-pro', 'anthropic/claude-opus-4-6'],
-  deep: ['openai/gpt-5.3-codex', 'anthropic/claude-opus-4-6', 'google/gemini-3.1-pro'],
+  ultrabrain: ['openai/gpt-5.4', 'google/gemini-3.1-pro', 'anthropic/claude-opus-4-6', 'glm-5'],
+  deep: ['openai/gpt-5.4', 'anthropic/claude-opus-4-6', 'google/gemini-3.1-pro'],
   artistry: ['google/gemini-3.1-pro', 'anthropic/claude-opus-4-6', 'openai/gpt-5.4'],
-  quick: ['anthropic/claude-haiku-4-5', 'google/gemini-3-flash', 'opencode/gpt-5-nano'],
-  'unspecified-low': ['anthropic/claude-sonnet-4-6', 'openai/gpt-5.3-codex', 'google/gemini-3-flash'],
-  'unspecified-high': ['openai/gpt-5.4', 'anthropic/claude-opus-4-6', 'glm-5', 'kimi-for-coding/k2p5'],
-  writing: ['google/gemini-3-flash', 'anthropic/claude-sonnet-4-6'],
+  quick: ['openai/gpt-5.4-mini', 'anthropic/claude-haiku-4-5', 'google/gemini-3-flash', 'minimax-m2.7', 'gpt-5-nano'],
+  'unspecified-low': ['anthropic/claude-sonnet-4-6', 'openai/gpt-5.3-codex', 'kimi-k2.5', 'google/gemini-3-flash', 'minimax-m2.7'],
+  'unspecified-high': ['anthropic/claude-opus-4-6', 'openai/gpt-5.4', 'glm-5', 'k2p5', 'kimi-k2.5'],
+  writing: ['google/gemini-3-flash', 'kimi-k2.5', 'anthropic/claude-sonnet-4-6', 'minimax-m2.7'],
 };
 
 export function CategoryConfigForm({

package/.next/standalone/src/hooks/useOpencodeSync.test.ts

@@ -117,6 +117,8 @@ function createSession(overrides: Partial<OpencodeSession> & Pick<OpencodeSessio
         rawSessionId: overrides.rawSessionId,
         sourceSessionKey: overrides.sourceSessionKey ?? overrides.id,
         readOnly: overrides.readOnly,
+        provider: overrides.provider,
+        providerRawId: overrides.providerRawId,
     };
 }
 
@@ -164,7 +166,9 @@ describe('useOpencodeSync', () => {
                 delete mockLocalStorage[key];
             },
             clear: () => {
-                Object.keys(mockLocalStorage).forEach((key) => delete mockLocalStorage[key]);
+                for (const key of Object.keys(mockLocalStorage)) {
+                    delete mockLocalStorage[key];
+                }
             },
         });
         (getSseStatusSnapshot() as Map<string, unknown>).clear();
@@ -384,4 +388,320 @@ describe('useOpencodeSync', () => {
 
         unmount();
     });
+
+    it('keeps recently-idle child sessions nested instead of removing them immediately', () => {
+        const eventTimestamp = 75_000;
+        const parentSession = createSession({
+            id: 'local:parent',
+            rawSessionId: 'parent',
+            hostId: 'local',
+            hostLabel: 'Local',
+            hostKind: 'local',
+            children: [
+                {
+                    id: 'local:child',
+                    slug: 'child',
+                    title: 'Child Session',
+                    directory: '/tmp/project',
+                    projectName: 'Project',
+                    parentID: 'local:parent',
+                    time: { created: 1000, updated: 2000 },
+                    realTimeStatus: 'busy',
+                    waitingForUser: false,
+                },
+            ],
+        });
+
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [parentSession],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.status',
+                properties: {
+                    sessionID: 'child',
+                    status: { type: 'idle' },
+                },
+                timestamp: eventTimestamp,
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const nextParent = data?.sessions.find((session) => session.id === 'local:parent');
+
+        expect(nextParent?.children).toHaveLength(1);
+        expect(nextParent?.children?.[0]?.id).toBe('local:child');
+        expect(nextParent?.children?.[0]?.realTimeStatus).toBe('idle');
+        expect(nextParent?.children?.[0]?.time.updated).toBe(eventTimestamp);
+
+        unmount();
+    });
+});
+
+describe('useOpencodeSync provider defaults', () => {
+    let mockLocalStorage: Record<string, string>;
+
+    beforeEach(() => {
+        mockLocalStorage = {};
+        MockEventSource.reset();
+        vi.useFakeTimers();
+        vi.stubGlobal('EventSource', MockEventSource as unknown as typeof EventSource);
+        vi.stubGlobal('localStorage', {
+            getItem: (key: string) => mockLocalStorage[key] || null,
+            setItem: (key: string, value: string) => {
+                mockLocalStorage[key] = value;
+            },
+            removeItem: (key: string) => {
+                delete mockLocalStorage[key];
+            },
+            clear: () => {
+                for (const key of Object.keys(mockLocalStorage)) {
+                    delete mockLocalStorage[key];
+                }
+            },
+        });
+        (getSseStatusSnapshot() as Map<string, unknown>).clear();
+    });
+
+    afterEach(() => {
+        vi.clearAllTimers();
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+        MockEventSource.reset();
+        (getSseStatusSnapshot() as Map<string, unknown>).clear();
+    });
+
+    it('applies default provider opencode to new sessions from session.created event', () => {
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.created',
+                properties: {
+                    info: {
+                        id: 'ses_1744181234567_build',
+                        slug: 'session_1744181234567_build',
+                        title: 'New Session',
+                        directory: '/tmp/project',
+                        time: { created: Date.now(), updated: Date.now() },
+                    },
+                },
+                timestamp: Date.now(),
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const newSession = data?.sessions.find((s) => s.id === 'local:ses_1744181234567_build');
+
+        expect(newSession?.provider).toBe('opencode');
+        expect(newSession?.readOnly).toBe(false);
+        expect(newSession?.capabilities).toEqual({
+            openProject: true,
+            openEditor: true,
+            archive: true,
+            delete: true,
+        });
+
+        unmount();
+    });
+
+    it('applies default provider opencode to existing sessions on update', () => {
+        const existingSession = createSession({
+            id: 'local:ses_123',
+            rawSessionId: 'ses_123',
+            hostId: 'local',
+            hostLabel: 'Local',
+            hostKind: 'local',
+        });
+
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [existingSession],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.updated',
+                properties: {
+                    info: {
+                        id: 'ses_123',
+                        slug: 'session_123',
+                        title: 'Updated Session',
+                        directory: '/tmp/project',
+                        time: { created: 1000, updated: Date.now() },
+                    },
+                },
+                timestamp: Date.now(),
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const updatedSession = data?.sessions.find((s) => s.id === 'local:ses_123');
+
+        expect(updatedSession?.provider).toBe('opencode');
+        expect(updatedSession?.readOnly).toBe(false);
+        expect(updatedSession?.capabilities).toEqual({
+            openProject: true,
+            openEditor: true,
+            archive: true,
+            delete: true,
+        });
+
+        unmount();
+    });
+
+    it('preserves explicit claude-code provider from event info', () => {
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.created',
+                properties: {
+                    info: {
+                        id: 'claude~550e8400-e29b-41d4-a716-446655440000',
+                        slug: 'claude_session',
+                        title: 'Claude Session',
+                        directory: '/tmp/claude-project',
+                        time: { created: Date.now(), updated: Date.now() },
+                        provider: 'claude-code',
+                        providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+                    },
+                },
+                timestamp: Date.now(),
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const newSession = data?.sessions.find((s) => s.id === 'local:claude~550e8400-e29b-41d4-a716-446655440000');
+
+        expect(newSession?.provider).toBe('claude-code');
+        expect(newSession?.providerRawId).toBe('550e8400-e29b-41d4-a716-446655440000');
+        expect(newSession?.capabilities).toEqual({
+            openProject: true,
+            openEditor: false,
+            archive: true,
+            delete: true,
+        });
+
+        unmount();
+    });
+
+    it('preserves explicit readOnly true when specified', () => {
+        const existingSession = createSession({
+            id: 'local:ses_123',
+            rawSessionId: 'ses_123',
+            hostId: 'local',
+            readOnly: true,
+        });
+
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [existingSession],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.status',
+                properties: {
+                    sessionID: 'ses_123',
+                    status: { type: 'busy' },
+                },
+                timestamp: Date.now(),
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const updatedSession = data?.sessions.find((s) => s.id === 'local:ses_123');
+
+        expect(updatedSession?.readOnly).toBe(true);
+
+        unmount();
+    });
+
+    it('propagates provider and readOnly on session.status events for existing sessions', () => {
+        const localSession = createSession({
+            id: 'local:abc',
+            rawSessionId: 'abc',
+            hostId: 'local',
+            provider: 'claude-code',
+            readOnly: true,
+        });
+
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [localSession],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.status',
+                properties: {
+                    sessionID: 'abc',
+                    status: { type: 'busy' },
+                },
+                timestamp: Date.now(),
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const updatedSession = data?.sessions.find((s) => s.id === 'local:abc');
+
+        expect(updatedSession?.provider).toBe('claude-code');
+        expect(updatedSession?.readOnly).toBe(true);
+
+        unmount();
+    });
+
+    it('keeps OpenCode SSE updates scoped to plain local ids when a Claude session shares the same raw uuid', () => {
+        const sharedUuid = '550e8400-e29b-41d4-a716-446655440000';
+        const openCodeSession = createSession({
+            id: `local:${sharedUuid}`,
+            rawSessionId: sharedUuid,
+            hostId: 'local',
+            hostLabel: 'Local',
+            hostKind: 'local',
+            provider: 'opencode',
+            readOnly: false,
+        });
+        const claudeSession = createSession({
+            id: `local:claude~${sharedUuid}`,
+            rawSessionId: sharedUuid,
+            hostId: 'local',
+            hostLabel: 'Local',
+            hostKind: 'local',
+            provider: 'claude-code',
+            providerRawId: sharedUuid,
+            readOnly: true,
+        });
+
+        const { eventSource, queryClient, queryKey, unmount } = renderUseOpencodeSync({
+            sessions: [openCodeSession, claudeSession],
+        });
+
+        act(() => {
+            eventSource.emitMessage({
+                type: 'session.status',
+                properties: {
+                    sessionID: sharedUuid,
+                    status: { type: 'busy' },
+                },
+                timestamp: Date.now(),
+            });
+        });
+
+        const data = queryClient.getQueryData<SessionsQueryData>(queryKey);
+        const updatedOpenCodeSession = data?.sessions.find((s) => s.id === `local:${sharedUuid}`);
+        const updatedClaudeSession = data?.sessions.find((s) => s.id === `local:claude~${sharedUuid}`);
+
+        expect(updatedOpenCodeSession?.provider).toBe('opencode');
+        expect(updatedOpenCodeSession?.realTimeStatus).toBe('busy');
+        expect(updatedClaudeSession?.provider).toBe('claude-code');
+        expect(updatedClaudeSession?.realTimeStatus).toBe('idle');
+        expect(getSseStatusSnapshot().get(`local:${sharedUuid}`)?.status).toBe('busy');
+        expect(getSseStatusSnapshot().has(`local:claude~${sharedUuid}`)).toBe(false);
+
+        unmount();
+    });
 });

package/.next/standalone/src/hooks/useOpencodeSync.ts

@@ -5,6 +5,7 @@ import { useQueryClient } from '@tanstack/react-query';
 import { OpencodeEvent, OpencodeSession } from '@/types';
 import { playAlertSound, playAttentionSound } from '@/lib/notificationSound';
 import { composeSourceKey, getSessionIdFromSourceKey } from '@/lib/hostIdentity';
+import { DEFAULT_PROVIDER_CONTEXT, getDefaultProviderContext } from '@/lib/session-providers/providerIds';
 
 const WAITING_STORAGE_KEY = 'vibepulse:waiting-sessions:v2';
 const WAITING_ENTER_DELAY_MS = 1500;
@@ -104,6 +105,7 @@ function toSourceKey(hostId: string, sessionId: string): string {
 }
 
 function normalizeSessionForSource(info: OpencodeSession, source: EventSourceContext): OpencodeSession {
+    const providerDefaults = getDefaultProviderContext(info.provider ?? DEFAULT_PROVIDER_CONTEXT.provider);
     const rawSessionId = getSessionIdFromSourceKey(info.rawSessionId ?? info.id) ?? info.rawSessionId ?? info.id;
     const sourceSessionKey = composeSourceKey(source.hostId, rawSessionId);
     const rawParentId = info.parentID ? getSessionIdFromSourceKey(info.parentID) ?? info.parentID : info.parentID;
@@ -118,7 +120,10 @@ function normalizeSessionForSource(info: OpencodeSession, source: EventSourceCon
         hostBaseUrl: source.hostBaseUrl,
         rawSessionId,
         sourceSessionKey,
-        readOnly: false,
+        readOnly: info.readOnly ?? providerDefaults.readOnly,
+        capabilities: info.capabilities ?? providerDefaults.capabilities,
+        provider: info.provider ?? providerDefaults.provider,
+        providerRawId: info.providerRawId ?? rawSessionId,
         children: info.children?.map((child) =>
             normalizeSessionForSource({
                 ...child,
@@ -354,19 +359,24 @@ export function useOpencodeSync() {
                     }
 
                     const applyEvent = (s: OpencodeSession): OpencodeSession => {
+                        const providerDefaults = getDefaultProviderContext(s.provider ?? DEFAULT_PROVIDER_CONTEXT.provider);
                         const baseSession: OpencodeSession = {
                             ...s,
                             hostId: source.hostId,
                             hostLabel: source.hostLabel,
                             hostKind: source.hostKind,
                             hostBaseUrl: source.hostBaseUrl ?? s.hostBaseUrl,
-                            readOnly: false,
+                            readOnly: s.readOnly ?? providerDefaults.readOnly,
+                            capabilities: s.capabilities ?? providerDefaults.capabilities,
+                            provider: s.provider ?? providerDefaults.provider,
+                            providerRawId: s.providerRawId ?? s.rawSessionId,
                         };
 
                         switch (event.type) {
                             case 'session.status': {
                                 const statusType = event.properties?.status?.type as 'idle' | 'busy' | 'retry' | undefined;
                                 if (!statusType) return baseSession;
+                                const statusTimestamp = typeof event.timestamp === 'number' ? event.timestamp : Date.now();
                                 recordSseStatus(s.id, statusType);
                                 const isParentSession = !s.parentID;
                                 const shouldAutoUnarchive = statusType === 'busy' || statusType === 'retry';
@@ -393,7 +403,9 @@ export function useOpencodeSync() {
                                 }
                                 return { 
                                     ...baseSession, 
-                                    time: shouldAutoUnarchive ? { ...(s.time || {}), archived: undefined } : s.time,
+                                    time: shouldAutoUnarchive
+                                        ? { ...(s.time || {}), updated: statusTimestamp, archived: undefined }
+                                        : { ...(s.time || {}), updated: statusTimestamp },
                                     realTimeStatus: statusType, 
                                     waitingForUser:
                                         statusType === 'retry'
@@ -448,15 +460,7 @@ export function useOpencodeSync() {
                         }
                         if (session.children?.some(c => c.id === sourceSessionId)) {
                             found = true;
-                            // If the event is a status update to 'idle', we should filter the child out
-                            // so it disappears from the UI without needing a full refetch, matching backend logic.
-                            if (event.type === 'session.status' && event.properties?.status?.type === 'idle') {
-                                return {
-                                    ...session,
-                                    children: session.children.filter(c => c.id !== sourceSessionId)
-                                };
-                            }
-                            
+
                             return {
                                 ...session,
                                 children: session.children.map(c => c.id === sourceSessionId ? applyEvent(c) : c)

package/.next/standalone/src/index.ts

@@ -1,2 +1,2 @@
-export type { Profile, ProfileConfig, CategoryConfig, AgentConfig, OhMyOpencodeConfig, ProfileIndex } from './types/opencodeConfig';
+export type { Profile, ProfileConfig, CategoryConfig, AgentConfig, OhMyOpenAgentConfig, ProfileIndex } from './types/opencodeConfig';
 export { CONFIG_DIR, CONFIG_PATH, type OpenCodeConfig, detectConfig, readConfig, writeConfig } from './lib/opencodeConfig';