vibepulse 0.2.2 → 0.3.1-beta

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/lib/claudeSessionOverrides.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from 'vitest';
+import { mkdtemp, readFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+async function withTempHome<T>(fn: (homeDir: string) => Promise<T>): Promise<T> {
+  const homeDir = await mkdtemp(join(tmpdir(), 'vibepulse-claude-overrides-'));
+  const originalHome = process.env.HOME;
+  process.env.HOME = homeDir;
+  try {
+    return await fn(homeDir);
+  } finally {
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    await rm(homeDir, { recursive: true, force: true });
+  }
+}
+
+describe('claudeSessionOverrides', () => {
+  it('persists archived and deleted Claude overrides to the local registry file', async () => {
+    await withTempHome(async (homeDir) => {
+      const mod = await import('./claudeSessionOverrides');
+      await mod.markClaudeSessionArchived('session-a', 100);
+      await mod.markClaudeSessionDeleted('session-b', 200);
+
+      const entries = await mod.listClaudeSessionOverrides();
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-a', archivedAt: 100 }),
+        expect.objectContaining({ sessionId: 'session-b', deletedAt: 200 }),
+      ]));
+
+      const content = await readFile(join(homeDir, '.config', 'vibepulse', 'claude-session-overrides.jsonc'), 'utf-8');
+      expect(content).toContain('session-a');
+      expect(content).toContain('session-b');
+    });
+  });
+
+  it('preserves all entries under concurrent override writes', async () => {
+    await withTempHome(async () => {
+      const mod = await import('./claudeSessionOverrides');
+
+      await Promise.all([
+        mod.markClaudeSessionArchived('session-a', 100),
+        mod.markClaudeSessionDeleted('session-b', 200),
+        mod.markClaudeSessionArchived('session-c', 300),
+      ]);
+
+      const entries = await mod.listClaudeSessionOverrides();
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-a', archivedAt: 100 }),
+        expect.objectContaining({ sessionId: 'session-b', deletedAt: 200 }),
+        expect.objectContaining({ sessionId: 'session-c', archivedAt: 300 }),
+      ]));
+      expect(entries).toHaveLength(3);
+    });
+  });
+
+  it('can clear archived state while preserving deleted state when restoring a Claude session', async () => {
+    await withTempHome(async () => {
+      const mod = await import('./claudeSessionOverrides');
+      await mod.markClaudeSessionArchived('session-a', 100);
+      await mod.markClaudeSessionDeleted('session-b', 200);
+      await mod.clearClaudeSessionArchived('session-a');
+      await mod.clearClaudeSessionArchived('session-b');
+
+      const entries = await mod.listClaudeSessionOverrides();
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-b', deletedAt: 200, restoredAt: expect.any(Number) }),
+      ]));
+      expect(entries).toEqual(expect.arrayContaining([
+        expect.objectContaining({ sessionId: 'session-a', restoredAt: expect.any(Number) }),
+      ]));
+    });
+  });
+});

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

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync } from 'fs';
+import { readFile, rename, writeFile } from 'fs/promises';
+import { homedir } from 'os';
+import { join } from 'path';
+import { parse, stringify } from 'comment-json';
+
+export const VIBEPULSE_CONFIG_DIR = join(homedir(), '.config', 'vibepulse');
+export const CLAUDE_SESSION_OVERRIDES_PATH = join(VIBEPULSE_CONFIG_DIR, 'claude-session-overrides.jsonc');
+
+export interface ClaudeSessionOverrideEntry {
+  sessionId: string;
+  archivedAt?: number;
+  deletedAt?: number;
+  restoredAt?: number;
+  updatedAt: number;
+}
+
+interface ClaudeSessionOverridesFile {
+  version: number;
+  sessions: ClaudeSessionOverrideEntry[];
+}
+
+let claudeOverrideWriteQueue: Promise<void> = Promise.resolve();
+
+function ensureConfigDir(): void {
+  if (!existsSync(VIBEPULSE_CONFIG_DIR)) {
+    mkdirSync(VIBEPULSE_CONFIG_DIR, { recursive: true });
+  }
+}
+
+function defaultOverrides(): ClaudeSessionOverridesFile {
+  return {
+    version: 1,
+    sessions: [],
+  };
+}
+
+function normalizeEntry(entry: unknown): ClaudeSessionOverrideEntry | null {
+  if (!entry || typeof entry !== 'object') return null;
+  const candidate = entry as Record<string, unknown>;
+  if (typeof candidate.sessionId !== 'string' || typeof candidate.updatedAt !== 'number') return null;
+  if (candidate.archivedAt !== undefined && typeof candidate.archivedAt !== 'number') return null;
+  if (candidate.deletedAt !== undefined && typeof candidate.deletedAt !== 'number') return null;
+  if (candidate.restoredAt !== undefined && typeof candidate.restoredAt !== 'number') return null;
+
+  return {
+    sessionId: candidate.sessionId,
+    updatedAt: candidate.updatedAt,
+    ...(typeof candidate.archivedAt === 'number' ? { archivedAt: candidate.archivedAt } : {}),
+    ...(typeof candidate.deletedAt === 'number' ? { deletedAt: candidate.deletedAt } : {}),
+    ...(typeof candidate.restoredAt === 'number' ? { restoredAt: candidate.restoredAt } : {}),
+  };
+}
+
+async function readOverridesFile(): Promise<ClaudeSessionOverridesFile> {
+  try {
+    ensureConfigDir();
+    if (!existsSync(CLAUDE_SESSION_OVERRIDES_PATH)) {
+      const initial = defaultOverrides();
+      await writeOverridesFile(initial);
+      return initial;
+    }
+
+    const raw = await readFile(CLAUDE_SESSION_OVERRIDES_PATH, 'utf-8');
+    const parsed = parse(raw, null, false) as unknown;
+    if (!parsed || typeof parsed !== 'object') {
+      return defaultOverrides();
+    }
+
+    const file = parsed as Record<string, unknown>;
+    const sessions = Array.isArray(file.sessions)
+      ? file.sessions.map(normalizeEntry).filter((entry): entry is ClaudeSessionOverrideEntry => entry !== null)
+      : [];
+
+    return {
+      version: typeof file.version === 'number' ? file.version : 1,
+      sessions,
+    };
+  } catch {
+    return defaultOverrides();
+  }
+}
+
+async function writeOverridesFile(file: ClaudeSessionOverridesFile): Promise<void> {
+  ensureConfigDir();
+  const tempPath = `${CLAUDE_SESSION_OVERRIDES_PATH}.tmp`;
+  await writeFile(tempPath, stringify(file, null, 2), 'utf-8');
+  await rename(tempPath, CLAUDE_SESSION_OVERRIDES_PATH);
+}
+
+export async function listClaudeSessionOverrides(): Promise<ClaudeSessionOverrideEntry[]> {
+  const file = await readOverridesFile();
+  return file.sessions;
+}
+
+export async function getClaudeSessionOverride(sessionId: string): Promise<ClaudeSessionOverrideEntry | null> {
+  const file = await readOverridesFile();
+  return file.sessions.find((entry) => entry.sessionId === sessionId) ?? null;
+}
+
+async function upsertClaudeSessionOverride(
+  sessionId: string,
+  mutate: (current: ClaudeSessionOverrideEntry | null, now: number) => ClaudeSessionOverrideEntry | null,
+): Promise<void> {
+  const run = async () => {
+    const file = await readOverridesFile();
+    const now = Date.now();
+    const current = file.sessions.find((entry) => entry.sessionId === sessionId) ?? null;
+    const next = mutate(current, now);
+    const withoutCurrent = file.sessions.filter((entry) => entry.sessionId !== sessionId);
+    file.sessions = next ? [...withoutCurrent, next] : withoutCurrent;
+    await writeOverridesFile(file);
+  };
+
+  const queued = claudeOverrideWriteQueue.then(run, run);
+  claudeOverrideWriteQueue = queued.then(() => undefined, () => undefined);
+  await queued;
+}
+
+export async function markClaudeSessionArchived(sessionId: string, archivedAt: number = Date.now()): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (current, now) => ({
+    sessionId,
+    archivedAt,
+    deletedAt: current?.deletedAt,
+    restoredAt: undefined,
+    updatedAt: now,
+  }));
+}
+
+export async function markClaudeSessionDeleted(sessionId: string, deletedAt: number = Date.now()): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (_current, now) => ({
+    sessionId,
+    deletedAt,
+    restoredAt: undefined,
+    updatedAt: now,
+  }));
+}
+
+export async function clearClaudeSessionDeleted(sessionId: string): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (current, now) => {
+    if (!current) return null;
+    if (current.archivedAt === undefined) return null;
+    return {
+      sessionId,
+      archivedAt: current.archivedAt,
+      restoredAt: current.restoredAt,
+      updatedAt: now,
+    };
+  });
+}
+
+export async function clearClaudeSessionArchived(sessionId: string): Promise<void> {
+  await upsertClaudeSessionOverride(sessionId, (current, now) => {
+    if (!current) return null;
+    if (current.deletedAt !== undefined) {
+      return {
+        sessionId,
+        deletedAt: current.deletedAt,
+        restoredAt: now,
+        updatedAt: now,
+      };
+    }
+    return {
+      sessionId,
+      restoredAt: now,
+      updatedAt: now,
+    };
+  });
+}