merge(main): resolve skills.test.js import conflict

Keep both discoverSkills from main and renameSkill from this branch.

Co-authored-by: Serhii Dziupin <makeittech@users.noreply.github.com>

packages/ui/src/lib/debug.ts

@@ -1,12 +1,19 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { useSessionUIStore } from '@/sync/session-ui-store';
+import { useSessionUIStore, getRememberedSessionDirectory } from '@/sync/session-ui-store';
 import { useDirectoryStore } from '@/stores/useDirectoryStore';
 import { useProjectsStore } from '@/stores/useProjectsStore';
 import { opencodeClient } from '@/lib/opencode/client';
 import { checkIsGitRepository } from '@/lib/gitApi';
 import { streamDebugEnabled } from '@/stores/utils/streamDebug';
 import { copyTextToClipboard as copyPlainTextToClipboard } from '@/lib/clipboard';
-import { getSyncSessions, getSyncMessages, getSyncParts } from '@/sync/sync-refs';
+import { getSyncSessions, getSyncMessages, getSyncParts, getAllSyncSessions, getSyncSessionDirectory } from '@/sync/sync-refs';
+import {
+  describeSessionDirectorySources,
+  resolveSessionDirectoryFromSources,
+} from '@/sync/session-directory-resolution';
+import { useSessionWorktreeStore } from '@/sync/session-worktree-store';
+import { getRecentSendFailures } from '@/sync/send-failure-log';
+import { getAttachedSessionDirectory } from '@/sync/session-worktree-contract';
 import { useStreamingStore } from '@/sync/streaming';
 import { runtimeFetch } from '@/lib/runtime-fetch';
 import { getRegisteredRuntimeAPIs } from '@/contexts/runtimeAPIRegistry';
@@ -375,12 +382,107 @@ export const debugUtils = {
       openchamber: {
         settingsInfo,
       },
+      // Empty is a meaningful answer here: it means no prompt was rejected in
+      // this session, so a "my message disappeared" report is not a rejected
+      // send and needs a different explanation.
+      recentSendFailures: getRecentSendFailures(),
+      currentSessionDirectoryResolution: sessionState.currentSessionId
+        ? this.diagnoseSessionDirectory(sessionState.currentSessionId)
+        : null,
     };
 
     console.log('[DEBUG] App status snapshot:', report);
     return report;
   },
 
+  /**
+   * Prompt sends that were rejected and rolled back in this app session.
+   * Newest first; empty means no send was rejected.
+   */
+  getRecentSendFailures() {
+    const failures = getRecentSendFailures();
+    if (failures.length === 0) {
+      console.log('[OK] No prompt sends were rejected in this session.');
+    } else {
+      console.warn(`[ALERT] ${failures.length} rejected prompt send(s):`);
+      console.table(failures);
+    }
+    return failures;
+  },
+
+  /**
+   * Report how a session's directory is resolved, from every source, in
+   * precedence order. A send is routed by the winning value, so a disagreement
+   * here explains a prompt that vanishes without an error: it was posted
+   * against a directory that does not own the session.
+   */
+  diagnoseSessionDirectory(sessionId?: string) {
+    const sessionState = useSessionUIStore.getState();
+    const targetSessionId = sessionId ?? sessionState.currentSessionId;
+
+    if (!targetSessionId) {
+      console.log('[ERROR] No session selected and no session id passed');
+      return null;
+    }
+
+    const attachment = getAttachedSessionDirectory(
+      useSessionWorktreeStore.getState().getAttachment(targetSessionId),
+    );
+    const worktreeMetadata = sessionState.worktreeMetadata.get(targetSessionId)?.path ?? null;
+    const owningStoreDirectory = getSyncSessionDirectory(targetSessionId);
+    const sessionRecord = getAllSyncSessions().find((session) => session.id === targetSessionId);
+    const recordDirectory = (sessionRecord as { directory?: string | null } | undefined)?.directory ?? null;
+    const selected = targetSessionId === sessionState.currentSessionId
+      ? sessionState.currentSessionDirectory
+      : null;
+
+    const remembered = getRememberedSessionDirectory(targetSessionId);
+
+    const sources = {
+      attachment,
+      worktreeMetadata,
+      authoritative: owningStoreDirectory ?? recordDirectory,
+      selected,
+      remembered: remembered.runtime,
+    };
+
+    const resolution = resolveSessionDirectoryFromSources(sources);
+    const routedDirectory = sessionState.getDirectoryForSession(targetSessionId);
+
+    const report = {
+      sessionId: targetSessionId,
+      isCurrentSession: targetSessionId === sessionState.currentSessionId,
+      routedDirectory,
+      resolvedFrom: resolution.source,
+      conflict: resolution.conflict,
+      sources: describeSessionDirectorySources(sources),
+      details: {
+        owningChildStore: owningStoreDirectory,
+        sessionRecordDirectory: recordDirectory,
+        sessionIndexed: Boolean(sessionRecord),
+        currentSessionDirectory: sessionState.currentSessionDirectory,
+        rememberedForRuntime: remembered.runtime,
+        persistedAcrossRestarts: remembered.persisted,
+        activeDirectory: useDirectoryStore.getState().currentDirectory ?? null,
+        opencodeClientDirectory: opencodeClient.getDirectory() ?? null,
+      },
+    };
+
+    console.log('[DEBUG] Session directory resolution:', report);
+    if (resolution.conflict) {
+      console.warn(
+        `[ALERT] Directory sources disagree: using "${resolution.directory}" (${resolution.source}) `
+        + `while "${resolution.conflict.directory}" came from ${resolution.conflict.source}.`,
+      );
+    } else if (!routedDirectory) {
+      console.warn('[ALERT] No directory resolved for this session — sends fall back to the active directory.');
+    } else {
+      console.log('[OK] All known sources agree on the session directory.');
+    }
+
+    return report;
+  },
+
   async buildDiagnosticsReport() {
     const report = await this.getAppStatus();
     return JSON.stringify(report, null, 2);
@@ -697,6 +799,8 @@ if (typeof window !== 'undefined') {
     console.log('  __opencodeDebug.getAllMessages(truncate?) - List all messages (truncate=true for short preview)');
     console.log('  __opencodeDebug.truncateMessages(messages) - Truncate long fields in messages array');
     console.log('  __opencodeDebug.getAppStatus() - Show app status snapshot');
+    console.log('  __opencodeDebug.diagnoseSessionDirectory(sessionId?) - Show how the session directory is resolved');
+    console.log('  __opencodeDebug.getRecentSendFailures() - List prompt sends that were rejected and rolled back');
     console.log('  __opencodeDebug.checkLastMessage() - Check if last message is problematic');
     console.log('  __opencodeDebug.findEmptyMessages() - Find all empty assistant messages');
     console.log('  __opencodeDebug.showRetryHelp() - Show instructions for handling empty responses');

packages/ui/src/lib/terminalApi.test.ts

@@ -93,6 +93,157 @@ describe('terminal transport', () => {
     transport.dispose();
   });
 
+  test('invalidates URL auth when the current socket closes before opening', async () => {
+    const socket = new FakeSocket();
+    let cleared = 0;
+    const transport = new TerminalTransport({
+      refreshAuth: async () => '',
+      openSocket: () => socket,
+      clearUrlAuthToken: () => { cleared += 1; },
+    });
+
+    const unsubscribe = transport.subscribe('term-1', { onEvent: () => {} });
+    await tick();
+    socket.close();
+    await tick();
+
+    expect(cleared).toBe(1);
+    unsubscribe();
+    transport.dispose();
+  });
+
+  test('invalidates URL auth before retrying a pre-open socket error', async () => {
+    const socket = new FakeSocket();
+    let cleared = 0;
+    const transport = new TerminalTransport({
+      refreshAuth: async () => '',
+      openSocket: () => socket,
+      clearUrlAuthToken: () => { cleared += 1; },
+    });
+
+    const unsubscribe = transport.subscribe('term-1', { onEvent: () => {} });
+    await tick();
+    socket.onerror?.();
+
+    expect(cleared).toBe(1);
+    unsubscribe();
+    transport.dispose();
+  });
+
+  test('does not let a cancelled opening reconnect a replacement subscription', async () => {
+    const sockets = [new FakeSocket(), new FakeSocket()];
+    let socketIndex = 0;
+    const replacementEvents: string[] = [];
+    const transport = new TerminalTransport({
+      refreshAuth: async () => '',
+      openSocket: () => sockets[socketIndex++]!,
+    });
+
+    const unsubscribeFirst = transport.subscribe('term-1', { onEvent: () => {} });
+    await tick();
+    unsubscribeFirst();
+
+    const unsubscribeReplacement = transport.subscribe('term-1', {
+      onEvent: (event) => replacementEvents.push(event.type),
+    });
+    await tick();
+    sockets[1]?.open();
+    await tick();
+
+    expect(replacementEvents).not.toContain('reconnecting');
+    unsubscribeReplacement();
+    transport.dispose();
+  });
+
+  test('starts a fresh reconnect sequence after every terminal has detached', async () => {
+    const firstEvents: number[] = [];
+    const replacementEvents: number[] = [];
+    const transport = new TerminalTransport({
+      refreshAuth: async () => '',
+      openSocket: () => { throw new Error('offline'); },
+    });
+
+    const unsubscribeFirst = transport.subscribe('term-1', {
+      onEvent: (event) => {
+        if (event.type === 'reconnecting' && typeof event.attempt === 'number') firstEvents.push(event.attempt);
+      },
+    });
+    await tick();
+    await tick();
+    expect(firstEvents).toEqual([1]);
+
+    unsubscribeFirst();
+    const unsubscribeReplacement = transport.subscribe('term-2', {
+      onEvent: (event) => {
+        if (event.type === 'reconnecting' && typeof event.attempt === 'number') replacementEvents.push(event.attempt);
+      },
+    });
+    await tick();
+    await tick();
+
+    expect(replacementEvents).toEqual([1]);
+    unsubscribeReplacement();
+    transport.dispose();
+  });
+
+  test('waits a minute before reconnecting while hidden', async () => {
+    const originalSetTimeout = globalThis.setTimeout;
+    const originalDocument = Object.getOwnPropertyDescriptor(globalThis, 'document');
+    const delays: number[] = [];
+    let transport: TerminalTransport | null = null;
+
+    Object.defineProperty(globalThis, 'document', {
+      configurable: true,
+      value: {
+        visibilityState: 'hidden',
+        addEventListener: () => {},
+        removeEventListener: () => {},
+      },
+    });
+    globalThis.setTimeout = ((handler: TimerHandler, timeout?: number, ...args: unknown[]) => {
+      delays.push(Number(timeout ?? 0));
+      if (timeout === 0) return originalSetTimeout(handler, 0, ...args);
+      return 0 as unknown as ReturnType<typeof setTimeout>;
+    }) as typeof setTimeout;
+
+    try {
+      transport = new TerminalTransport({
+        refreshAuth: async () => '',
+        openSocket: () => { throw new Error('offline'); },
+      });
+      transport.subscribe('term-1', { onEvent: () => {} });
+      await tick();
+      await tick();
+
+      expect(delays).toContain(60_000);
+    } finally {
+      transport?.dispose();
+      globalThis.setTimeout = originalSetTimeout;
+      if (originalDocument) Object.defineProperty(globalThis, 'document', originalDocument);
+      else delete (globalThis as { document?: unknown }).document;
+    }
+  });
+
+  test('attaches a remaining same-terminal subscriber after the first one leaves', async () => {
+    const socket = new FakeSocket();
+    const transport = new TerminalTransport({ refreshAuth: async () => '', openSocket: () => socket });
+
+    const unsubscribeOther = transport.subscribe('term-other', { onEvent: () => {} });
+    await tick();
+    socket.open();
+    await tick();
+
+    const unsubscribeFirst = transport.subscribe('term-1', { onEvent: () => {} });
+    const unsubscribeRemaining = transport.subscribe('term-1', { onEvent: () => {} });
+    unsubscribeFirst();
+    await tick();
+
+    expect(socket.sent.filter((message) => message.t === 'attach' && message.s === 'term-1')).toHaveLength(1);
+    unsubscribeRemaining();
+    unsubscribeOther();
+    transport.dispose();
+  });
+
   test('releases replay projections when the last subscriber detaches', async () => {
     const socket = new FakeSocket();
     const transport = new TerminalTransport({ refreshAuth: async () => '', openSocket: () => socket });

packages/ui/src/lib/terminalApi.ts

@@ -3,7 +3,7 @@ import { openRuntimeWebSocket } from './relay/runtime-socket';
 import type { RelayTunnelWebSocket } from './relay/tunnel-client';
 import { runtimeFetch } from './runtime-fetch';
 import { getRuntimeUrlResolver } from './runtime-url';
-import { refreshRuntimeUrlAuthToken } from './runtime-auth';
+import { clearRuntimeUrlAuthToken, refreshRuntimeUrlAuthToken } from './runtime-auth';
 import { isTerminalShell } from './terminalShell';
 
 type Message = Record<string, unknown> & { t: string; s?: string; q?: number };
@@ -66,12 +66,12 @@ const trimProjection = (value: string): string => {
 type TerminalTransportDependencies = {
   refreshAuth: () => Promise<unknown>;
   openSocket: () => RelayTunnelWebSocket;
+  clearUrlAuthToken?: () => void;
 };
 
 export class TerminalTransport {
   private socket: RelayTunnelWebSocket | null = null;
   private opening: Promise<void> | null = null;
-  private openingGeneration: number | null = null;
   private subscribers = new Map<string, Set<Subscriber>>();
   private projections = new Map<string, TerminalProjection>();
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
@@ -85,6 +85,7 @@ export class TerminalTransport {
   constructor(private readonly dependencies: TerminalTransportDependencies = {
     refreshAuth: refreshRuntimeUrlAuthToken,
     openSocket: () => openRuntimeWebSocket(getRuntimeUrlResolver().websocket('/api/terminal/ws')),
+    clearUrlAuthToken: clearRuntimeUrlAuthToken,
   }) {}
 
   subscribe(sessionId: string, handlers: TerminalHandlers): () => void {
@@ -100,7 +101,13 @@ export class TerminalTransport {
       handlers.onEvent({ type: 'snapshot', sequence: projection.sequence, data: projection.history, status: projection.status, exitCode: projection.exitCode, signal: projection.signal, runtime: projection.runtime, ptyBackend: projection.ptyBackend });
     }
     const socketWasOpen = this.socket?.readyState === SOCKET_OPEN;
-    this.ensureConnected().then(() => { if (first && socketWasOpen && set.has(subscriber)) this.send({ t: 'attach', v: 3, s: sessionId }); }).catch((error) => {
+    this.ensureConnected().then(() => {
+      const current = this.subscribers.get(sessionId);
+      if (first && socketWasOpen && current === set && current.size > 0) {
+        this.send({ t: 'attach', v: 3, s: sessionId });
+      }
+    }).catch((error) => {
+      if (!set.has(subscriber)) return;
       handlers.onError?.(error, false);
       this.scheduleReconnect();
     });
@@ -114,6 +121,7 @@ export class TerminalTransport {
       }
       if (this.subscribers.size === 0) {
         this.cancelReconnect();
+        this.failures = 0;
         if (this.socket?.readyState === SOCKET_OPEN) {
           // Healthy socket: hold it briefly so a tab switch can reattach to it.
           this.scheduleIdleClose();
@@ -121,6 +129,7 @@ export class TerminalTransport {
         }
         // Nothing to reuse, so abandon any dial that is still in flight.
         this.generation += 1;
+        this.opening = null;
         this.closeSocket();
       }
     };
@@ -138,6 +147,7 @@ export class TerminalTransport {
   dispose(): void {
     this.disposed = true;
     this.generation += 1;
+    this.opening = null;
     this.subscribers.clear();
     this.projections.clear();
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
@@ -155,71 +165,89 @@ export class TerminalTransport {
   private async ensureConnected(): Promise<void> {
     if (this.disposed) throw new Error('Terminal runtime changed');
     if (this.socket?.readyState === SOCKET_OPEN) return;
-    if (this.opening && this.openingGeneration === this.generation) {
+    if (this.opening) {
       await this.opening;
       if (this.socket?.readyState === SOCKET_OPEN) return;
       return this.ensureConnected();
     }
-    if (this.openingGeneration !== this.generation) {
-      this.opening = null;
-      this.openingGeneration = null;
-    }
     const generation = this.generation;
     const opening = (async () => {
       await this.dependencies.refreshAuth();
       if (generation !== this.generation || this.disposed) throw new Error('Terminal runtime changed');
       await new Promise<void>((resolve, reject) => {
-      let settled = false;
-      let pendingSocket: RelayTunnelWebSocket | null = null;
-      const finish = (error?: Error) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timeout);
-        if (error) reject(error);
-        else resolve();
-      };
-      const timeout = setTimeout(() => {
-        pendingSocket?.close();
-        finish(new Error('Terminal connection timed out'));
-      }, 10_000);
-      try {
-        const socket = this.dependencies.openSocket();
-        pendingSocket = socket;
-        socket.binaryType = 'arraybuffer';
-        this.socket = socket;
-        socket.onopen = () => {
-          if (generation !== this.generation || this.disposed) { socket.close(); finish(new Error('Terminal runtime changed')); return; }
-          this.failures = 0;
-          this.send({ t: 'hello', v: 3 });
-          for (const sessionId of this.subscribers.keys()) this.send({ t: 'attach', v: 3, s: sessionId });
-          this.startKeepalive();
-          finish();
+        let settled = false;
+        let opened = false;
+        let authInvalidated = false;
+        let pendingSocket: RelayTunnelWebSocket | null = null;
+        const isCurrentSocket = () => (
+          generation === this.generation &&
+          !this.disposed &&
+          pendingSocket !== null &&
+          this.socket === pendingSocket
+        );
+        const invalidatePreOpenAuth = () => {
+          if (authInvalidated || opened || !isCurrentSocket()) return;
+          authInvalidated = true;
+          this.dependencies.clearUrlAuthToken?.();
         };
-        socket.onmessage = (event) => void this.handleMessage(event.data);
-        socket.onerror = () => {
-          finish(new Error('Terminal WebSocket failed'));
+        const finish = (error?: Error) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeout);
+          if (error) reject(error);
+          else resolve();
+        };
+        const timeout = setTimeout(() => {
+          invalidatePreOpenAuth();
+          pendingSocket?.close();
+          finish(new Error('Terminal connection timed out'));
+        }, 10_000);
+        try {
+          const socket = this.dependencies.openSocket();
+          pendingSocket = socket;
+          socket.binaryType = 'arraybuffer';
+          this.socket = socket;
+          socket.onopen = () => {
+            if (!isCurrentSocket()) { socket.close(); finish(new Error('Terminal runtime changed')); return; }
+            opened = true;
+            this.failures = 0;
+            this.send({ t: 'hello', v: 3 });
+            for (const sessionId of this.subscribers.keys()) this.send({ t: 'attach', v: 3, s: sessionId });
+            this.startKeepalive();
+            finish();
+          };
+          socket.onmessage = (event) => void this.handleMessage(event.data);
+          socket.onerror = () => {
+            const current = isCurrentSocket();
+            if (current) invalidatePreOpenAuth();
+            finish(new Error('Terminal WebSocket failed'));
+            if (current && this.subscribers.size > 0) this.scheduleReconnect();
+          };
+          socket.onclose = () => {
+            const current = isCurrentSocket();
+            if (current) {
+              this.stopKeepalive();
+              // An upgrade rejected before `open` commonly means the cached
+              // URL-scoped auth token is stale. Retrying it reaches the 8s
+              // backoff cap instead of minting a fresh token.
+              invalidatePreOpenAuth();
+            }
+            if (this.socket === socket) this.socket = null;
+            finish(new Error('Terminal WebSocket closed'));
+            if (current && this.subscribers.size > 0) this.scheduleReconnect();
+          };
+        } catch (error) {
+          finish(error instanceof Error ? error : new Error('Terminal WebSocket failed'));
           if (!this.disposed && this.subscribers.size > 0) this.scheduleReconnect();
-        };
-        socket.onclose = () => {
-          if (this.socket === socket) this.socket = null;
-          this.stopKeepalive();
-          finish(new Error('Terminal WebSocket closed'));
-          if (!this.disposed && this.subscribers.size > 0) this.scheduleReconnect();
-        };
-      } catch (error) {
-        finish(error instanceof Error ? error : new Error('Terminal WebSocket failed'));
-        if (!this.disposed && this.subscribers.size > 0) this.scheduleReconnect();
-      }
+        }
       });
     })();
     this.opening = opening;
-    this.openingGeneration = generation;
     try {
       await opening;
     } finally {
       if (this.opening === opening) {
         this.opening = null;
-        this.openingGeneration = null;
       }
     }
   }
@@ -279,7 +307,7 @@ export class TerminalTransport {
     if (this.reconnectTimer || this.disposed || this.subscribers.size === 0) return;
     this.failures += 1;
     const slow = (typeof document !== 'undefined' && document.visibilityState === 'hidden') || (typeof navigator !== 'undefined' && !navigator.onLine);
-    const delay = Math.min(500 * 2 ** Math.min(this.failures - 1, 10), slow ? 60_000 : 8_000);
+    const delay = slow ? 60_000 : Math.min(500 * 2 ** Math.min(this.failures - 1, 10), 8_000);
     for (const set of this.subscribers.values()) for (const sub of set) sub.handlers.onEvent({ type: 'reconnecting', attempt: this.failures, maxAttempts: Number.POSITIVE_INFINITY });
     const wake = () => {
       if (typeof document !== 'undefined' && document.visibilityState === 'hidden') return;
@@ -304,6 +332,7 @@ export class TerminalTransport {
       this.idleCloseTimer = null;
       if (this.disposed || this.subscribers.size > 0) return;
       this.generation += 1;
+      this.opening = null;
       this.closeSocket();
     }, IDLE_SOCKET_GRACE_MS);
   }