zenflo 0.11.6 → 0.11.7

package/dist/{types-DjiA-t1_.mjs → types-DJhJK2jD.mjs}

@@ -21,7 +21,7 @@ import { platform } from 'os';
 import { Expo } from 'expo-server-sdk';
 
 var name = "zenflo";
-var version = "0.11.6";
+var version = "0.11.7";
 var description = "Mobile and Web client for Claude Code and Codex - ZenFlo edition";
 var author = "Combined Memory";
 var license = "MIT";
@@ -172,7 +172,7 @@ class Configuration {
   webappUrl;
   isDaemonProcess;
   // Directories and paths (from persistence)
-  happyHomeDir;
+  zenfloHomeDir;
   logsDir;
   settingsFile;
   privateKeyFile;
@@ -188,20 +188,20 @@ class Configuration {
     this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
     if (process.env.ZENFLO_HOME_DIR) {
       const expandedPath = process.env.ZENFLO_HOME_DIR.replace(/^~/, homedir());
-      this.happyHomeDir = expandedPath;
+      this.zenfloHomeDir = expandedPath;
     } else {
-      this.happyHomeDir = join(homedir(), ".happy");
+      this.zenfloHomeDir = join(homedir(), ".zenflo");
     }
-    this.logsDir = join(this.happyHomeDir, "logs");
-    this.settingsFile = join(this.happyHomeDir, "settings.json");
-    this.privateKeyFile = join(this.happyHomeDir, "access.key");
-    this.daemonStateFile = join(this.happyHomeDir, "daemon.state.json");
-    this.daemonLockFile = join(this.happyHomeDir, "daemon.state.json.lock");
-    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
-    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.HAPPY_DISABLE_CAFFEINATE?.toLowerCase() || "");
+    this.logsDir = join(this.zenfloHomeDir, "logs");
+    this.settingsFile = join(this.zenfloHomeDir, "settings.json");
+    this.privateKeyFile = join(this.zenfloHomeDir, "access.key");
+    this.daemonStateFile = join(this.zenfloHomeDir, "daemon.state.json");
+    this.daemonLockFile = join(this.zenfloHomeDir, "daemon.state.json.lock");
+    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.ZENFLO_EXPERIMENTAL?.toLowerCase() || "");
+    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.ZENFLO_DISABLE_CAFFEINATE?.toLowerCase() || "");
     this.currentCliVersion = packageJson.version;
-    if (!existsSync(this.happyHomeDir)) {
-      mkdirSync(this.happyHomeDir, { recursive: true });
+    if (!existsSync(this.zenfloHomeDir)) {
+      mkdirSync(this.zenfloHomeDir, { recursive: true });
     }
     if (!existsSync(this.logsDir)) {
       mkdirSync(this.logsDir, { recursive: true });
@@ -361,8 +361,8 @@ async function updateSettings(updater) {
   try {
     const current = await readSettings() || { ...defaultSettings };
     const updated = await updater(current);
-    if (!existsSync(configuration.happyHomeDir)) {
-      await mkdir(configuration.happyHomeDir, { recursive: true });
+    if (!existsSync(configuration.zenfloHomeDir)) {
+      await mkdir(configuration.zenfloHomeDir, { recursive: true });
     }
     await writeFile(tmpFile, JSON.stringify(updated, null, 2));
     await rename(tmpFile, configuration.settingsFile);
@@ -413,8 +413,8 @@ async function readCredentials() {
   return null;
 }
 async function writeCredentialsLegacy(credentials) {
-  if (!existsSync(configuration.happyHomeDir)) {
-    await mkdir(configuration.happyHomeDir, { recursive: true });
+  if (!existsSync(configuration.zenfloHomeDir)) {
+    await mkdir(configuration.zenfloHomeDir, { recursive: true });
   }
   await writeFile(configuration.privateKeyFile, JSON.stringify({
     secret: encodeBase64(credentials.secret),
@@ -422,8 +422,8 @@ async function writeCredentialsLegacy(credentials) {
   }, null, 2));
 }
 async function writeCredentialsDataKey(credentials) {
-  if (!existsSync(configuration.happyHomeDir)) {
-    await mkdir(configuration.happyHomeDir, { recursive: true });
+  if (!existsSync(configuration.zenfloHomeDir)) {
+    await mkdir(configuration.zenfloHomeDir, { recursive: true });
   }
   await writeFile(configuration.privateKeyFile, JSON.stringify({
     encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
@@ -767,10 +767,10 @@ z$1.object({
 z$1.object({
   host: z$1.string(),
   platform: z$1.string(),
-  happyCliVersion: z$1.string(),
+  zenfloCliVersion: z$1.string(),
   homeDir: z$1.string(),
-  happyHomeDir: z$1.string(),
-  happyLibDir: z$1.string()
+  zenfloHomeDir: z$1.string(),
+  zenfloLibDir: z$1.string()
 });
 z$1.object({
   status: z$1.union([
@@ -1442,9 +1442,11 @@ class ApiSessionClient extends EventEmitter {
     }
     logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const localId = typeof body.uuid === "string" ? body.uuid : null;
     this.socket.emit("message", {
       sid: this.sessionId,
-      message: encrypted
+      message: encrypted,
+      localId
     });
     if (body.type === "assistant" && body.message.usage) {
       try {
@@ -2169,6 +2171,14 @@ const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
     type: z$1.literal("system"),
     uuid: z$1.string()
     // Used in getMessageKey()
+  }).passthrough(),
+  // Queue operation - internal Claude Code message for managing task queue
+  // These are not sent to backend, just need to be parseable
+  z$1.object({
+    type: z$1.literal("queue-operation"),
+    operation: z$1.enum(["enqueue", "dequeue"]),
+    timestamp: z$1.string(),
+    sessionId: z$1.string()
   }).passthrough()
 ]);
 

package/dist/{types-CJaqq466.cjs → types-Dvhor4zW.cjs}

@@ -42,7 +42,7 @@ function _interopNamespaceDefault(e) {
 var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 var name = "zenflo";
-var version = "0.11.6";
+var version = "0.11.7";
 var description = "Mobile and Web client for Claude Code and Codex - ZenFlo edition";
 var author = "Combined Memory";
 var license = "MIT";
@@ -193,7 +193,7 @@ class Configuration {
   webappUrl;
   isDaemonProcess;
   // Directories and paths (from persistence)
-  happyHomeDir;
+  zenfloHomeDir;
   logsDir;
   settingsFile;
   privateKeyFile;
@@ -209,20 +209,20 @@ class Configuration {
     this.isDaemonProcess = args.length >= 2 && args[0] === "daemon" && args[1] === "start-sync";
     if (process.env.ZENFLO_HOME_DIR) {
       const expandedPath = process.env.ZENFLO_HOME_DIR.replace(/^~/, os.homedir());
-      this.happyHomeDir = expandedPath;
+      this.zenfloHomeDir = expandedPath;
     } else {
-      this.happyHomeDir = node_path.join(os.homedir(), ".happy");
+      this.zenfloHomeDir = node_path.join(os.homedir(), ".zenflo");
     }
-    this.logsDir = node_path.join(this.happyHomeDir, "logs");
-    this.settingsFile = node_path.join(this.happyHomeDir, "settings.json");
-    this.privateKeyFile = node_path.join(this.happyHomeDir, "access.key");
-    this.daemonStateFile = node_path.join(this.happyHomeDir, "daemon.state.json");
-    this.daemonLockFile = node_path.join(this.happyHomeDir, "daemon.state.json.lock");
-    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.HAPPY_EXPERIMENTAL?.toLowerCase() || "");
-    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.HAPPY_DISABLE_CAFFEINATE?.toLowerCase() || "");
+    this.logsDir = node_path.join(this.zenfloHomeDir, "logs");
+    this.settingsFile = node_path.join(this.zenfloHomeDir, "settings.json");
+    this.privateKeyFile = node_path.join(this.zenfloHomeDir, "access.key");
+    this.daemonStateFile = node_path.join(this.zenfloHomeDir, "daemon.state.json");
+    this.daemonLockFile = node_path.join(this.zenfloHomeDir, "daemon.state.json.lock");
+    this.isExperimentalEnabled = ["true", "1", "yes"].includes(process.env.ZENFLO_EXPERIMENTAL?.toLowerCase() || "");
+    this.disableCaffeinate = ["true", "1", "yes"].includes(process.env.ZENFLO_DISABLE_CAFFEINATE?.toLowerCase() || "");
     this.currentCliVersion = packageJson.version;
-    if (!fs.existsSync(this.happyHomeDir)) {
-      fs.mkdirSync(this.happyHomeDir, { recursive: true });
+    if (!fs.existsSync(this.zenfloHomeDir)) {
+      fs.mkdirSync(this.zenfloHomeDir, { recursive: true });
     }
     if (!fs.existsSync(this.logsDir)) {
       fs.mkdirSync(this.logsDir, { recursive: true });
@@ -382,8 +382,8 @@ async function updateSettings(updater) {
   try {
     const current = await readSettings() || { ...defaultSettings };
     const updated = await updater(current);
-    if (!fs.existsSync(configuration.happyHomeDir)) {
-      await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+    if (!fs.existsSync(configuration.zenfloHomeDir)) {
+      await promises.mkdir(configuration.zenfloHomeDir, { recursive: true });
     }
     await promises.writeFile(tmpFile, JSON.stringify(updated, null, 2));
     await promises.rename(tmpFile, configuration.settingsFile);
@@ -434,8 +434,8 @@ async function readCredentials() {
   return null;
 }
 async function writeCredentialsLegacy(credentials) {
-  if (!fs.existsSync(configuration.happyHomeDir)) {
-    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+  if (!fs.existsSync(configuration.zenfloHomeDir)) {
+    await promises.mkdir(configuration.zenfloHomeDir, { recursive: true });
   }
   await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
     secret: encodeBase64(credentials.secret),
@@ -443,8 +443,8 @@ async function writeCredentialsLegacy(credentials) {
   }, null, 2));
 }
 async function writeCredentialsDataKey(credentials) {
-  if (!fs.existsSync(configuration.happyHomeDir)) {
-    await promises.mkdir(configuration.happyHomeDir, { recursive: true });
+  if (!fs.existsSync(configuration.zenfloHomeDir)) {
+    await promises.mkdir(configuration.zenfloHomeDir, { recursive: true });
   }
   await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
     encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
@@ -788,10 +788,10 @@ z.z.object({
 z.z.object({
   host: z.z.string(),
   platform: z.z.string(),
-  happyCliVersion: z.z.string(),
+  zenfloCliVersion: z.z.string(),
   homeDir: z.z.string(),
-  happyHomeDir: z.z.string(),
-  happyLibDir: z.z.string()
+  zenfloHomeDir: z.z.string(),
+  zenfloLibDir: z.z.string()
 });
 z.z.object({
   status: z.z.union([
@@ -1019,7 +1019,7 @@ class RpcHandlerManager {
   }
 }
 
-const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-CJaqq466.cjs', document.baseURI).href))));
+const __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('types-Dvhor4zW.cjs', document.baseURI).href))));
 function projectPath() {
   const path$1 = path.resolve(__dirname$1, "..");
   return path$1;
@@ -1463,9 +1463,11 @@ class ApiSessionClient extends node_events.EventEmitter {
     }
     logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
     const encrypted = encodeBase64(encrypt(this.encryptionKey, this.encryptionVariant, content));
+    const localId = typeof body.uuid === "string" ? body.uuid : null;
     this.socket.emit("message", {
       sid: this.sessionId,
-      message: encrypted
+      message: encrypted,
+      localId
     });
     if (body.type === "assistant" && body.message.usage) {
       try {
@@ -2190,6 +2192,14 @@ const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
     type: z.z.literal("system"),
     uuid: z.z.string()
     // Used in getMessageKey()
+  }).passthrough(),
+  // Queue operation - internal Claude Code message for managing task queue
+  // These are not sent to backend, just need to be parseable
+  z.z.object({
+    type: z.z.literal("queue-operation"),
+    operation: z.z.enum(["enqueue", "dequeue"]),
+    timestamp: z.z.string(),
+    sessionId: z.z.string()
   }).passthrough()
 ]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zenflo",
-  "version": "0.11.6",
+  "version": "0.11.7",
   "description": "Mobile and Web client for Claude Code and Codex - ZenFlo edition",
   "author": "Combined Memory",
   "license": "MIT",

package/scripts/claude_local_launcher.cjs

@@ -1,9 +1,21 @@
+#!/usr/bin/env node
+
 const crypto = require('crypto');
 const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
 
 // Disable autoupdater (never works really)
 process.env.DISABLE_AUTOUPDATER = '1';
 
+// Debug helper - only output when DEBUG=1
+const DEBUG = process.env.DEBUG === '1' || process.env.DEBUG === 'true';
+function debug(...args) {
+    if (DEBUG) {
+        console.error(...args);
+    }
+}
+
 // Helper to write JSON messages to fd 3
 function writeMessage(message) {
     try {
@@ -13,6 +25,145 @@ function writeMessage(message) {
     }
 }
 
+// Check if we're being called from zenflo (has fd 3 open) or directly from Claude Code extension
+let isCalledFromZenflo = false;
+try {
+    // Try to write to fd 3 - if it exists, we're being called from zenflo
+    fs.writeSync(3, '');
+    isCalledFromZenflo = true;
+} catch (err) {
+    // fd 3 doesn't exist, we're being called directly from Claude Code extension
+    isCalledFromZenflo = false;
+}
+
+// Track session IDs to prevent duplicate notifications
+const capturedSessionIds = new Set();
+let daemonNotified = false;
+let sessionWatcher = null;
+
+// Helper to get project path (same logic as zenflo)
+function getProjectPath(workingDirectory) {
+    const { join, resolve } = require('path');
+    const { homedir } = require('os');
+    
+    // Resolve and convert to a filesystem-safe path (replace /, \, ., : with -)
+    const projectId = resolve(workingDirectory).replace(/[\\\/\.:]/g, '-');
+    
+    // Get Claude config directory
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+    
+    // Return project directory path
+    return join(claudeConfigDir, 'projects', projectId);
+}
+
+// Helper to notify daemon about session (only once per session)
+async function notifyDaemon(sessionId) {
+    if (daemonNotified || capturedSessionIds.has(sessionId)) {
+        return;
+    }
+    capturedSessionIds.add(sessionId);
+    
+    try {
+        const { readFileSync } = require('fs');
+        const { homedir } = require('os');
+        
+        // Read daemon state to get HTTP port
+        const daemonStatePath = path.join(
+            process.env.ZENFLO_HOME_DIR || path.join(homedir(), '.happy'),
+            'daemon.state.json'
+        );
+        
+        let daemonState;
+        try {
+            daemonState = JSON.parse(readFileSync(daemonStatePath, 'utf8'));
+        } catch (err) {
+            // Daemon not running or state file doesn't exist
+            return;
+        }
+        
+        if (!daemonState.httpPort) {
+            return;
+        }
+        
+        // Notify daemon about the session
+        const metadata = {
+            path: process.cwd(),
+            host: require('os').hostname(),
+            hostPid: process.pid,
+            startedBy: 'claude-code-extension',
+            flavor: 'claude'
+        };
+        
+        const response = await fetch(`http://127.0.0.1:${daemonState.httpPort}/session-started`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ sessionId, metadata })
+        });
+        
+        if (response.ok) {
+            daemonNotified = true;
+        }
+    } catch (err) {
+        // Ignore errors - daemon might not be ready or not running
+    }
+}
+
+// Helper to handle detected session
+function handleSessionFile(sessionId) {
+    if (capturedSessionIds.has(sessionId)) {
+        return; // Already processed
+    }
+    capturedSessionIds.add(sessionId);
+
+    // Emit UUID message on fd 3 for session detection (when called from zenflo)
+    if (isCalledFromZenflo) {
+        writeMessage({ type: 'uuid', value: sessionId });
+    }
+
+    // Notify daemon (when called directly)
+    if (!isCalledFromZenflo) {
+        notifyDaemon(sessionId).catch(() => {});
+    }
+}
+
+// Helper to start session file watcher
+function startSessionWatcher() {
+    const { watch, mkdirSync } = require('fs');
+
+    try {
+        const cwd = process.cwd();
+        const projectDir = getProjectPath(cwd);
+        mkdirSync(projectDir, { recursive: true});
+
+        debug('[launcher] Working directory:', cwd);
+        debug('[launcher] Watching for sessions in:', projectDir);
+        debug('[launcher] Called from zenflo:', isCalledFromZenflo);
+
+        // Watch for MODIFIED session files only (not existing ones)
+        // This ensures we only track sessions that are actively being used
+        sessionWatcher = watch(projectDir, (eventType, filename) => {
+            if (typeof filename === 'string' && filename.toLowerCase().endsWith('.jsonl')) {
+                const sessionId = filename.replace('.jsonl', '');
+
+                // Only handle 'change' events (file modifications), not 'rename' (file creation)
+                // This prevents tracking empty session files that are created but never used
+                if (eventType === 'change') {
+                    debug('[launcher] Active session detected:', sessionId);
+                    handleSessionFile(sessionId);
+                }
+            }
+        });
+    } catch (err) {
+        console.error('[launcher] Error starting session watcher:', err.message);
+    }
+}
+
+// Start watching for session files
+// - When called directly (extension): notify daemon
+// - When called from zenflo with native binary: emit UUID messages for session detection
+// - When called from zenflo with JS module: UUID messages come from crypto interception
+startSessionWatcher();
+
 // Intercept crypto.randomUUID
 const originalRandomUUID = crypto.randomUUID;
 Object.defineProperty(global, 'crypto', {
@@ -23,6 +174,7 @@ Object.defineProperty(global, 'crypto', {
             randomUUID: () => {
                 const uuid = originalRandomUUID();
                 writeMessage({ type: 'uuid', value: uuid });
+                // Don't notify daemon from UUID interceptor - let file watcher handle it
                 return uuid;
             }
         };
@@ -35,6 +187,7 @@ Object.defineProperty(crypto, 'randomUUID', {
         return () => {
             const uuid = originalRandomUUID();
             writeMessage({ type: 'uuid', value: uuid });
+            // Don't notify daemon from UUID interceptor - let file watcher handle it
             return uuid;
         }
     }
@@ -51,15 +204,15 @@ global.fetch = function(...args) {
     
     // Parse URL for privacy
     let hostname = '';
-    let path = '';
+    let pathname = '';
     try {
         const urlObj = new URL(url, 'http://localhost');
         hostname = urlObj.hostname;
-        path = urlObj.pathname;
+        pathname = urlObj.pathname;
     } catch (e) {
         // If URL parsing fails, use defaults
         hostname = 'unknown';
-        path = url;
+        pathname = url;
     }
     
     // Send fetch start event
@@ -67,7 +220,7 @@ global.fetch = function(...args) {
         type: 'fetch-start',
         id,
         hostname,
-        path,
+        path: pathname,
         method,
         timestamp: Date.now()
     });
@@ -95,4 +248,108 @@ global.fetch = function(...args) {
 Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
 Object.defineProperty(global.fetch, 'length', { value: originalFetch.length });
 
-import('@anthropic-ai/claude-code/cli.js')
+// Get paths
+const scriptDir = __dirname;
+const cliDir = path.resolve(scriptDir, '..');
+const zenfloBin = path.resolve(cliDir, 'bin', 'zenflo.mjs');
+const claudeCodePath = path.resolve(cliDir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+const claudeCodePathMonorepo = path.resolve(cliDir, '..', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+
+if (!isCalledFromZenflo) {
+    // Called directly from Claude Code extension
+    // Just ensure daemon is running, then load Claude Code directly
+    // The file watcher will detect the session and notify daemon
+    try {
+        // Try to start zenflo daemon in background if not already running (non-blocking)
+        const daemonProcess = spawn(process.execPath, [zenfloBin, 'daemon', 'start'], {
+            detached: true,
+            stdio: 'ignore'
+        });
+        daemonProcess.unref();
+        // Give daemon a moment to start before we continue
+        setTimeout(() => {}, 500);
+    } catch (err) {
+        // Ignore errors - daemon might already be running
+    }
+    // Continue to load Claude Code directly - this creates ONE session
+    // The file watcher will detect it and notify daemon
+}
+
+// We're being called from zenflo (or fallback) - just load Claude Code with intercepts
+// Use require for CommonJS compatibility since this is a .cjs file
+try {
+    // Check if native binary path was provided by extension wrapper
+    const nativeBinary = process.env.CLAUDE_CODE_NATIVE_BINARY;
+
+    // Debug logging to stderr (won't interfere with stdio)
+    if (nativeBinary) {
+        debug(`[launcher] Native binary path provided: ${nativeBinary}`);
+        debug(`[launcher] File exists: ${fs.existsSync(nativeBinary)}`);
+    } else {
+        debug('[launcher] No CLAUDE_CODE_NATIVE_BINARY env var');
+    }
+
+    if (nativeBinary && fs.existsSync(nativeBinary)) {
+        debug('[launcher] Spawning native binary...');
+        debug('[launcher] Working directory:', process.cwd());
+        // Native binary is a compiled executable, need to spawn it instead of require
+        // Pass through all arguments, stdio, and working directory
+        const child = spawn(nativeBinary, process.argv.slice(2), {
+            stdio: 'inherit',
+            cwd: process.cwd(), // Ensure native binary uses correct working directory
+            env: process.env
+        });
+
+        // Forward all termination signals to child
+        const killChild = () => {
+            if (!child.killed) {
+                debug('[launcher] Killing child process...');
+                child.kill('SIGTERM');
+                // Force kill after 1 second if not dead
+                setTimeout(() => {
+                    if (!child.killed) {
+                        child.kill('SIGKILL');
+                    }
+                }, 1000);
+            }
+        };
+
+        process.on('SIGTERM', killChild);
+        process.on('SIGINT', killChild);
+        process.on('exit', killChild); // Also kill on normal exit (e.g., abort signal)
+
+        // Exit with child's exit code
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                process.kill(process.pid, signal);
+            } else {
+                process.exit(code || 0);
+            }
+        });
+    } else if (fs.existsSync(claudeCodePath)) {
+        debug('[launcher] Loading Claude Code from cli/node_modules');
+        require(claudeCodePath);
+    } else if (fs.existsSync(claudeCodePathMonorepo)) {
+        // Try monorepo root node_modules (Yarn workspace hoisting)
+        debug('[launcher] Loading Claude Code from monorepo node_modules');
+        require(claudeCodePathMonorepo);
+    } else {
+        // Fallback: try to use the system claude command
+        try {
+            const claudePath = execSync('which claude', { encoding: 'utf8' }).trim();
+            const resolvedPath = fs.realpathSync(claudePath);
+            require(resolvedPath);
+        } catch (whichErr) {
+            console.error('Failed to find Claude Code CLI');
+            console.error('Tried local path:', claudeCodePath);
+            console.error('Tried monorepo path:', claudeCodePathMonorepo);
+            console.error('Tried system claude command (not found)');
+            console.error('Make sure @anthropic-ai/claude-code is installed in node_modules or claude is in PATH');
+            process.exit(1);
+        }
+    }
+} catch (err) {
+    console.error('Failed to load Claude Code CLI:', err.message);
+    console.error('Tried paths:', claudeCodePath, claudeCodePathMonorepo, process.env.CLAUDE_CODE_NATIVE_BINARY);
+    process.exit(1);
+}

package/scripts/extension_wrapper.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Wrapper for Claude Code extension to launch ZenFlo instead of raw Claude
+
+# The extension passes the native binary path as first argument
+NATIVE_BINARY="$1"
+shift
+
+# Export the native binary path for the launcher to use
+export CLAUDE_CODE_NATIVE_BINARY="$NATIVE_BINARY"
+
+# Launch zenflo which creates full backend sessions
+# ZenFlo will spawn Claude Code with proper stdio handling
+exec zenflo "$@"