vibepulse 0.2.2 → 0.3.1-beta

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

@@ -17,15 +17,21 @@ vi.mock('@/lib/sessionArchiveOverrides', () => ({
   clearSessionStickyStatusBlocked: vi.fn(),
 }));
 
+vi.mock('@/lib/claudeSessionOverrides', () => ({
+  markClaudeSessionDeleted: vi.fn(),
+}));
+
 import { createOpencodeClient } from '@opencode-ai/sdk';
 import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
 import { listNodeRecords } from '@/lib/nodeRegistry';
+import { markClaudeSessionDeleted } from '@/lib/claudeSessionOverrides';
 
 import { POST } from './route';
 
 const mockCreateOpencodeClient: any = createOpencodeClient;
 const mockDiscoverPortsWithMeta: any = discoverOpencodePortsWithMeta;
 const mockListNodeRecords: any = listNodeRecords;
+const mockMarkClaudeSessionDeleted: any = markClaudeSessionDeleted;
 const mockSessionDelete = vi.fn();
 
 describe('/api/sessions/[id]/delete', () => {
@@ -50,6 +56,33 @@ describe('/api/sessions/[id]/delete', () => {
     expect(mockSessionDelete).toHaveBeenCalledWith({ path: { id: 'abc' } });
   });
 
+  it('deletes on the next discovered OpenCode port when the first port fails', async () => {
+    mockDiscoverPortsWithMeta.mockReturnValue({ ports: [7777, 7778], timedOut: false });
+    const deleteByPort: Record<string, ReturnType<typeof vi.fn>> = {
+      'http://localhost:7777': vi.fn(async () => {
+        throw new Error('port 7777 offline');
+      }),
+      'http://localhost:7778': vi.fn(async () => undefined),
+    };
+    mockCreateOpencodeClient.mockImplementation(({ baseUrl }: { baseUrl: string }) => ({
+      session: {
+        delete: deleteByPort[baseUrl],
+      },
+    }) as never);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(mockCreateOpencodeClient.mock.calls).toEqual([
+      [{ baseUrl: 'http://localhost:7777' }],
+      [{ baseUrl: 'http://localhost:7778' }],
+    ]);
+    expect(deleteByPort['http://localhost:7777']).toHaveBeenCalledWith({ path: { id: 'abc' } });
+    expect(deleteByPort['http://localhost:7778']).toHaveBeenCalledWith({ path: { id: 'abc' } });
+  });
+
   it('forwards remote delete ids to the matching node endpoint', async () => {
     mockListNodeRecords.mockResolvedValue([
       {
@@ -110,4 +143,111 @@ describe('/api/sessions/[id]/delete', () => {
       message: '404 not found',
     });
   });
+
+  it('maps object-shaped SDK BadRequest delete failures to session_not_found', async () => {
+    mockSessionDelete.mockRejectedValue({
+      name: 'BadRequestError',
+      statusCode: 404,
+      data: { error: 'session not found' },
+    });
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:abc/delete', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(404);
+    expect(data).toEqual({
+      error: 'Session not found',
+      reason: 'session_not_found',
+      message: 'BadRequestError 404: session not found',
+    });
+    expect(mockSessionDelete).toHaveBeenCalledWith({ path: { id: 'abc' } });
+  });
+
+  it('deletes 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/delete', { 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(mockMarkClaudeSessionDeleted).toHaveBeenCalledWith('550e8400-e29b-41d4-a716-446655440000');
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('deletes 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}/delete`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkClaudeSessionDeleted).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote Claude delete 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/delete', { 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: 'delete',
+    });
+    expect(mockMarkClaudeSessionDeleted).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote scoped Claude sidechain deletes 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}/delete`, { 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: 'delete',
+    });
+    expect(mockMarkClaudeSessionDeleted).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverPortsWithMeta).not.toHaveBeenCalled();
+    expect(mockCreateOpencodeClient).not.toHaveBeenCalled();
+    expect(mockSessionDelete).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
 });

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

@@ -1,12 +1,14 @@
-import { createOpencodeClient } from '@opencode-ai/sdk';
 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 { createVibePulseOpencodeClient, deleteOpencodeSession, formatOpencodeSdkError } from '@/lib/session-providers/opencodeSdkCompat';
+import { detectProviderFromRawId, extractProviderRawId, getDefaultProviderContext } from '@/lib/session-providers/providerIds';
 import {
     clearSessionForceUnarchived,
     clearSessionStickyStatusBlocked,
 } from '@/lib/sessionArchiveOverrides';
+import { markClaudeSessionDeleted } from '@/lib/claudeSessionOverrides';
 
 const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
 
@@ -28,6 +30,20 @@ function createSessionNotFoundResponse(message?: string) {
     );
 }
 
+function createUnsupportedCapabilityResponse(capability: 'delete', sessionId: string) {
+    const provider = detectProviderFromRawId(sessionId);
+
+    return Response.json(
+        {
+            error: 'Session action not supported by provider',
+            reason: 'provider_capability_unsupported',
+            provider,
+            capability,
+        },
+        { status: 403 }
+    );
+}
+
 async function forwardRemoteDelete(hostId: string, sessionId: string): Promise<Response> {
     const nodeRecords = await listNodeRecords();
     const nodeRecord = nodeRecords.find((node) => node.nodeId === hostId);
@@ -77,17 +93,36 @@ async function forwardRemoteDelete(hostId: string, sessionId: string): Promise<R
 
 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 forwardRemoteDelete(actionTarget.hostId, actionTarget.sessionId);
-            }
-        } catch {
-            return createInvalidActionSessionIdResponse();
+    try {
+        actionTarget = parseActionSessionReference(id);
+    } catch {
+        return createInvalidActionSessionIdResponse();
+    }
+
+    const provider = detectProviderFromRawId(actionTarget.sessionId);
+    if (!getDefaultProviderContext(provider).capabilities.delete) {
+        return createUnsupportedCapabilityResponse('delete', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code' && actionTarget.isRemote) {
+        return createUnsupportedCapabilityResponse('delete', actionTarget.sessionId);
+    }
+
+    if (provider === 'claude-code') {
+        await markClaudeSessionDeleted(extractProviderRawId(actionTarget.sessionId));
+        const localSessionId = resolveLocalActionSessionId(id);
+        if (localSessionId) {
+            clearSessionForceUnarchived(localSessionId);
+            clearSessionStickyStatusBlocked(localSessionId);
         }
+        return Response.json({ success: true });
+    }
+
+    const sessionId = resolveLocalActionSessionId(id);
+    if (!sessionId && actionTarget.isRemote) {
+        return forwardRemoteDelete(actionTarget.hostId, actionTarget.sessionId);
     }
 
     if (!sessionId) {
@@ -111,8 +146,8 @@ export async function POST(_: Request, { params }: { params: Promise<{ id: strin
     const errors: Error[] = [];
     for (const port of ports) {
         try {
-            const client = createOpencodeClient({ baseUrl: `http://localhost:${port}` });
-            await client.session.delete({ path: { id: sessionId } });
+            const client = createVibePulseOpencodeClient(`http://localhost:${port}`);
+            await deleteOpencodeSession(client, sessionId);
             clearSessionForceUnarchived(sessionId);
             clearSessionStickyStatusBlocked(sessionId);
             return Response.json({ success: true });
@@ -122,14 +157,14 @@ export async function POST(_: Request, { params }: { params: Promise<{ id: strin
     }
 
     const lastError = errors[errors.length - 1];
-    if (errors.length > 0 && errors.every((error) => /not found|404/i.test(error.message))) {
-        return createSessionNotFoundResponse(lastError?.message);
+    if (errors.length > 0 && errors.every((error) => /not found|404/i.test(formatOpencodeSdkError(error)))) {
+        return createSessionNotFoundResponse(lastError ? formatOpencodeSdkError(lastError) : undefined);
     }
 
     return Response.json(
         {
             error: 'Failed to delete session',
-            message: lastError?.message,
+            message: lastError ? formatOpencodeSdkError(lastError) : undefined,
             portsTried: ports.length,
         },
         { status: 500 }

package/.next/standalone/src/app/api/sessions/[id]/open-editor/route.test.ts

@@ -215,4 +215,78 @@ describe('/api/sessions/[id]/open-editor', () => {
     expect(response.status).toBe(400);
     expect(data).toEqual({ error: 'Invalid action session id', reason: 'invalid_action_session_id' });
   });
+
+  it('rejects unsupported Claude open-editor requests before remote 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/open-editor', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { 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: 'openEditor',
+    });
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects unsupported scoped Claude sidechain open-editor requests before remote 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}/open-editor`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { 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: 'openEditor',
+    });
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects local scoped Claude sidechain open-editor requests as unsupported capability', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+
+    const response = await POST(
+      new Request(`http://localhost/api/sessions/local:${scopedSessionId}/open-editor`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ tool: 'vscode' }),
+      }),
+      { params: Promise.resolve({ id: `local:${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: 'openEditor',
+    });
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+  });
 });

package/.next/standalone/src/app/api/sessions/[id]/open-editor/route.ts

@@ -1,6 +1,7 @@
-import { parseActionSessionReference } from '@/lib/hostIdentity';
+import { ActionSessionReference, parseActionSessionReference } from '@/lib/hostIdentity';
 import { listNodeRecords } from '@/lib/nodeRegistry';
 import { createNodeRequestHeaders } from '@/lib/nodeProtocol';
+import { detectProviderFromRawId, getDefaultProviderContext } from '@/lib/session-providers/providerIds';
 
 const REMOTE_NODE_ACTION_TIMEOUT_MS = 5_000;
 
@@ -18,16 +19,35 @@ function createSessionNotFoundResponse() {
   );
 }
 
+function createUnsupportedCapabilityResponse(capability: 'openEditor', sessionId: string) {
+  const provider = detectProviderFromRawId(sessionId);
+
+  return Response.json(
+    {
+      error: 'Session action not supported by provider',
+      reason: 'provider_capability_unsupported',
+      provider,
+      capability,
+    },
+    { status: 403 }
+  );
+}
+
 export async function POST(request: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;
 
-  let actionTarget;
+  let actionTarget: ActionSessionReference;
   try {
     actionTarget = parseActionSessionReference(id);
   } catch {
     return createInvalidActionSessionIdResponse();
   }
 
+  const provider = detectProviderFromRawId(actionTarget.sessionId);
+  if (!getDefaultProviderContext(provider).capabilities.openEditor) {
+    return createUnsupportedCapabilityResponse('openEditor', actionTarget.sessionId);
+  }
+
   if (!actionTarget.isRemote) {
     return createInvalidActionSessionIdResponse();
   }

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

@@ -0,0 +1,186 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('@/lib/opencodeDiscovery', () => ({
+  discoverOpencodePortsWithMeta: vi.fn(() => ({ ports: [], timedOut: false })),
+}));
+
+vi.mock('@/lib/nodeRegistry', () => ({
+  listNodeRecords: vi.fn(async () => []),
+}));
+
+vi.mock('@/lib/sessionArchiveOverrides', () => ({
+  markSessionForceUnarchived: vi.fn(),
+  clearSessionStickyStatusBlocked: vi.fn(),
+}));
+
+vi.mock('@/lib/claudeSessionOverrides', () => ({
+  clearClaudeSessionArchived: vi.fn(),
+}));
+
+import { POST } from './route';
+import { discoverOpencodePortsWithMeta } from '@/lib/opencodeDiscovery';
+import { listNodeRecords } from '@/lib/nodeRegistry';
+import { clearClaudeSessionArchived } from '@/lib/claudeSessionOverrides';
+import {
+  clearSessionStickyStatusBlocked,
+  markSessionForceUnarchived,
+} from '@/lib/sessionArchiveOverrides';
+
+const mockDiscoverOpencodePortsWithMeta: any = discoverOpencodePortsWithMeta;
+const mockListNodeRecords: any = listNodeRecords;
+const mockClearClaudeSessionArchived: any = clearClaudeSessionArchived;
+const mockMarkSessionForceUnarchived: any = markSessionForceUnarchived;
+const mockClearSessionStickyStatusBlocked: any = clearSessionStickyStatusBlocked;
+
+describe('/api/sessions/[id]/restore', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [], timedOut: false });
+    mockListNodeRecords.mockResolvedValue([]);
+  });
+
+  it('restores Claude sessions through local override storage', async () => {
+    const response = await POST(new Request('http://localhost/api/sessions/local:claude~550e8400-e29b-41d4-a716-446655440000/restore', { 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(mockMarkSessionForceUnarchived).toHaveBeenCalledWith('claude~550e8400-e29b-41d4-a716-446655440000');
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith('claude~550e8400-e29b-41d4-a716-446655440000');
+    expect(mockClearClaudeSessionArchived).toHaveBeenCalledWith('550e8400-e29b-41d4-a716-446655440000');
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+  });
+
+  it('restores scoped Claude sidechain sessions through local override storage', async () => {
+    const scopedSessionId = '550e8400-e29b-41d4-a716-446655440000__agent-a123';
+    const response = await POST(new Request(`http://localhost/api/sessions/local:${scopedSessionId}/restore`, { method: 'POST' }), {
+      params: Promise.resolve({ id: `local:${scopedSessionId}` }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockMarkSessionForceUnarchived).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockClearClaudeSessionArchived).toHaveBeenCalledWith(scopedSessionId);
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote Claude restore 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/restore', { 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(mockClearClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('rejects remote scoped Claude sidechain restore 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}/restore`, { 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(mockClearClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockListNodeRecords).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('forwards remote opencode restores to node archive DELETE endpoint', async () => {
+    mockListNodeRecords.mockResolvedValue([
+      {
+        nodeId: 'node-1',
+        nodeLabel: 'Node 1',
+        baseUrl: 'https://node-1.test',
+        enabled: true,
+        token: 'node-token',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ]);
+
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ success: true }), { status: 200 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/node-1:abc/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'node-1:abc' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockFetch).toHaveBeenCalledWith('https://node-1.test/api/node/sessions/abc/archive', expect.objectContaining({ method: 'DELETE' }));
+    expect(mockClearClaudeSessionArchived).not.toHaveBeenCalled();
+    expect(mockDiscoverOpencodePortsWithMeta).not.toHaveBeenCalled();
+  });
+
+  it('clears sticky blocked state when local opencode restore succeeds', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [3456], timedOut: false });
+    const mockFetch = vi.fn(async () => new Response(JSON.stringify({ ok: true }), { status: 200 }));
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:session-1/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:session-1' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(200);
+    expect(data).toEqual({ success: true });
+    expect(mockFetch).toHaveBeenCalledWith('http://localhost:3456/session/session-1', expect.objectContaining({ method: 'PATCH' }));
+    expect(mockMarkSessionForceUnarchived).toHaveBeenCalledWith('session-1');
+    expect(mockClearSessionStickyStatusBlocked).toHaveBeenCalledWith('session-1');
+  });
+
+  it('returns the latest non-404 upstream failure when restore attempts fail', async () => {
+    mockDiscoverOpencodePortsWithMeta.mockReturnValue({ ports: [3456, 3457], timedOut: false });
+    const mockFetch = vi.fn(async (input: RequestInfo | URL) => {
+      const url = String(input);
+      if (url.includes(':3456/')) {
+        return new Response('upstream boom', { status: 503 });
+      }
+      return new Response('not found', { status: 404 });
+    });
+    vi.stubGlobal('fetch', mockFetch);
+
+    const response = await POST(new Request('http://localhost/api/sessions/local:session-2/restore', { method: 'POST' }), {
+      params: Promise.resolve({ id: 'local:session-2' }),
+    });
+    const data = await response.json();
+
+    expect(response.status).toBe(503);
+    expect(data).toEqual(expect.objectContaining({
+      error: 'Failed to restore session',
+      reason: 'restore_request_failed',
+      message: 'upstream boom',
+    }));
+  });
+});