vibepulse 0.2.2 → 0.3.1-beta

package/.next/standalone/src/lib/session-providers/types.ts

@@ -0,0 +1,131 @@
+import type { BuiltInHostSource, RemoteHostConfig, SessionCapabilities, SessionProvider } from '@/types';
+
+export type SessionLike = {
+  id: string;
+  slug?: string;
+  title?: string;
+  directory: string;
+  debugReason?: string;
+  parentID?: string;
+  time?: {
+    created: number;
+    updated: number;
+    archived?: number;
+  };
+};
+
+export type SessionSource = BuiltInHostSource | (RemoteHostConfig & { hostKind: 'remote' });
+
+export type ChildTopologySupport = 'flat' | 'authoritative';
+
+export type ProviderTopology = {
+  childSessions: ChildTopologySupport;
+};
+
+export type HostAwareFields = {
+  hostId?: string;
+  hostLabel?: string;
+  hostKind?: SessionSource['hostKind'];
+  hostBaseUrl?: string;
+  provider?: SessionProvider;
+  providerRawId?: string;
+  rawSessionId?: string;
+  sourceSessionKey?: string;
+  readOnly?: boolean;
+  capabilities?: SessionCapabilities;
+  topology?: ProviderTopology;
+};
+
+export type ChildEntry = HostAwareFields & {
+  id: string;
+  slug?: string;
+  title?: string;
+  directory?: string;
+  debugReason?: string;
+  parentID?: string;
+  time?: { created: number; updated: number; archived?: number };
+  realTimeStatus: string;
+  waitingForUser: boolean;
+};
+
+export type EnrichedSession = SessionLike & HostAwareFields & {
+  projectName: string;
+  branch: string | null;
+  realTimeStatus: 'idle' | 'busy' | 'retry';
+  waitingForUser: boolean;
+  children: ChildEntry[];
+};
+
+export type ProcessHint = {
+  pid: number;
+  directory: string;
+  projectName: string;
+  reason: 'process_without_api_port';
+};
+
+export type SessionHostStatus = {
+  hostId: string;
+  hostLabel: string;
+  hostKind: SessionSource['hostKind'];
+  online: boolean;
+  degraded?: boolean;
+  reason?: string;
+  baseUrl?: string;
+};
+
+export type SourceResultMeta = {
+  online: boolean;
+  degraded?: boolean;
+  reason?: string;
+};
+
+export type SessionsSuccessPayload = {
+  sessions: EnrichedSession[];
+  processHints: ProcessHint[];
+  failedPorts?: Array<{ port: number; reason: string }>;
+  degraded?: boolean;
+  hosts?: SessionHostStatus[];
+  hostStatuses?: SessionHostStatus[];
+};
+
+export type SessionsRouteResult = {
+  payload: SessionsSuccessPayload | Record<string, unknown>;
+  status?: number;
+  sourceMeta?: SourceResultMeta;
+};
+
+export type StableRealtimeStatus = 'idle' | 'busy' | 'retry';
+
+export type MessageStateStatus = string;
+
+export type MessagePart = {
+  state?: {
+    status?: unknown;
+  };
+};
+
+export type SessionStatusStabilizationTarget = {
+  id: string;
+  time?: {
+    archived?: number;
+  };
+  realTimeStatus: string;
+  waitingForUser: boolean;
+  children: Array<{
+    id: string;
+    time?: {
+      archived?: number;
+    };
+    realTimeStatus: string;
+    waitingForUser: boolean;
+  }>;
+};
+
+export type LocalSessionProviderContext = {
+  stickyBusyDelayMs: number;
+};
+
+export type LocalSessionProvider = {
+  id: SessionProvider;
+  getSessionsResult(context: LocalSessionProviderContext): Promise<SessionsRouteResult>;
+};

package/.next/standalone/src/lib/transform.test.ts

@@ -33,6 +33,8 @@ function makeSession(overrides: SessionOverrides = {}): OpencodeSession {
     rawSessionId: overrides.rawSessionId,
     sourceSessionKey: overrides.sourceSessionKey,
     readOnly: overrides.readOnly,
+    provider: overrides.provider,
+    providerRawId: overrides.providerRawId,
   };
 }
 
@@ -119,3 +121,254 @@ describe('transformSession archive precedence', () => {
     expect(card.readOnly).toBe(false);
   });
 });
+
+describe('transformSession provider propagation', () => {
+  it('defaults provider to opencode when not specified', () => {
+    const session = makeSession();
+
+    const card = transformSession(session);
+
+    expect(card.provider).toBe('opencode');
+  });
+
+  it('defaults readOnly to false for OpenCode sessions', () => {
+    const session = makeSession();
+
+    const card = transformSession(session);
+
+    expect(card.readOnly).toBe(false);
+    expect(card.capabilities).toEqual({
+      openProject: true,
+      openEditor: true,
+      archive: true,
+      delete: true,
+    });
+  });
+
+  it('preserves explicit claude-code provider', () => {
+    const session = makeSession({
+      provider: 'claude-code',
+      providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+    });
+
+    const card = transformSession(session);
+
+    expect(card.provider).toBe('claude-code');
+    expect(card.providerRawId).toBe('550e8400-e29b-41d4-a716-446655440000');
+  });
+
+  it('preserves explicit readOnly true', () => {
+    const session = makeSession({ readOnly: true });
+
+    const card = transformSession(session);
+
+    expect(card.readOnly).toBe(true);
+  });
+
+  it('falls back to rawSessionId when providerRawId not specified', () => {
+    const session = makeSession({ rawSessionId: 'ses_123' });
+
+    const card = transformSession(session);
+
+    expect(card.providerRawId).toBe('ses_123');
+  });
+
+  it('uses providerRawId over rawSessionId when both specified', () => {
+    const session = makeSession({
+      rawSessionId: 'ses_123',
+      providerRawId: 'claude~550e8400-e29b-41d4-a716-446655440000',
+    });
+
+    const card = transformSession(session);
+
+    expect(card.providerRawId).toBe('claude~550e8400-e29b-41d4-a716-446655440000');
+  });
+
+  it('correctly handles Claude-backed sessions from provider properties', () => {
+    const session = makeSession({
+      provider: 'claude-code',
+      readOnly: true,
+      providerRawId: '550e8400-e29b-41d4-a716-446655440000',
+    });
+
+    const card = transformSession(session);
+
+    expect(card.provider).toBe('claude-code');
+    expect(card.readOnly).toBe(true);
+    expect(card.capabilities).toEqual({
+      openProject: true,
+      openEditor: false,
+      archive: true,
+      delete: true,
+    });
+    expect(card.providerRawId).toBe('550e8400-e29b-41d4-a716-446655440000');
+  });
+});
+
+describe('transformSession child roll-up semantics', () => {
+  it('pulls a Claude parent into busy when a verified Claude child is active', () => {
+    const now = Date.now();
+    const child = makeSession({
+      id: 'claude-child-1',
+      provider: 'claude-code',
+      parentID: 'claude-parent-1',
+      realTimeStatus: 'busy',
+      time: {
+        created: now - 10_000,
+        updated: now - 2_000,
+      },
+    });
+
+    const parent = makeSession({
+      id: 'claude-parent-1',
+      provider: 'claude-code',
+      realTimeStatus: 'idle',
+      children: [child],
+    });
+
+    const card = transformSession(parent);
+
+    expect(card.status).toBe('busy');
+    expect(card.opencodeStatus).toBe('busy');
+    expect(card.waitingForUser).toBe(false);
+    expect(card.debugReason).toBe('child_recent_activity');
+  });
+
+  it('pulls a Claude parent into review when a verified Claude child is idle but waiting for user', () => {
+    const now = Date.now();
+    const child = makeSession({
+      id: 'claude-child-2',
+      provider: 'claude-code',
+      parentID: 'claude-parent-2',
+      realTimeStatus: 'idle',
+      waitingForUser: true,
+      time: {
+        created: now - 12_000,
+        updated: now - 3_000,
+      },
+    });
+
+    const parent = makeSession({
+      id: 'claude-parent-2',
+      provider: 'claude-code',
+      realTimeStatus: 'idle',
+      children: [child],
+    });
+
+    const card = transformSession(parent);
+    const firstChild = card.children?.[0];
+
+    expect(card.status).toBe('review');
+    expect(card.opencodeStatus).toBe('busy');
+    expect(card.waitingForUser).toBe(true);
+    expect(card.debugReason).toBe('waiting_for_user');
+    expect(firstChild?.waitingForUser).toBe(true);
+  });
+
+  it('ignores malformed Claude child rows so unrelated parents stay idle', () => {
+    const now = Date.now();
+    const childWithoutParent = makeSession({
+      id: 'claude-child-missing-parent',
+      provider: 'claude-code',
+      realTimeStatus: 'busy',
+      waitingForUser: true,
+      time: {
+        created: now - 10_000,
+        updated: now - 1_000,
+      },
+    });
+    const childWithWrongParent = makeSession({
+      id: 'claude-child-wrong-parent',
+      provider: 'claude-code',
+      parentID: 'different-parent',
+      realTimeStatus: 'busy',
+      time: {
+        created: now - 10_000,
+        updated: now - 1_000,
+      },
+    });
+    const childWithoutTime = {
+      ...makeSession({
+        id: 'claude-child-without-time',
+        provider: 'claude-code',
+        parentID: 'claude-parent-3',
+        realTimeStatus: 'busy',
+        waitingForUser: true,
+      }),
+      time: undefined,
+    } as unknown as OpencodeSession;
+
+    const parent = makeSession({
+      id: 'claude-parent-3',
+      provider: 'claude-code',
+      realTimeStatus: 'idle',
+      children: [childWithoutParent, childWithWrongParent, childWithoutTime],
+    });
+
+    const card = transformSession(parent);
+
+    expect(card.status).toBe('idle');
+    expect(card.opencodeStatus).toBe('idle');
+    expect(card.waitingForUser).toBe(false);
+    expect(card.debugReason).toBeUndefined();
+    expect(card.children).toEqual([]);
+  });
+
+  it('keeps existing OpenCode child roll-up behavior intact', () => {
+    const now = Date.now();
+    const child = makeSession({
+      id: 'opencode-child-1',
+      realTimeStatus: 'busy',
+      time: {
+        created: now - 10_000,
+        updated: now - 2_000,
+      },
+    });
+
+    const parent = makeSession({
+      id: 'opencode-parent-1',
+      realTimeStatus: 'idle',
+      children: [child],
+    });
+
+    const card = transformSession(parent);
+
+    expect(card.status).toBe('busy');
+    expect(card.opencodeStatus).toBe('busy');
+    expect(card.debugReason).toBe('child_recent_activity');
+    expect(card.children).toEqual([
+      expect.objectContaining({
+        id: 'opencode-child-1',
+      }),
+    ]);
+  });
+
+  it('does not promote an OpenCode parent when a child is idle but waiting', () => {
+    const now = Date.now();
+    const child = makeSession({
+      id: 'opencode-child-idle-waiting',
+      realTimeStatus: 'idle',
+      waitingForUser: true,
+      time: {
+        created: now - 10_000,
+        updated: now - 2_000,
+      },
+    });
+
+    const parent = makeSession({
+      id: 'opencode-parent-idle-waiting',
+      realTimeStatus: 'idle',
+      children: [child],
+    });
+
+    const card = transformSession(parent);
+    const firstChild = card.children?.[0];
+
+    expect(card.status).toBe('idle');
+    expect(card.opencodeStatus).toBe('idle');
+    expect(card.waitingForUser).toBe(false);
+    expect(card.debugReason).toBeUndefined();
+    expect(firstChild?.waitingForUser).toBe(false);
+    expect(firstChild?.debugReason).toBeUndefined();
+  });
+});

package/.next/standalone/src/lib/transform.ts

@@ -1,4 +1,5 @@
-import { KanbanCard, OpencodeSession, KanbanColumn, SessionDebugReason } from '@/types';
+import { KanbanCard, OpencodeSession, KanbanColumn, SessionDebugReason, SessionProvider } from '@/types';
+import { DEFAULT_PROVIDER_CONTEXT, getDefaultProviderContext } from './session-providers/providerIds';
 
 interface EnrichedSession extends OpencodeSession {
   realTimeStatus?: 'idle' | 'busy' | 'retry';
@@ -10,22 +11,80 @@ interface EnrichedSession extends OpencodeSession {
 type EnrichedChild = NonNullable<EnrichedSession['children']>[number];
 
 const RECENT_ACTIVITY_FALLBACK_MS = 5 * 60 * 1000;
+const CHILD_BLOCKER_STALENESS_MS = 10 * 60 * 1000;
+
+function getChildActivityTimestamp(child: EnrichedChild | undefined): number | undefined {
+    const childUpdatedAt = child?.time?.updated || child?.time?.created;
+    return typeof childUpdatedAt === 'number' && childUpdatedAt > 0 ? childUpdatedAt : undefined;
+}
+
+function isVerifiedClaudeChild(parent: EnrichedSession, child: EnrichedChild | undefined): boolean {
+    if (!child || child.provider !== 'claude-code') {
+        return true;
+    }
+
+    const parentProvider = parent.provider ?? DEFAULT_PROVIDER_CONTEXT.provider;
+    if (parentProvider !== 'claude-code') {
+        return false;
+    }
+
+    return (
+        typeof child.id === 'string' &&
+        child.id.length > 0 &&
+        child.id !== parent.id &&
+        child.parentID === parent.id &&
+        getChildActivityTimestamp(child) !== undefined
+    );
+}
 
 function isRecentlyUpdated(updatedAt: number | undefined, now: number): boolean {
     return typeof updatedAt === 'number' && updatedAt > 0 && now - updatedAt <= RECENT_ACTIVITY_FALLBACK_MS;
 }
 
-function deriveChildDebugReason(child: EnrichedChild | undefined, now: number): SessionDebugReason | undefined {
+function getChildProvider(parent: EnrichedSession, child: EnrichedChild | undefined): SessionProvider {
+    return child?.provider ?? parent.provider ?? DEFAULT_PROVIDER_CONTEXT.provider;
+}
+
+function shouldMarkChildWaitingForUser(parent: EnrichedSession, child: EnrichedChild | undefined): boolean {
+    if (!child) return false;
+
+    const childStatus = child.realTimeStatus || 'idle';
+    const childProvider = getChildProvider(parent, child);
+
+    return (
+        childStatus === 'retry' ||
+        (childProvider === 'claude-code'
+            ? !!child.waitingForUser
+            : childStatus === 'busy' && !!child.waitingForUser)
+    );
+}
+
+function isFreshWaitingChildBlocker(parent: EnrichedSession, child: EnrichedChild | undefined, now: number): boolean {
+    if (!child) return false;
+
+    if (!shouldMarkChildWaitingForUser(parent, child)) {
+        return false;
+    }
+
+    const childUpdated = getChildActivityTimestamp(child);
+    return childUpdated !== undefined && (now - childUpdated) < CHILD_BLOCKER_STALENESS_MS;
+}
+
+function deriveChildDebugReason(
+    parent: EnrichedSession,
+    child: EnrichedChild | undefined,
+    now: number
+): SessionDebugReason | undefined {
     if (!child) return undefined;
     if (child.debugReason) return child.debugReason;
 
     const childStatus = child.realTimeStatus || 'idle';
-    if (child.waitingForUser || childStatus === 'retry') {
+    if (shouldMarkChildWaitingForUser(parent, child)) {
         return 'waiting_for_user';
     }
 
     if (childStatus === 'busy') {
-        const childUpdatedAt = child.time?.updated || child.time?.created;
+        const childUpdatedAt = getChildActivityTimestamp(child);
         return isRecentlyUpdated(childUpdatedAt, now) ? 'child_recent_activity' : 'child_unknown_fallback';
     }
 
@@ -53,8 +112,8 @@ function deriveSessionDebugReason({
 
     if (waitingForUser) {
         return (
-            deriveChildDebugReason(firstWaitingChild, now) ||
-            deriveChildDebugReason(firstActiveChild, now) ||
+            deriveChildDebugReason(session, firstWaitingChild, now) ||
+            deriveChildDebugReason(session, firstActiveChild, now) ||
             'waiting_for_user'
         );
     }
@@ -79,43 +138,35 @@ function deriveSessionDebugReason({
 export function transformSession(session: EnrichedSession): KanbanCard {
     let status: KanbanColumn;
     const children = session.children || [];
+    const rollupChildren = children.filter((child) => isVerifiedClaudeChild(session, child));
     const sessionSlug = typeof session.slug === 'string' ? session.slug : '';
 
-    // Staleness window: child blockers older than this don't keep parent in review
-    const CHILD_BLOCKER_STALENESS_MS = 10 * 60 * 1000; // 10 minutes
     const now = Date.now();
 
     const realTimeStatus = session.realTimeStatus || 'idle';
-    const hasActiveChildren = children.some((child) => {
+    const hasBusyChildren = rollupChildren.some((child) => {
         const childStatus = child.realTimeStatus || 'idle';
         return childStatus === 'busy' || childStatus === 'retry';
     });
+    const hasWaitingChildren = rollupChildren.some((child) => isFreshWaitingChildBlocker(session, child, now));
+    const hasActiveChildren = hasBusyChildren || hasWaitingChildren;
     const effectiveStatus =
         realTimeStatus === 'retry'
             ? 'retry'
             : (realTimeStatus === 'busy' || hasActiveChildren)
                 ? 'busy'
                 : 'idle';
-    const hasWaitingChildren = children.some((child) => {
-        const childStatus = child.realTimeStatus || 'idle';
-        const isBlocker = childStatus === 'retry' || (childStatus !== 'idle' && !!child.waitingForUser);
-        if (!isBlocker) return false;
-        // Only consider fresh blockers (within staleness window)
-        const childUpdated = child.time?.updated || now;
-        return (now - childUpdated) < CHILD_BLOCKER_STALENESS_MS;
-    });
     const parentWaiting = !!session.waitingForUser;
     const waitingForUser =
         effectiveStatus === 'retry' ||
         parentWaiting ||
-        (effectiveStatus === 'busy' && hasWaitingChildren);
-    const firstActiveChild = children.find((child) => {
+        hasWaitingChildren;
+    const firstActiveChild = rollupChildren.find((child) => {
         const childStatus = child.realTimeStatus || 'idle';
         return childStatus === 'busy' || childStatus === 'retry';
     });
-    const firstWaitingChild = children.find((child) => {
-        const childStatus = child.realTimeStatus || 'idle';
-        return childStatus === 'retry' || (childStatus !== 'idle' && !!child.waitingForUser);
+    const firstWaitingChild = rollupChildren.find((child) => {
+        return isFreshWaitingChildBlocker(session, child, now);
     });
     const debugReason = deriveSessionDebugReason({
         session,
@@ -136,8 +187,10 @@ export function transformSession(session: EnrichedSession): KanbanCard {
         status = 'idle';
     }
     
-     return {
-         id: session.id,
+      const providerDefaults = getDefaultProviderContext(session.provider ?? DEFAULT_PROVIDER_CONTEXT.provider);
+
+      return {
+          id: session.id,
          sessionSlug,
          title: session.title || 'Untitled Session',
          directory: session.directory,
@@ -161,19 +214,25 @@ export function transformSession(session: EnrichedSession): KanbanCard {
           hostBaseUrl: session.hostBaseUrl,
           rawSessionId: session.rawSessionId,
           sourceSessionKey: session.sourceSessionKey,
-          readOnly: session.readOnly,
-         children: children.map(c => ({
-             id: c.id,
-             title: c.title,
-             realTimeStatus: c.realTimeStatus || 'idle',
-             waitingForUser:
-                 (c.realTimeStatus || 'idle') === 'retry' ||
-                 ((c.realTimeStatus || 'idle') === 'busy' && !!c.waitingForUser),
-              debugReason: deriveChildDebugReason(c, now),
-             createdAt: c.time?.created || 0,
-             updatedAt: c.time?.updated || 0,
-         })),
-     };
+          readOnly: session.readOnly ?? providerDefaults.readOnly,
+          capabilities: session.capabilities ?? providerDefaults.capabilities,
+          provider: session.provider ?? providerDefaults.provider,
+          providerRawId: session.providerRawId ?? session.rawSessionId,
+          children: rollupChildren.map((c) => {
+              const childStatus = c.realTimeStatus || 'idle';
+              const childWaitingForUser = shouldMarkChildWaitingForUser(session, c);
+
+             return {
+                 id: c.id,
+                 title: c.title,
+                 realTimeStatus: childStatus,
+                 waitingForUser: childWaitingForUser,
+                 debugReason: deriveChildDebugReason(session, c, now),
+                 createdAt: c.time?.created || 0,
+                 updatedAt: c.time?.updated || 0,
+             };
+         }),
+      };
 }
 
 function extractAgents(slug?: string): string[] {

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

@@ -9,8 +9,17 @@ export type SessionDebugReason =
   | 'unknown_fallback'
   | 'waiting_for_user';
 
+export type SessionProvider = 'opencode' | 'claude-code';
+
+export interface SessionCapabilities {
+  openProject: boolean;
+  openEditor: boolean;
+  archive: boolean;
+  delete: boolean;
+}
+
 export interface KanbanCard {
-  id: string; // composite key: hostId:sessionId
+  id: string;
   sessionSlug: string;
   title: string;
   directory: string;
@@ -28,14 +37,16 @@ export interface KanbanCard {
   updatedAt: number;
   archivedAt?: number;
   sortOrder: number;
-  // Host-aware fields (direct, not nested)
   hostId?: string;
   hostLabel?: string;
   hostKind?: HostSourceKind;
   hostBaseUrl?: string;
-  rawSessionId?: string; // original session ID without host prefix
-  sourceSessionKey?: string; // alias for id, kept for compatibility
+  rawSessionId?: string;
+  sourceSessionKey?: string;
   readOnly?: boolean;
+  capabilities?: SessionCapabilities;
+  provider?: SessionProvider;
+  providerRawId?: string;
    children?: {
      id: string;
      title?: string;
@@ -47,15 +58,14 @@ export interface KanbanCard {
    }[];
 }
 
-// OpenCode event types
 export interface OpencodeSession {
-  id: string; // composite key: hostId:sessionId
+  id: string;
   slug: string;
   title?: string;
   directory: string;
   projectName?: string;
   branch?: string;
-  parentID?: string;  // Used to filter subagents
+  parentID?: string;
   time: {
     created: number;
     updated: number;
@@ -64,18 +74,20 @@ export interface OpencodeSession {
   messageCount?: number;
   hasTodos?: boolean;
   hasTranscript?: boolean;
-  realTimeStatus?: 'idle' | 'busy' | 'retry';  // Real-time status
+  realTimeStatus?: 'idle' | 'busy' | 'retry';
   waitingForUser?: boolean;
   debugReason?: SessionDebugReason;
   children?: OpencodeSession[];
-  // Host-aware fields (direct, not nested)
   hostId?: string;
   hostLabel?: string;
   hostKind?: HostSourceKind;
   hostBaseUrl?: string;
-  rawSessionId?: string; // original session ID without host prefix
-  sourceSessionKey?: string; // alias for id, kept for compatibility
+  rawSessionId?: string;
+  sourceSessionKey?: string;
   readOnly?: boolean;
+  capabilities?: SessionCapabilities;
+  provider?: SessionProvider;
+  providerRawId?: string;
 }
 
 export type OpencodeEventType =
@@ -105,10 +117,8 @@ export interface OpencodeEvent {
   timestamp: number;
 }
 
-// Status mapping
 export type OpencodeStatus = 'idle' | 'busy' | 'retry';
 
-// Host source types
 export type HostSourceKind = 'local' | 'remote';
 
 export interface BuiltInHostSource {
@@ -139,10 +149,6 @@ export interface HostStatus {
   baseUrl?: string;
 }
 
-// Host-aware fields that appear directly on sessions/cards
-// (not nested in a wrapper object)
-
-// Type guards
 export function isKanbanColumn(value: string): value is KanbanColumn {
   return ['idle', 'busy', 'review', 'done'].includes(value);
 }