vibepulse 0.2.2 → 0.3.1-beta

package/.next/standalone/src/app/api/opencode-events/route.test.ts

@@ -251,6 +251,59 @@ describe('/api/opencode-events', () => {
     await reader!.cancel();
   });
 
+  it('streams from the next discovered OpenCode port when the first local port preflight fails', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    mockDiscoverPortsWithMeta.mockReturnValue({ ports: [7777, 7778], timedOut: false });
+
+    mockCreateOpencodeClient.mockImplementation(({ baseUrl }: { baseUrl: string }) => ({
+      global: {
+        event: vi.fn(async () => {
+          if (baseUrl === 'http://localhost:7777') {
+            throw new Error('port 7777 offline');
+          }
+
+          return {
+            stream: createAsyncIterable([
+              {
+                type: 'session.status',
+                properties: {
+                  sessionID: 'surviving-port-session',
+                  status: { type: 'busy' },
+                },
+                timestamp: 400,
+              },
+            ]),
+          };
+        }),
+      },
+    }) as never);
+
+    const response = await GET(new Request('http://localhost/api/opencode-events'));
+
+    expect(response.status).toBe(200);
+    expect(mockCreateOpencodeClient.mock.calls).toEqual(expect.arrayContaining([
+      [{ baseUrl: 'http://localhost:7777' }],
+      [{ baseUrl: 'http://localhost:7778' }],
+    ]));
+    expect(mockCreateOpencodeClient.mock.calls.length).toBeGreaterThanOrEqual(2);
+
+    const reader = response.body?.getReader();
+    expect(reader).toBeTruthy();
+
+    const first = await readPayload(reader!);
+    expect(first).toEqual({
+      type: 'session.status',
+      properties: {
+        sessionID: 'surviving-port-session',
+        status: { type: 'busy' },
+      },
+      timestamp: 400,
+    });
+
+    await reader!.cancel();
+    warnSpy.mockRestore();
+  });
+
   it('keeps the shared stream alive when one remote node stream fails', async () => {
     mockGlobalEvent.mockResolvedValue({
       stream: createAsyncIterable([
@@ -493,7 +546,7 @@ describe('/api/opencode-events', () => {
     const reader = response.body?.getReader();
     expect(reader).toBeTruthy();
 
-    const first = await readPayload(reader!);
+    const first = (await readPayload(reader!)) as any;
     expect(first).toEqual({
       type: 'session.status',
       properties: {
@@ -502,6 +555,8 @@ describe('/api/opencode-events', () => {
       },
       timestamp: 100,
     });
+    expect(first.source).toBeUndefined();
+    expect(first.event).toBeUndefined();
 
     await reader!.cancel();
   });
@@ -621,4 +676,25 @@ describe('/api/opencode-events', () => {
 
     warnSpy.mockRestore();
   });
+
+  it('returns a graceful unavailable response when latest root SDK event preflight rejects with BadRequest shape', async () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    mockGlobalEvent.mockRejectedValue({
+      name: 'BadRequestError',
+      status: 400,
+      body: { message: 'event stream unavailable' },
+    });
+
+    const response = await GET(new Request('http://localhost/api/opencode-events'));
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual({
+      error: 'Failed to connect to OpenCode event streams',
+      hint: 'Detected local and/or remote node event sources, but every streaming handshake failed. Ensure the hub can reach each source and retry.',
+    });
+    expect(mockGlobalEvent).toHaveBeenCalledWith({ signal: expect.any(AbortSignal) });
+
+    warnSpy.mockRestore();
+  });
 });

package/.next/standalone/src/app/api/opencode-events/route.ts

@@ -1,8 +1,8 @@
-import { createOpencodeClient } from '@opencode-ai/sdk';
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import { NODE_PROTOCOL_VERSION, createNodeRequestHeaders } from '@/lib/nodeProtocol';
 import { listNodeRecords, type StoredNodeRecord } from '@/lib/nodeRegistry';
 import { RUNTIME_ROLE_ENV_VAR } from '@/lib/runtimeMode';
+import { createVibePulseOpencodeClient, streamOpencodeGlobalEvents } from '@/lib/session-providers/opencodeSdkCompat';
 
 const DEFAULT_EVENTS_PREFLIGHT_TIMEOUT_MS = 2500;
 
@@ -106,7 +106,7 @@ async function connectLocalEventStreamWithTimeout(
   controller?: AbortController
 ): Promise<ConnectedStream> {
   const connectionController = controller ?? new AbortController();
-  const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
+  const client = createVibePulseOpencodeClient(`http://localhost:${port}`);
 
   let timerId: ReturnType<typeof setTimeout> | null = null;
   const timeoutPromise = new Promise<never>((_, reject) => {
@@ -118,7 +118,7 @@ async function connectLocalEventStreamWithTimeout(
 
   try {
     const connection = await Promise.race([
-      client.global.event({ signal: connectionController.signal }),
+      streamOpencodeGlobalEvents(client, connectionController.signal),
       timeoutPromise,
     ]);
 

package/.next/standalone/src/app/api/opencode-models/route.test.ts

@@ -53,6 +53,25 @@ describe('/api/opencode-models', () => {
       expect(result.source).toBe('opencode');
       expect(result.models).toContain('anthropic/claude');
     });
+
+    it('should trim models and ignore provider headers, whitespace, and stderr noise', () => {
+      const result = handleExecResult(
+        null,
+        '\nAnthropic\n  anthropic/claude-3.5-sonnet  \n\nOpenAI\n\topenai/gpt-4o\t\nLoaded 2 providers\n',
+        'debug: provider cache refreshed\nwarning: extra stderr noise'
+      );
+
+      expect(result.source).toBe('opencode');
+      expect(result.models).toEqual(['anthropic/claude-3.5-sonnet', 'openai/gpt-4o']);
+    });
+
+    it('should reject non-slash CLI output as an error', () => {
+      const result = handleExecResult(null, 'Anthropic\nOpenAI\nNo models configured\n', '');
+
+      expect(result.source).toBe('error');
+      expect(result.models).toEqual([]);
+      expect(result.error).toContain('No models found');
+    });
   });
 
   describe('GET API Integration Tests', () => {

package/.next/standalone/src/app/api/opencode-models/route.ts

@@ -41,7 +41,10 @@ export function handleExecResult(
   }
 
   try {
-    const models = stdout.trim().split('\n').filter(line => line.includes('/'));
+    const models = stdout
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line.includes('/'));
     if (models.length === 0) {
       return { models: [], source: 'error', error: 'No models found. Please check your OpenCode installation.' };
     }

package/.next/standalone/src/app/api/profiles/[id]/apply/route.test.ts

@@ -0,0 +1,227 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/profiles/storage', () => ({
+  readProfileConfig: vi.fn(),
+  getProfileById: vi.fn(),
+  setActiveProfileId: vi.fn(),
+}));
+
+vi.mock('@/lib/opencodeConfig', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/opencodeConfig')>('@/lib/opencodeConfig');
+  return {
+    ...actual,
+    readConfig: vi.fn(),
+    writeConfig: vi.fn(),
+  };
+});
+
+import {
+  getProfileById,
+  readProfileConfig,
+  setActiveProfileId,
+} from '@/lib/profiles/storage';
+import { readConfig, writeConfig } from '@/lib/opencodeConfig';
+import { createExportedProfileFile, parseImportedProfileFile } from '@/lib/profiles/share';
+import { POST } from './route';
+
+const mockReadProfileConfig = vi.mocked(readProfileConfig);
+const mockGetProfileById = vi.mocked(getProfileById);
+const mockSetActiveProfileId = vi.mocked(setActiveProfileId);
+const mockReadConfig = vi.mocked(readConfig);
+const mockWriteConfig = vi.mocked(writeConfig);
+let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+describe('/api/profiles/[id]/apply', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('applies a profile as a v4 overlay without deleting absent config keys', async () => {
+    const exportedProfile = createExportedProfileFile(
+      {
+        id: 'v4-overlay',
+        name: 'V4 Overlay',
+        emoji: '🧩',
+        createdAt: '2026-05-11T00:00:00.000Z',
+        updatedAt: '2026-05-11T00:00:00.000Z',
+      },
+      {
+        agents: {
+          sisyphus: {
+            fallback_models: [
+              'anthropic/claude-opus-4-6',
+              {
+                model: 'google/gemini-3.1-pro',
+                variant: 'high',
+                reasoningEffort: 'max',
+                maxTokens: 32000,
+                thinking: { enabled: true },
+                futureFallbackField: 'preserve-me',
+              },
+            ],
+            reasoningEffort: 'max',
+            maxTokens: 64000,
+            thinking: { type: 'enabled', budget_tokens: 12000 },
+            future_agent_knob: { mode: 'experimental' },
+          },
+        },
+        categories: {
+          ultrabrain: {
+            reasoningEffort: 'max',
+            fallback_models: [
+              'openai/gpt-5.4',
+              { model: 'anthropic/claude-opus-4-6', reasoningEffort: 'max' },
+            ],
+            future_category_knob: 'keep-me',
+          },
+        },
+        team_mode: {
+          enabled: true,
+          strategy: 'pairing',
+        },
+        metadata: {
+          owner: 'platform',
+        },
+      }
+    );
+    const importedProfile = parseImportedProfileFile(exportedProfile);
+
+    mockGetProfileById.mockResolvedValue({
+      ...importedProfile.profile,
+      createdAt: '2026-05-11T00:00:00.000Z',
+      updatedAt: '2026-05-11T00:00:00.000Z',
+    });
+    mockReadProfileConfig.mockResolvedValue(importedProfile.config);
+    mockReadConfig.mockResolvedValue({
+      agents: {
+        sisyphus: {
+          model: 'openai/gpt-5.4',
+          fallback_models: ['anthropic/claude-opus-4-6'],
+          system: 'Keep this system prompt',
+        },
+        oracle: {
+          model: 'openai/gpt-5.4',
+        },
+      },
+      categories: {
+        deep: {
+          model: 'openai/gpt-5.4',
+          variant: 'medium',
+        },
+      },
+      tools: {
+        shell: { enabled: true },
+      },
+    });
+    mockWriteConfig.mockResolvedValue();
+    mockSetActiveProfileId.mockResolvedValue();
+
+    const response = await POST(new Request('http://localhost/api/profiles/v4-overlay/apply') as never, {
+      params: Promise.resolve({ id: 'v4-overlay' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockWriteConfig).toHaveBeenCalledWith({
+      agents: {
+        sisyphus: {
+          model: 'openai/gpt-5.4',
+          fallback_models: [
+            'anthropic/claude-opus-4-6',
+            {
+              model: 'google/gemini-3.1-pro',
+              variant: 'high',
+              reasoningEffort: 'max',
+              maxTokens: 32000,
+              thinking: { enabled: true },
+              futureFallbackField: 'preserve-me',
+            },
+          ],
+          reasoningEffort: 'max',
+          maxTokens: 64000,
+          thinking: { type: 'enabled', budget_tokens: 12000 },
+          future_agent_knob: { mode: 'experimental' },
+          system: 'Keep this system prompt',
+        },
+        oracle: {
+          model: 'openai/gpt-5.4',
+        },
+      },
+      categories: {
+        deep: {
+          model: 'openai/gpt-5.4',
+          variant: 'medium',
+        },
+        ultrabrain: {
+          reasoningEffort: 'max',
+          fallback_models: [
+            'openai/gpt-5.4',
+            { model: 'anthropic/claude-opus-4-6', reasoningEffort: 'max' },
+          ],
+          future_category_knob: 'keep-me',
+        },
+      },
+      team_mode: {
+        enabled: true,
+        strategy: 'pairing',
+      },
+      metadata: {
+        owner: 'platform',
+      },
+      tools: {
+        shell: { enabled: true },
+      },
+    });
+    expect(mockSetActiveProfileId).toHaveBeenCalledWith('v4-overlay');
+  });
+
+  it('rolls config back when setting the active profile fails', async () => {
+    const currentConfig = {
+      agents: {
+        oracle: { model: 'openai/gpt-5.4' },
+      },
+      team_mode: {
+        enabled: false,
+      },
+    };
+
+    mockGetProfileById.mockResolvedValue({
+      id: 'v4-overlay',
+      name: 'V4 Overlay',
+      emoji: '🧩',
+      createdAt: '2026-05-11T00:00:00.000Z',
+      updatedAt: '2026-05-11T00:00:00.000Z',
+    });
+    mockReadProfileConfig.mockResolvedValue({
+      agents: {
+        oracle: { model: 'anthropic/claude-opus-4-6' },
+      },
+      team_mode: {
+        enabled: true,
+      },
+    });
+    mockReadConfig.mockResolvedValue(currentConfig);
+    mockWriteConfig.mockResolvedValue();
+    mockSetActiveProfileId.mockRejectedValue(new Error('index write failed'));
+
+    const response = await POST(new Request('http://localhost/api/profiles/v4-overlay/apply') as never, {
+      params: Promise.resolve({ id: 'v4-overlay' }),
+    });
+
+    expect(response.status).toBe(500);
+    expect(mockWriteConfig).toHaveBeenNthCalledWith(1, {
+      agents: {
+        oracle: { model: 'anthropic/claude-opus-4-6' },
+      },
+      team_mode: {
+        enabled: true,
+      },
+    });
+    expect(mockWriteConfig).toHaveBeenNthCalledWith(2, currentConfig);
+    expect(mockSetActiveProfileId).toHaveBeenCalledTimes(1);
+  });
+});

package/.next/standalone/src/app/api/profiles/[id]/apply/route.ts

@@ -4,7 +4,7 @@ import {
   getProfileById,
   setActiveProfileId,
 } from '@/lib/profiles/storage';
-import { readConfig, writeConfig } from '@/lib/opencodeConfig';
+import { mergeConfig, readConfig, writeConfig } from '@/lib/opencodeConfig';
 
 interface RouteParams {
   params: Promise<{ id: string }>;
@@ -24,15 +24,19 @@ export async function POST(_request: NextRequest, { params }: RouteParams) {
 
     const profileConfig = await readProfileConfig(id);
     const currentConfig = await readConfig();
+    const mergedConfig = mergeConfig(currentConfig, profileConfig);
+    let configWasWritten = false;
 
-    const mergedConfig = {
-      ...currentConfig,
-      agents: profileConfig.agents,
-      categories: profileConfig.categories,
-    };
-
-    await writeConfig(mergedConfig);
-    await setActiveProfileId(id);
+    try {
+      await writeConfig(mergedConfig);
+      configWasWritten = true;
+      await setActiveProfileId(id);
+    } catch (error) {
+      if (configWasWritten) {
+        await writeConfig(currentConfig);
+      }
+      throw error;
+    }
 
     return NextResponse.json({
       message: 'Profile applied successfully',

package/.next/standalone/src/app/api/sessions/[id]/archive/route.test.ts

@@ -13,13 +13,19 @@ vi.mock('@/lib/sessionArchiveOverrides', () => ({
   markSessionStickyStatusBlocked: vi.fn(),
 }));
 
+vi.mock('@/lib/claudeSessionOverrides', () => ({
+  markClaudeSessionArchived: vi.fn(),
+}));
+
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import { listNodeRecords } from '@/lib/nodeRegistry';
+import { markClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
 
 import { POST } from './route';
 
 const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
 const mockListNodeRecords: any = listNodeRecords;
+const mockMarkClaudeSessionArchived: any = markClaudeSessionArchived;
 
 describe('/api/sessions/[id]/archive', () => {
   beforeEach(() => {
@@ -40,6 +46,48 @@ describe('/api/sessions/[id]/archive', () => {
     expect(mockFetch).toHaveBeenCalledWith('http://localhost:7777/session/abc', expect.objectContaining({ method: 'PATCH' }));
   });
 
+  it('archives on the next discovered OpenCode port when the first port fails', async () => {
+    mockDiscoverPortsWithMeta.mockReturnValue({ ports: [7777, 7778], timedOut: false });
+    const mockFetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString();
+      if (url === 'http://localhost:7777/session/abc') {
+        throw new Error('port 7777 offline');
+      }
+
+      if (url === 'http://localhost:7778/session/abc') {
+        return new Response('', { status: 200 });
+      }
+
+      throw new Error(`Unexpected archive URL: ${url}`);
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockFetch).toHaveBeenCalledWith('http://localhost:7777/session/abc', expect.objectContaining({ method: 'PATCH' }));
+    expect(mockFetch).toHaveBeenCalledWith('http://localhost:7778/session/abc', expect.objectContaining({ method: 'PATCH' }));
+  });
+
+  it('treats UUID-like local ids without claude namespace as opencode sessions', async () => {
+    const opencodeUuid = '550e8400-e29b-41d4-a716-446655440000';
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ error: 'missing' }), { status: 404 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request(`http://localhost/api/sessions/local:${opencodeUuid}/archive`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${opencodeUuid}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
+    expect(mockMarkClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).toHaveBeenCalled();
+    expect(mockFetch).toHaveBeenCalledWith(`http://localhost:7777/session/${opencodeUuid}`, expect.objectContaining({ method: 'PATCH' }));
+  });
+
   it('forwards remote archive ids to the matching node endpoint', async () => {
     mockListNodeRecords.mockResolvedValue([
       {
@@ -98,6 +146,84 @@ describe('/api/sessions/[id]/archive', () => {
     expect(data).toEqual({ error: 'Session not found', reason: 'session_not_found' });
   });
 
+  it('archives Claude sessions through local override storage before any OpenCode execution', async () => {
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:claude~550e8400-e29b-41d4-a716-446655440000/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:claude~550e8400-e29b-41d4-a716-446655440000' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkClaudeSessionArchived).toHaveBeenCalledWith('550e8400-e29b-41d4-a716-446655440000');
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('archives scoped Claude sidechain sessions through local override storage', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request(`http://localhost/api/sessions/local:${scopedSessionId}/archive`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkClaudeSessionArchived).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote Claude archive requests before local override or node execution', async () => {
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:claude~550e8400-e29b-41d4-a716-446655440000/archive', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:claude~550e8400-e29b-41d4-a716-446655440000' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(403);
+    expect(data).toEqual({
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider: 'claude-code',
+      capability: 'archive',
+    });
+    expect(mockMarkClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote scoped Claude sidechain archive requests before node execution', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+    const mockFetch = vi.fn();
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request(`http://localhost/api/sessions/node-1:${scopedSessionId}/archive`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `node-1:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(403);
+    expect(data).toEqual({
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider: 'claude-code',
+      capability: 'archive',
+    });
+    expect(mockMarkClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
   it('does not misclassify non-404 local archive failures as session_not_found', async () => {
     const mockFetch = vi.fn(async () => new Response(JSON.stringify({ error: 'boom' }), { status: 500 }));
     vi.stubGlobal('fetch', mockFetch);

package/.next/standalone/src/app/api/sessions/[id]/archive/route.ts

@@ -1,11 +1,13 @@
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
-import { parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
+import { ActionSessionReference, parseActionSessionReference, resolveLocalActionSessionId } from '@/lib/hostIdentity';
 import { listNodeRecords } from '@/lib/nodeRegistry';
 import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import { detectProviderFromRawId, extractProviderRawId, getDefaultProviderContext } from '@/lib/session-providers/providerIds';
 import {
-    clearSessionForceUnarchived,
-    markSessionStickyStatusBlocked,
+  clearSessionForceUnarchived,
+  markSessionStickyStatusBlocked,
 } from '@/lib/sessionArchiveOverrides';
+import { markClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
 
 const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
 
@@ -23,6 +25,20 @@ function createSessionNotFoundResponse() {
     );
 }
 
+function createUnsupportedCapabilityResponse(capability: 'archive', sessionId: string) {
+    const provider = detectProviderFromRawId(sessionId);
+
+    return Response.json(
+        {
+            error: 'Session action not supported by provider',
+            reason: 'provider_capability_unsupported',
+            provider,
+            capability,
+        },
+        { status: 403 }
+    );
+}
+
 function createArchiveFailureResponse(
     status: number,
     message?: string,
@@ -87,17 +103,36 @@ async function forwardRemoteArchive(hostId: string, sessionId: string): Promise<
 
 export async function POST(_: Request, { params }: { params: Promise<{ id: string }> }) {
     const { id } = await params;
-    const sessionId = resolveLocalActionSessionId(id);
+    let actionTarget: ActionSessionReference;
 
-    if (!sessionId) {
-        try {
-            const actionTarget = parseActionSessionReference(id);
-            if (actionTarget.isRemote) {
-                return forwardRemoteArchive(actionTarget.hostId, actionTarget.sessionId);
-            }
-        } catch {
-            return createInvalidActionSessionIdResponse();
+    try {
+        actionTarget = parseActionSessionReference(id);
+    } catch {
+        return createInvalidActionSessionIdResponse();
+    }
+
+    const provider = detectProviderFromRawId(actionTarget.sessionId);
+    if (!getDefaultProviderContext(provider).capabilities.archive) {
+        return createUnsupportedCapabilityResponse('archive', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code' && actionTarget.isRemote) {
+        return createUnsupportedCapabilityResponse('archive', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code') {
+        await markClaudeSessionArchived(extractProviderRawId(actionTarget.sessionId));
+        const localSessionId = resolveLocalActionSessionId(id);
+        if (localSessionId) {
+            clearSessionForceUnarchived(localSessionId);
+            markSessionStickyStatusBlocked(localSessionId);
         }
+        return Response.json({ success: true });
+    }
+
+    const sessionId = resolveLocalActionSessionId(id);
+    if (!sessionId && actionTarget.isRemote) {
+        return forwardRemoteArchive(actionTarget.hostId, actionTarget.sessionId);
     }
 
     if (!sessionId) {