@mmmbuto/nexuscli 0.5.9 → 0.6.1

package/lib/server/routes/chat.js

@@ -71,27 +71,39 @@ router.post('/', async (req, res) => {
     // Send initial event
     res.write(`data: ${JSON.stringify({ type: 'message_start', messageId: `user-${Date.now()}`, sessionId })}\n\n`);
 
-    // Use optimized ContextBridge for token-aware context building
+    // Check if this is an engine switch (requires context bridging)
     const lastEngine = Message.getLastEngine(sessionId);
-    const contextResult = await contextBridge.buildContext({
-      sessionId,
-      fromEngine: lastEngine,
-      toEngine: 'claude',
-      userMessage: message
-    });
+    const isEngineBridge = lastEngine && lastEngine !== 'claude';
 
-    const promptWithContext = contextResult.prompt;
-    const isEngineBridge = contextResult.isEngineBridge;
+    // IMPORTANT: Skip contextBridge for Claude native resume!
+    // When Claude uses `-r sessionId`, it loads full history from .jsonl file.
+    // ContextBridge is ONLY needed for:
+    // 1. Engine switches (e.g., Codex → Claude)
+    // 2. New sessions without history
+    let promptToSend = message;
 
-    console.log(`[Chat] Context: ${contextResult.contextTokens} tokens from ${contextResult.contextSource}, total: ${contextResult.totalTokens}`);
-
-    // Notify frontend about engine switch
     if (isEngineBridge) {
+      // Engine switch: need context from previous engine
+      const contextResult = await contextBridge.buildContext({
+        sessionId,
+        fromEngine: lastEngine,
+        toEngine: 'claude',
+        userMessage: message
+      });
+      promptToSend = contextResult.prompt;
+      console.log(`[Chat] Engine bridge: ${contextResult.contextTokens} tokens from ${lastEngine}`);
+
       res.write(`data: ${JSON.stringify({
         type: 'status',
         category: 'engine_switch',
         message: `Continuing conversation from ${lastEngine}`
       })}\n\n`);
+    } else if (!isNewSession) {
+      // Native resume: Claude will load history from session file
+      console.log(`[Chat] Native resume: Claude will use -r ${sessionId} (full history in .jsonl)`);
+    } else {
+      // New session: no context needed
+      console.log(`[Chat] New session: starting fresh`);
     }
 
     try {
@@ -113,7 +125,7 @@ router.post('/', async (req, res) => {
 
       // Call Claude Code wrapper with workspace path for --cwd
       const result = await claudeWrapper.sendMessage({
-        prompt: promptWithContext,
+        prompt: promptToSend,
         conversationId: sessionId,
         model,
         workspacePath,  // Pass workspace for Claude CLI --cwd

package/lib/server/routes/codex.js

@@ -82,28 +82,37 @@ router.post('/', async (req, res) => {
     // Send initial event
     res.write(`data: ${JSON.stringify({ type: 'message_start', messageId: `user-${Date.now()}`, sessionId })}\n\n`);
 
-    // Use optimized ContextBridge for token-aware context building
-    // Note: Codex uses codeOnly mode for better code-focused context
+    // Check if this is an engine switch (requires context bridging)
     const lastEngine = Message.getLastEngine(sessionId);
-    const contextResult = await contextBridge.buildContext({
-      sessionId,
-      fromEngine: lastEngine,
-      toEngine: 'codex',
-      userMessage: message
-    });
-
-    const promptWithContext = contextResult.prompt;
-    const isEngineBridge = contextResult.isEngineBridge;
+    const isEngineBridge = lastEngine && lastEngine !== 'codex';
 
-    console.log(`[Codex] Context: ${contextResult.contextTokens} tokens from ${contextResult.contextSource}, total: ${contextResult.totalTokens}`);
+    // IMPORTANT: Skip contextBridge for Codex native resume!
+    // When Codex uses `exec resume <threadId>`, it loads full history from native thread.
+    // ContextBridge is ONLY needed for engine switches.
+    let promptToSend = message;
 
-    // Notify frontend about engine switch
     if (isEngineBridge) {
+      // Engine switch: need context from previous engine
+      const contextResult = await contextBridge.buildContext({
+        sessionId,
+        fromEngine: lastEngine,
+        toEngine: 'codex',
+        userMessage: message
+      });
+      promptToSend = contextResult.prompt;
+      console.log(`[Codex] Engine bridge: ${contextResult.contextTokens} tokens from ${lastEngine}`);
+
       res.write(`data: ${JSON.stringify({
         type: 'status',
         category: 'engine_switch',
         message: `Continuing conversation from ${lastEngine}`
       })}\n\n`);
+    } else if (nativeThreadId) {
+      // Native resume: Codex will load history from thread
+      console.log(`[Codex] Native resume: Codex will use threadId ${nativeThreadId}`);
+    } else {
+      // New session: no context needed
+      console.log(`[Codex] New session: starting fresh`);
     }
 
     try {
@@ -124,7 +133,7 @@ router.post('/', async (req, res) => {
 
       // Call Codex wrapper with native threadId for session resume
       const result = await codexWrapper.sendMessage({
-        prompt: nativeThreadId ? message : promptWithContext, // Use raw message if resuming native session
+        prompt: promptToSend,
         model,
         threadId: nativeThreadId, // Native Codex thread ID for resume
         reasoningEffort,

package/lib/server/routes/gemini.js

@@ -90,29 +90,38 @@ router.post('/', async (req, res) => {
       engine: 'gemini'
     })}\n\n`);
 
-    // Use optimized ContextBridge for token-aware context building
-    // Note: Gemini has larger context window, uses preferSummary: false config
+    // Check if this is an engine switch (requires context bridging)
     const lastEngine = Message.getLastEngine(sessionId);
-    const contextResult = await contextBridge.buildContext({
-      sessionId,
-      fromEngine: lastEngine,
-      toEngine: 'gemini',
-      userMessage: message
-    });
+    const isEngineBridge = lastEngine && lastEngine !== 'gemini';
 
-    const promptWithContext = contextResult.prompt;
-    const isEngineBridge = contextResult.isEngineBridge;
+    // IMPORTANT: Skip contextBridge for Gemini native resume!
+    // When Gemini uses `--resume <sessionId>`, it loads full history from native session.
+    // ContextBridge is ONLY needed for engine switches.
+    let promptToSend = message;
 
-    console.log(`[Gemini] Context: ${contextResult.contextTokens} tokens from ${contextResult.contextSource}, total: ${contextResult.totalTokens}`);
-
-    // Notify frontend about engine switch
     if (isEngineBridge) {
+      // Engine switch: need context from previous engine
+      const contextResult = await contextBridge.buildContext({
+        sessionId,
+        fromEngine: lastEngine,
+        toEngine: 'gemini',
+        userMessage: message
+      });
+      promptToSend = contextResult.prompt;
+      console.log(`[Gemini] Engine bridge: ${contextResult.contextTokens} tokens from ${lastEngine}`);
+
       res.write(`data: ${JSON.stringify({
         type: 'status',
         category: 'system',
         message: `Context bridged from ${lastEngine}`,
         icon: '🔄'
       })}\n\n`);
+    } else if (nativeSessionId) {
+      // Native resume: Gemini will load history from session
+      console.log(`[Gemini] Native resume: Gemini will use --resume ${nativeSessionId}`);
+    } else {
+      // New session: no context needed
+      console.log(`[Gemini] New session: starting fresh`);
     }
 
     // Save user message to DB
@@ -139,7 +148,7 @@ router.post('/', async (req, res) => {
 
     // Call Gemini wrapper with native sessionId for session resume
     const result = await geminiWrapper.sendMessage({
-      prompt: nativeSessionId ? message : promptWithContext, // Use raw message if resuming native session
+      prompt: promptToSend,
       threadId: nativeSessionId, // Native Gemini session ID for resume
       model,
       workspacePath,

package/lib/server/services/session-manager.js

@@ -58,6 +58,26 @@ class SessionManager {
       return true; // Always trust DB for exec-mode CLI sessions
     }
 
+    // For Claude: search ALL project folders (session might be in different workspace)
+    if (normalizedEngine === 'claude') {
+      try {
+        const projectsDir = SESSION_DIRS.claude;
+        if (fs.existsSync(projectsDir)) {
+          const dirs = fs.readdirSync(projectsDir);
+          for (const dir of dirs) {
+            const sessionFile = path.join(projectsDir, dir, `${sessionId}.jsonl`);
+            if (fs.existsSync(sessionFile)) {
+              console.log(`[SessionManager] Claude session found: ${sessionFile}`);
+              return true;
+            }
+          }
+        }
+      } catch (err) {
+        console.warn(`[SessionManager] Claude session lookup failed:`, err.message);
+      }
+      return false;
+    }
+
     try {
       const sessionPath = this.getSessionFilePath(sessionId, engine, workspacePath);
       if (!sessionPath) return false;
@@ -165,12 +185,13 @@ class SessionManager {
     }
 
     // 2. Check DB for existing session mapping
+    // Note: Frontend may send sessionId as conversationId, so check both columns
     try {
       const stmt = prepare(`
         SELECT id, workspace_path FROM sessions
-        WHERE conversation_id = ? AND engine = ?
+        WHERE (conversation_id = ? OR id = ?) AND engine = ?
       `);
-      const row = stmt.get(conversationId, normalizedEngine);
+      const row = stmt.get(conversationId, conversationId, normalizedEngine);
 
       if (row) {
         // 3. Verify session file exists on filesystem

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.5.9",
+  "version": "0.6.1",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini)",
   "main": "lib/server/server.js",
   "bin": {