@lanonasis/cli 3.9.3 → 3.9.5

package/CHANGELOG.md

@@ -16,6 +16,11 @@
   - Path translation handles endpoint differences between API and MCP servers
   - Vendor key authentication continues to route to main API server
 
+- **Frozen Terminal During Text Input**: Fixed SSE/WebSocket event handlers interfering with inline text editor
+  - Real-time update messages (📡) now only display in verbose mode
+  - Prevents terminal freeze during interactive prompts (memory create, update)
+  - Raw terminal mode no longer conflicts with background MCP events
+
 - **Missing CLI Option**: The `--vendor-key` option was defined in code but not exposed in CLI
   - Now properly registered in command-line interface
 

package/README.md

@@ -1,11 +1,11 @@
-# @lanonasis/cli v3.9.0 - Enterprise Security & Professional UX
+# @lanonasis/cli v3.9.3 - Enterprise Security & Professional UX
 
 [![NPM Version](https://img.shields.io/npm/v/@lanonasis/cli)](https://www.npmjs.com/package/@lanonasis/cli)
 [![Downloads](https://img.shields.io/npm/dt/@lanonasis/cli)](https://www.npmjs.com/package/@lanonasis/cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Golden Contract](https://img.shields.io/badge/Onasis--Core-v0.1%20Compliant-gold)](https://api.lanonasis.com/.well-known/onasis.json)
 
-🎉 **NEW IN v3.9**: Professional CLI UX with seamless inline text editing, intelligent MCP connection management, and first-run onboarding. Advanced Model Context Protocol (MCP) support with multi-server connections, enhanced error handling, and enterprise-grade transport protocols. Revolutionary interactive CLI experience with guided workflows and **Golden Contract compliance**.
+🎉 **NEW IN v3.9.3**: Fixed JWT authentication routing for username/password login, resolved frozen terminal during interactive input, and added non-interactive vendor key authentication (`-k` flag). Professional CLI UX with seamless inline text editing, intelligent MCP connection management, and first-run onboarding.
 
 ## 🚀 Quick Start
 
@@ -151,7 +151,11 @@ onasis login --vendor-key pk_xxxxx.sk_xxxxx  // ✅ Automatically hashed
 Best for API integrations and automation. Copy the vendor key value exactly as shown in your LanOnasis dashboard (keys may vary in format):
 
 ```bash
-onasis login --vendor-key <your-vendor-key>
+# Full option
+onasis auth login --vendor-key <your-vendor-key>
+
+# Short form (for scripts and CI/CD)
+onasis auth login -k <your-vendor-key>
 ```
 
 ### 2. OAuth Browser Authentication
@@ -179,6 +183,13 @@ onasis auth status    # Check current authentication
 onasis auth logout    # Logout from current session
 ```
 
+**Auth Login Options:**
+| Short | Long | Description |
+|-------|------|-------------|
+| `-k` | `--vendor-key <key>` | Authenticate with vendor key (non-interactive) |
+| `-e` | `--email <email>` | Email for credentials login |
+| `-p` | `--password <pass>` | Password for credentials login |
+
 ## 💻 Shell Completions
 
 ### Installation Guide
@@ -224,24 +235,74 @@ onasis quickstart      # Essential commands reference
 
 ```bash
 # List memories
-onasis memory list
-onasis memory list --memory-type context --limit 20 --sort-by created_at
+onasis memory list                        # or: onasis memory ls
+onasis memory list --type context --limit 20
+
+# Create memories (non-interactive)
+onasis memory create -t "Project Notes" -c "Important information"
+onasis memory create -t "Reference" --type reference --tags "docs,api"
+
+# Create memory via JSON payload
+onasis memory create --json '{"title":"Design decisions","type":"project","content":"Summary...","tags":["architecture","design"]}'
 
-# Create memories
-onasis memory create --title "Project Notes" --content "Important information"
-onasis memory create --title "Reference" --memory-type reference --tags "docs,api"
+# Create memory from a file
+onasis memory create -t "Session notes" --content-file ./notes.md
+
+# Create memories (interactive)
+onasis memory create -i                   # Interactive mode with inline editor
+onasis memory create                      # Prompts for missing fields
 
 # Search memories
 onasis memory search "api integration"
-onasis memory search "meeting notes" --memory-types context,reference
+onasis memory search "meeting notes" --type context
 
 # Memory operations
 onasis memory get <id>                    # Get specific memory
-onasis memory update <id> --title "New Title"
+onasis memory update <id> -t "New Title"  # Update title
+onasis memory update <id> -i              # Interactive update
 onasis memory delete <id>                 # Delete memory
 onasis memory stats                       # Memory statistics
 ```
 
+#### `onasis memory save-session`
+
+Save the current CLI session context (CWD + git branch/status + changed files) as a memory entry so you can persist what you worked on and pick it up later.
+
+- `--test-summary`: Stores a human-readable test result summary (e.g., `Vitest: 53 passed, 1 skipped`) in the saved session memory.
+- `--title`: Sets the memory title (default: `Session summary`).
+- `--type`: Sets the memory type (default: `project`).
+- `--tags`: Comma-separated tags for session metadata (default: `session,cli`).
+
+**Examples**
+```bash
+onasis memory save-session --test-summary "Vitest: 53 passed, 1 skipped"
+onasis memory save-session --title "API client fixes" --type project --tags "session,cli,testing"
+```
+
+See **Session management** below for related commands.
+
+#### Session management
+
+Sessions are stored as memory entries (tagged `session,cli` by default). Related commands:
+
+```bash
+onasis memory save-session
+onasis memory list-sessions
+onasis memory load-session <id>
+onasis memory delete-session <id>
+```
+
+**Create/Update Options:**
+| Short | Long | Description |
+|-------|------|-------------|
+| `-t` | `--title` | Memory title |
+| `-c` | `--content` | Memory content |
+| `-i` | `--interactive` | Interactive mode |
+| | `--type` | Memory type (context, project, knowledge, etc.) |
+| | `--tags` | Comma-separated tags |
+| | `--json` | JSON payload (title, content, type/memory_type, tags, topic_id) |
+| | `--content-file` | Read content from a file |
+
 ### Topic Management
 
 ```bash
@@ -612,4 +673,3 @@ The CLI will show the authorization URL - copy and paste it into your browser ma
 
 **Token refresh failed:**
 Run `onasis auth login` to re-authenticate.
-

package/dist/commands/config.js

@@ -11,11 +11,13 @@ export function configCommands(program) {
         .action(async (key, value) => {
         const config = new CLIConfig();
         await config.init();
+        let shouldSave = true;
         // Handle special cases
         switch (key) {
             case 'api-url':
                 await config.setApiUrl(value);
                 console.log(chalk.green('✓ API URL updated:'), value);
+                shouldSave = false; // setApiUrl already persists
                 break;
             case 'ai-integration':
                 if (value === 'claude-mcp') {
@@ -42,11 +44,19 @@ export function configCommands(program) {
                 config.set('mcpServerUrl', value);
                 console.log(chalk.green('✓ MCP server URL updated:'), value);
                 break;
+            case 'force-api':
+                config.set('forceApi', value === 'true');
+                config.set('connectionTransport', value === 'true' ? 'api' : 'auto');
+                console.log(chalk.green('✓ Force direct API mode:'), value === 'true' ? 'enabled' : 'disabled');
+                break;
             default:
                 // Generic config set
                 config.set(key, value);
                 console.log(chalk.green(`✓ ${key} set to:`), value);
         }
+        if (shouldSave) {
+            await config.save();
+        }
     });
     // Generic config get command
     program
@@ -101,6 +111,7 @@ export function configCommands(program) {
             { key: 'mcp-use-remote', description: 'Use remote MCP server', current: config.get('mcpUseRemote') || false },
             { key: 'mcp-server-path', description: 'Local MCP server path', current: config.get('mcpServerPath') || 'default' },
             { key: 'mcp-server-url', description: 'Remote MCP server URL', current: config.get('mcpServerUrl') || 'https://mcp.lanonasis.com' },
+            { key: 'force-api', description: 'Force direct API transport', current: config.get('forceApi') || false },
             { key: 'mcpEnabled', description: 'MCP integration enabled', current: config.get('mcpEnabled') || false }
         ];
         configOptions.forEach(opt => {

package/dist/commands/memory.js

@@ -8,6 +8,30 @@ import { apiClient } from '../utils/api.js';
 import { formatBytes, truncateText } from '../utils/formatting.js';
 import { CLIConfig } from '../utils/config.js';
 import { createTextInputHandler } from '../ux/index.js';
+import * as fs from 'fs/promises';
+import { exec as execCb } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execCb);
+const MEMORY_TYPE_CHOICES = [
+    'context',
+    'project',
+    'knowledge',
+    'reference',
+    'personal',
+    'workflow',
+];
+const coerceMemoryType = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    // Backward compatibility for older docs/examples.
+    if (normalized === 'conversation')
+        return 'context';
+    if (MEMORY_TYPE_CHOICES.includes(normalized)) {
+        return normalized;
+    }
+    return undefined;
+};
 const resolveInputMode = async () => {
     const config = new CLIConfig();
     await config.init();
@@ -41,13 +65,53 @@ export function memoryCommands(program) {
         .description('Create a new memory entry')
         .option('-t, --title <title>', 'memory title')
         .option('-c, --content <content>', 'memory content')
-        .option('--type <type>', 'memory type (conversation, knowledge, project, context, reference)', 'context')
+        .option('--type <type>', `memory type (${MEMORY_TYPE_CHOICES.join(', ')})`)
         .option('--tags <tags>', 'comma-separated tags')
         .option('--topic-id <id>', 'topic ID')
         .option('-i, --interactive', 'interactive mode')
+        .option('--json <json>', 'JSON payload (title, content, type/memory_type, tags[], topic_id)')
+        .option('--content-file <path>', 'Read memory content from a file (overrides --content)')
         .action(async (options) => {
         try {
-            let { title, content, type, tags, topicId, interactive } = options;
+            let { title, content, type, tags, topicId, interactive, json, contentFile } = options;
+            // 1) JSON payload (optional)
+            if (json) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(json);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : 'Invalid JSON';
+                    throw new Error(`Invalid --json payload: ${msg}`);
+                }
+                if (!title && typeof parsed.title === 'string')
+                    title = parsed.title;
+                if (!content && typeof parsed.content === 'string')
+                    content = parsed.content;
+                const parsedType = parsed.memory_type ?? parsed.type;
+                if (!type && parsedType !== undefined) {
+                    const coerced = coerceMemoryType(parsedType);
+                    if (!coerced) {
+                        throw new Error(`Invalid memory type in --json payload. Expected one of: ${MEMORY_TYPE_CHOICES.join(', ')}`);
+                    }
+                    type = coerced;
+                }
+                if (!tags) {
+                    if (Array.isArray(parsed.tags)) {
+                        tags = parsed.tags.map((t) => String(t)).join(',');
+                    }
+                    else if (typeof parsed.tags === 'string') {
+                        tags = parsed.tags;
+                    }
+                }
+                const parsedTopic = parsed.topic_id ?? parsed.topicId;
+                if (!topicId && typeof parsedTopic === 'string')
+                    topicId = parsedTopic;
+            }
+            // 2) Content file (optional)
+            if (contentFile) {
+                content = await fs.readFile(contentFile, 'utf-8');
+            }
             if (interactive || (!title || !content)) {
                 const inputMode = await resolveInputMode();
                 const answers = await inquirer.prompt([
@@ -62,7 +126,7 @@ export function memoryCommands(program) {
                         type: 'list',
                         name: 'type',
                         message: 'Memory type:',
-                        choices: ['conversation', 'knowledge', 'project', 'context', 'reference'],
+                        choices: [...MEMORY_TYPE_CHOICES],
                         default: type || 'context',
                     },
                     {
@@ -86,11 +150,12 @@ export function memoryCommands(program) {
             if (!content || content.trim().length === 0) {
                 throw new Error('Content is required');
             }
+            const resolvedType = type ?? 'context';
             const spinner = ora('Creating memory...').start();
             const memoryData = {
                 title,
                 content,
-                memory_type: type
+                memory_type: resolvedType
             };
             if (tags) {
                 memoryData.tags = tags.split(',').map((tag) => tag.trim()).filter(Boolean);
@@ -115,6 +180,211 @@ export function memoryCommands(program) {
             process.exit(1);
         }
     });
+    // Save current working session context as a memory
+    program
+        .command('save-session')
+        .description('Save current session context (git branch/status + optional test summary) as a memory')
+        .option('-t, --title <title>', 'memory title', 'Session summary')
+        .option('--type <type>', `memory type (${MEMORY_TYPE_CHOICES.join(', ')})`, 'project')
+        .option('--tags <tags>', 'comma-separated tags', 'session,cli')
+        .option('--test-summary <text>', 'Optional test summary to include')
+        .action(async (options) => {
+        try {
+            const spinner = ora('Collecting session info...').start();
+            const cwd = process.cwd();
+            const runGit = async (cmd) => {
+                try {
+                    const { stdout } = await exec(cmd, { cwd });
+                    return String(stdout || '').trim();
+                }
+                catch {
+                    return null;
+                }
+            };
+            const branch = await runGit('git rev-parse --abbrev-ref HEAD');
+            const status = await runGit('git status --porcelain');
+            const changedFiles = status
+                ? status
+                    .split('\n')
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .map((line) => line.replace(/^.. /, ''))
+                : [];
+            const lines = [];
+            lines.push(`# Session Summary`);
+            lines.push('');
+            lines.push(`- Date: ${new Date().toISOString()}`);
+            lines.push(`- CWD: ${cwd}`);
+            if (branch)
+                lines.push(`- Git branch: ${branch}`);
+            lines.push('');
+            lines.push('## Changes');
+            if (changedFiles.length === 0) {
+                lines.push('No uncommitted changes detected (or git not available).');
+            }
+            else {
+                lines.push(changedFiles.map((f) => `- ${f}`).join('\n'));
+            }
+            lines.push('');
+            if (options.testSummary) {
+                lines.push('## Test Summary');
+                lines.push(options.testSummary);
+                lines.push('');
+            }
+            spinner.text = 'Saving session memory...';
+            const resolvedType = coerceMemoryType(options.type) ?? 'project';
+            const memoryData = {
+                title: options.title || 'Session summary',
+                content: lines.join('\n'),
+                memory_type: resolvedType
+            };
+            if (options.tags) {
+                memoryData.tags = options.tags.split(',').map((t) => t.trim()).filter(Boolean);
+            }
+            const memory = await apiClient.createMemory(memoryData);
+            spinner.succeed('Session saved');
+            console.log();
+            console.log(chalk.green('✓ Memory created:'));
+            console.log(`  ID: ${chalk.cyan(memory.id)}`);
+            console.log(`  Title: ${memory.title}`);
+            console.log(`  Type: ${memory.memory_type}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to save session:'), errorMessage);
+            process.exit(1);
+        }
+    });
+    // Session management helpers (sessions are stored as memory entries tagged `session,cli` by default)
+    program
+        .command('list-sessions')
+        .description('List saved CLI sessions (memories tagged session,cli by default)')
+        .option('-p, --page <page>', 'page number', '1')
+        .option('-l, --limit <limit>', 'number of entries per page', '20')
+        .option('--type <type>', 'filter by memory type', 'project')
+        .option('--tags <tags>', 'filter by tags (comma-separated)', 'session,cli')
+        .option('--sort <field>', 'sort by field (created_at, updated_at, title, last_accessed)', 'created_at')
+        .option('--order <order>', 'sort order (asc, desc)', 'desc')
+        .action(async (options) => {
+        try {
+            const spinner = ora('Fetching sessions...').start();
+            const params = {
+                page: parseInt(options.page || '1'),
+                limit: parseInt(options.limit || '20'),
+                sort: options.sort || 'created_at',
+                order: options.order || 'desc'
+            };
+            if (options.type)
+                params.memory_type = options.type;
+            if (options.tags)
+                params.tags = options.tags;
+            const result = await apiClient.getMemories(params);
+            spinner.stop();
+            const memories = result.memories || result.data || [];
+            if (memories.length === 0) {
+                console.log(chalk.yellow('No sessions found'));
+                return;
+            }
+            console.log(chalk.blue.bold(`\n📚 Sessions (${result.pagination.total} total)`));
+            console.log(chalk.gray(`Page ${result.pagination.page || 1} of ${result.pagination.pages || Math.ceil(result.pagination.total / result.pagination.limit)}`));
+            console.log();
+            const outputFormat = process.env.CLI_OUTPUT_FORMAT || 'table';
+            if (outputFormat === 'json') {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            const tableData = memories.map((memory) => [
+                truncateText(memory.title, 30),
+                memory.memory_type,
+                memory.tags.slice(0, 3).join(', '),
+                format(new Date(memory.created_at), 'MMM dd, yyyy'),
+                memory.access_count
+            ]);
+            const tableConfig = {
+                header: ['Title', 'Type', 'Tags', 'Created', 'Access'],
+                columnDefault: {
+                    width: 20,
+                    wrapWord: true
+                },
+                columns: [
+                    { width: 30 },
+                    { width: 12 },
+                    { width: 20 },
+                    { width: 12 },
+                    { width: 8 }
+                ]
+            };
+            console.log(table([tableConfig.header, ...tableData], {
+                columnDefault: tableConfig.columnDefault,
+                columns: tableConfig.columns
+            }));
+            if (result.pagination.pages > 1) {
+                console.log(chalk.gray(`\nUse --page ${result.pagination.page + 1} for next page`));
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to list sessions:'), errorMessage);
+            process.exit(1);
+        }
+    });
+    program
+        .command('load-session')
+        .description('Load a saved session by memory ID (prints the saved session context)')
+        .argument('<id>', 'session memory ID')
+        .action(async (id) => {
+        try {
+            const spinner = ora('Loading session...').start();
+            const memory = await apiClient.getMemory(id);
+            spinner.stop();
+            const outputFormat = process.env.CLI_OUTPUT_FORMAT || 'text';
+            if (outputFormat === 'json') {
+                console.log(JSON.stringify(memory, null, 2));
+                return;
+            }
+            console.log(chalk.blue.bold('\n📌 Session'));
+            console.log(chalk.gray(`${memory.title} (${memory.id})`));
+            console.log();
+            console.log(memory.content);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to load session:'), errorMessage);
+            process.exit(1);
+        }
+    });
+    program
+        .command('delete-session')
+        .description('Delete a saved session by memory ID')
+        .argument('<id>', 'session memory ID')
+        .option('-f, --force', 'skip confirmation')
+        .action(async (id, options) => {
+        try {
+            if (!options.force) {
+                const memory = await apiClient.getMemory(id);
+                const answer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `Are you sure you want to delete session "${memory.title}"?`,
+                        default: false
+                    }
+                ]);
+                if (!answer.confirm) {
+                    console.log(chalk.yellow('Deletion cancelled'));
+                    return;
+                }
+            }
+            const spinner = ora('Deleting session...').start();
+            await apiClient.deleteMemory(id);
+            spinner.succeed('Session deleted successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            console.error(chalk.red('✖ Failed to delete session:'), errorMessage);
+            process.exit(1);
+        }
+    });
     // List memories
     program
         .command('list')
@@ -294,7 +564,7 @@ export function memoryCommands(program) {
         .argument('<id>', 'memory ID')
         .option('-t, --title <title>', 'new title')
         .option('-c, --content <content>', 'new content')
-        .option('--type <type>', 'new memory type')
+        .option('--type <type>', `new memory type (${MEMORY_TYPE_CHOICES.join(', ')})`)
         .option('--tags <tags>', 'new tags (comma-separated)')
         .option('-i, --interactive', 'interactive mode')
         .action(async (id, options) => {
@@ -317,7 +587,7 @@ export function memoryCommands(program) {
                         type: 'list',
                         name: 'type',
                         message: 'Memory type:',
-                        choices: ['conversation', 'knowledge', 'project', 'context', 'reference'],
+                        choices: [...MEMORY_TYPE_CHOICES],
                         default: currentMemory.memory_type,
                     },
                     {

package/dist/index-simple.js

@@ -64,12 +64,23 @@ program
         process.env.MEMORY_API_URL = opts.apiUrl;
     }
     process.env.CLI_OUTPUT_FORMAT = opts.output;
+    const forceApiFromEnv = process.env.LANONASIS_FORCE_API === 'true' ||
+        process.env.CLI_FORCE_API === 'true' ||
+        process.env.ONASIS_FORCE_API === 'true';
+    const forceApiFromConfig = cliConfig.get('forceApi') === true ||
+        cliConfig.get('connectionTransport') === 'api';
+    const forceDirectApi = forceApiFromEnv || forceApiFromConfig || opts.mcp === false;
+    if (forceDirectApi) {
+        process.env.LANONASIS_FORCE_API = 'true';
+    }
     // Auto-initialize MCP unless disabled
     const isMcpFlow = actionCommand.name() === 'mcp' ||
         actionCommand.parent?.name?.() === 'mcp' ||
         actionCommand.name() === 'mcp-server' ||
         actionCommand.parent?.name?.() === 'mcp-server';
-    if (opts.mcp !== false && !isMcpFlow && !['init', 'auth', 'login', 'health', 'status'].includes(actionCommand.name())) {
+    const isConfigFlow = actionCommand.name() === 'config' ||
+        actionCommand.parent?.name?.() === 'config';
+    if (!forceDirectApi && !isMcpFlow && !isConfigFlow && !['init', 'auth', 'login', 'health', 'status'].includes(actionCommand.name())) {
         try {
             const client = getMCPClient();
             if (!client.isConnectedToServer()) {
@@ -87,6 +98,9 @@ program
             }
         }
     }
+    else if (forceDirectApi && process.env.CLI_VERBOSE === 'true') {
+        console.log(colors.muted('MCP auto-connect skipped (force direct API enabled)'));
+    }
 });
 // Enhanced global error handler
 process.on('uncaughtException', (error) => {
@@ -324,11 +338,10 @@ const topicCmd = program
     .description('Topic management commands');
 requireAuth(topicCmd);
 topicCommands(topicCmd);
-// Configuration commands (require auth)
+// Configuration commands (no auth required)
 const configCmd = program
     .command('config')
     .description('Configuration management');
-requireAuth(configCmd);
 configCommands(configCmd);
 // Organization commands (require auth)
 const orgCmd = program

package/dist/index.js

@@ -53,6 +53,18 @@ program
         process.env.MEMORY_API_URL = opts.apiUrl;
     }
     process.env.CLI_OUTPUT_FORMAT = opts.output;
+    const forceApiFromEnv = process.env.LANONASIS_FORCE_API === 'true' ||
+        process.env.CLI_FORCE_API === 'true' ||
+        process.env.ONASIS_FORCE_API === 'true';
+    const forceApiFromConfig = cliConfig.get('forceApi') === true ||
+        cliConfig.get('connectionTransport') === 'api';
+    const forceDirectApi = forceApiFromEnv || forceApiFromConfig || opts.mcp === false;
+    if (process.env.CLI_VERBOSE === 'true') {
+        console.log(colors.muted(`transport flags: env=${forceApiFromEnv} config=${forceApiFromConfig} no_mcp=${opts.mcp === false}`));
+    }
+    if (forceDirectApi) {
+        process.env.LANONASIS_FORCE_API = 'true';
+    }
     const skipOnboarding = actionCommand.name() === 'init' ||
         actionCommand.name() === 'auth' ||
         actionCommand.parent?.name?.() === 'auth';
@@ -76,7 +88,9 @@ program
         actionCommand.parent?.name?.() === 'mcp' ||
         actionCommand.name() === 'mcp-server' ||
         actionCommand.parent?.name?.() === 'mcp-server';
-    if (opts.mcp !== false && !isMcpFlow && !['init', 'auth', 'login', 'health', 'status'].includes(actionCommand.name())) {
+    const isConfigFlow = actionCommand.name() === 'config' ||
+        actionCommand.parent?.name?.() === 'config';
+    if (!forceDirectApi && !isMcpFlow && !isConfigFlow && !['init', 'auth', 'login', 'health', 'status'].includes(actionCommand.name())) {
         try {
             const client = getMCPClient();
             if (!client.isConnectedToServer()) {
@@ -94,6 +108,9 @@ program
             }
         }
     }
+    else if (forceDirectApi && process.env.CLI_VERBOSE === 'true') {
+        console.log(colors.muted('MCP auto-connect skipped (force direct API enabled)'));
+    }
 });
 // Enhanced global error handler
 process.on('uncaughtException', (error) => {
@@ -399,11 +416,10 @@ const topicCmd = program
     .description('Topic management commands');
 requireAuth(topicCmd);
 topicCommands(topicCmd);
-// Configuration commands (require auth)
+// Configuration commands (no auth required)
 const configCmd = program
     .command('config')
     .description('Configuration management');
-requireAuth(configCmd);
 configCommands(configCmd);
 // Organization commands (require auth)
 const orgCmd = program

package/dist/mcp/schemas/tool-schemas.d.ts

@@ -91,18 +91,18 @@ export declare const MemoryListSchema: z.ZodObject<{
     tags?: string[];
     limit?: number;
     topic_id?: string;
+    order?: "desc" | "asc";
     memory_type?: "context" | "reference" | "note";
     offset?: number;
     sort_by?: "title" | "created_at" | "updated_at";
-    order?: "desc" | "asc";
 }, {
     tags?: string[];
     limit?: number;
     topic_id?: string;
+    order?: "desc" | "asc";
     memory_type?: "context" | "reference" | "note";
     offset?: number;
     sort_by?: "title" | "created_at" | "updated_at";
-    order?: "desc" | "asc";
 }>;
 export declare const TopicCreateSchema: z.ZodObject<{
     name: z.ZodString;
@@ -201,14 +201,14 @@ export declare const SystemConfigSchema: z.ZodObject<{
     scope: z.ZodDefault<z.ZodEnum<["user", "global"]>>;
 }, "strip", z.ZodTypeAny, {
     value?: any;
-    key?: string;
     action?: "get" | "set" | "reset";
     scope?: "user" | "global";
+    key?: string;
 }, {
     value?: any;
-    key?: string;
     action?: "get" | "set" | "reset";
     scope?: "user" | "global";
+    key?: string;
 }>;
 export declare const BulkOperationSchema: z.ZodObject<{
     operation: z.ZodEnum<["create", "update", "delete"]>;
@@ -463,18 +463,18 @@ export declare const MCPSchemas: {
             tags?: string[];
             limit?: number;
             topic_id?: string;
+            order?: "desc" | "asc";
             memory_type?: "context" | "reference" | "note";
             offset?: number;
             sort_by?: "title" | "created_at" | "updated_at";
-            order?: "desc" | "asc";
         }, {
             tags?: string[];
             limit?: number;
             topic_id?: string;
+            order?: "desc" | "asc";
             memory_type?: "context" | "reference" | "note";
             offset?: number;
             sort_by?: "title" | "created_at" | "updated_at";
-            order?: "desc" | "asc";
         }>;
     };
     topic: {
@@ -579,14 +579,14 @@ export declare const MCPSchemas: {
             scope: z.ZodDefault<z.ZodEnum<["user", "global"]>>;
         }, "strip", z.ZodTypeAny, {
             value?: any;
-            key?: string;
             action?: "get" | "set" | "reset";
             scope?: "user" | "global";
+            key?: string;
         }, {
             value?: any;
-            key?: string;
             action?: "get" | "set" | "reset";
             scope?: "user" | "global";
+            key?: string;
         }>;
     };
     operations: {

package/dist/utils/api.d.ts

@@ -54,11 +54,15 @@ export interface UpdateMemoryRequest {
     metadata?: Record<string, unknown>;
 }
 export interface GetMemoriesParams {
+    page?: number;
     limit?: number;
     offset?: number;
     memory_type?: MemoryType;
     tags?: string[] | string;
     topic_id?: string;
+    user_id?: string;
+    sort?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count' | 'title';
+    order?: 'asc' | 'desc';
     sort_by?: 'created_at' | 'updated_at' | 'last_accessed' | 'access_count';
     sort_order?: 'asc' | 'desc';
 }
@@ -148,6 +152,7 @@ export interface ApiErrorResponse {
 export declare class APIClient {
     private client;
     private config;
+    private normalizeMemoryEntry;
     constructor();
     login(email: string, password: string): Promise<AuthResponse>;
     register(email: string, password: string, organizationName?: string): Promise<AuthResponse>;

package/dist/utils/api.js

@@ -5,6 +5,26 @@ import { CLIConfig } from './config.js';
 export class APIClient {
     client;
     config;
+    normalizeMemoryEntry(payload) {
+        // API responses are inconsistent across gateways:
+        // - Some return the memory entry directly
+        // - Some wrap it in `{ data: <memory>, message?: string }`
+        if (payload && typeof payload === 'object') {
+            const obj = payload;
+            const directId = obj.id;
+            if (typeof directId === 'string' && directId.length > 0) {
+                return payload;
+            }
+            const data = obj.data;
+            if (data && typeof data === 'object') {
+                const dataObj = data;
+                if (typeof dataObj.id === 'string' && dataObj.id.length > 0) {
+                    return data;
+                }
+            }
+        }
+        return payload;
+    }
     constructor() {
         this.config = new CLIConfig();
         this.client = axios.create({
@@ -13,6 +33,8 @@ export class APIClient {
         // Setup request interceptor to add auth token and headers
         this.client.interceptors.request.use(async (config) => {
             await this.config.init();
+            // Keep OAuth sessions alive automatically (prevents intermittent "auth required" cutouts).
+            await this.config.refreshTokenIfNeeded();
             // Service Discovery
             await this.config.discoverServices();
             // Use appropriate base URL based on endpoint and auth method
@@ -20,17 +42,26 @@ export class APIClient {
             const discoveredServices = this.config.get('discoveredServices');
             const authMethod = this.config.get('authMethod');
             const vendorKey = await this.config.getVendorKeyAsync();
+            const token = this.config.getToken();
+            const forceApiFromEnv = process.env.LANONASIS_FORCE_API === 'true'
+                || process.env.CLI_FORCE_API === 'true'
+                || process.env.ONASIS_FORCE_API === 'true';
+            const forceApiFromConfig = this.config.get('forceApi') === true
+                || this.config.get('connectionTransport') === 'api';
+            const forceDirectApi = forceApiFromEnv || forceApiFromConfig;
+            const prefersTokenAuth = Boolean(token) && (authMethod === 'jwt' || authMethod === 'oauth' || authMethod === 'oauth2');
+            const useVendorKeyAuth = Boolean(vendorKey) && !prefersTokenAuth;
             // Determine the correct API base URL:
             // - Auth endpoints -> auth.lanonasis.com
             // - JWT auth (no vendor key) -> mcp.lanonasis.com (supports JWT tokens)
             // - Vendor key auth -> api.lanonasis.com (requires vendor key)
             let apiBaseUrl;
-            const useMcpServer = !vendorKey && (authMethod === 'jwt' || authMethod === 'oauth' || authMethod === 'oauth2');
+            const useMcpServer = !forceDirectApi && prefersTokenAuth && !useVendorKeyAuth;
             if (isAuthEndpoint) {
                 apiBaseUrl = discoveredServices?.auth_base || 'https://auth.lanonasis.com';
             }
-            else if (vendorKey) {
-                // Vendor key works with api.lanonasis.com
+            else if (forceDirectApi) {
+                // Force direct REST API mode to bypass MCP routing for troubleshooting.
                 apiBaseUrl = this.config.getApiUrl();
             }
             else if (useMcpServer) {
@@ -51,8 +82,22 @@ export class APIClient {
                 config.headers['X-Project-Scope'] = 'lanonasis-maas';
             }
             // Enhanced Authentication Support
-            const token = this.config.getToken();
-            if (vendorKey) {
+            // Even in forced direct-API mode, prefer bearer token auth when available.
+            // This avoids accidentally sending an OAuth access token as X-API-Key (we store it
+            // in secure storage for MCP/WebSocket usage), which can cause 401s.
+            const preferVendorKeyInDirectApiMode = forceDirectApi && Boolean(vendorKey) && !prefersTokenAuth;
+            if (preferVendorKeyInDirectApiMode) {
+                // Vendor key authentication (validated server-side)
+                // Send raw key - server handles hashing for comparison
+                config.headers['X-API-Key'] = vendorKey;
+                config.headers['X-Auth-Method'] = 'vendor_key';
+            }
+            else if (prefersTokenAuth) {
+                // JWT/OAuth token authentication takes precedence when both are present.
+                config.headers.Authorization = `Bearer ${token}`;
+                config.headers['X-Auth-Method'] = 'jwt';
+            }
+            else if (vendorKey) {
                 // Vendor key authentication (validated server-side)
                 // Send raw key - server handles hashing for comparison
                 config.headers['X-API-Key'] = vendorKey;
@@ -69,7 +114,10 @@ export class APIClient {
             // Add project scope for Golden Contract compliance
             config.headers['X-Project-Scope'] = 'lanonasis-maas';
             if (process.env.CLI_VERBOSE === 'true') {
+                const transportMode = forceDirectApi ? 'api-forced' : (useMcpServer ? 'mcp-http' : 'api');
+                config.headers['X-Transport-Mode'] = transportMode;
                 console.log(chalk.dim(`→ ${config.method?.toUpperCase()} ${config.url} [${requestId}]`));
+                console.log(chalk.dim(`  transport=${transportMode} baseURL=${config.baseURL}`));
             }
             return config;
         });
@@ -84,7 +132,7 @@ export class APIClient {
                 const { status, data } = error.response;
                 if (status === 401) {
                     console.error(chalk.red('✖ Authentication failed'));
-                    console.log(chalk.yellow('Please run:'), chalk.white('memory login'));
+                    console.log(chalk.yellow('Please run:'), chalk.white('lanonasis auth login'));
                     process.exit(1);
                 }
                 if (status === 403) {
@@ -127,19 +175,88 @@ export class APIClient {
     // All memory endpoints use /api/v1/memories path (plural, per REST conventions)
     async createMemory(data) {
         const response = await this.client.post('/api/v1/memories', data);
-        return response.data;
+        return this.normalizeMemoryEntry(response.data);
     }
     async getMemories(params = {}) {
-        const response = await this.client.get('/api/v1/memories', { params });
-        return response.data;
+        try {
+            const response = await this.client.get('/api/v1/memories', { params });
+            return response.data;
+        }
+        catch (error) {
+            // Backward-compatible fallback: newer API contracts may reject GET list and prefer search-only.
+            if (error?.response?.status === 405) {
+                const limit = Number(params.limit || 20);
+                const page = Number(params.page || 1);
+                const offset = Number(params.offset ?? Math.max(0, (page - 1) * limit));
+                const searchPayload = {
+                    query: '*',
+                    limit,
+                    threshold: 0
+                };
+                if (params.memory_type) {
+                    searchPayload.memory_types = [params.memory_type];
+                }
+                if (params.tags) {
+                    searchPayload.tags = Array.isArray(params.tags)
+                        ? params.tags
+                        : String(params.tags).split(',').map((tag) => tag.trim()).filter(Boolean);
+                }
+                if (params.topic_id) {
+                    searchPayload.topic_id = params.topic_id;
+                }
+                if (offset > 0) {
+                    searchPayload.offset = offset;
+                }
+                const fallback = await this.client.post('/api/v1/memories/search', searchPayload);
+                const payload = fallback.data || {};
+                const resultsArray = Array.isArray(payload.data)
+                    ? payload.data
+                    : Array.isArray(payload.results)
+                        ? payload.results
+                        : [];
+                const memories = resultsArray
+                    .map((entry) => {
+                    // Some gateways/search endpoints wrap results as `{ data: <memory> }`.
+                    if (entry && typeof entry === 'object') {
+                        const obj = entry;
+                        const data = obj.data;
+                        if (data && typeof data === 'object') {
+                            const dataObj = data;
+                            if (typeof dataObj.id === 'string' && dataObj.id.length > 0) {
+                                return data;
+                            }
+                        }
+                    }
+                    return entry;
+                })
+                    .map((entry) => this.normalizeMemoryEntry(entry));
+                const total = Number.isFinite(payload.total) ? Number(payload.total) : memories.length;
+                const pages = Math.max(1, Math.ceil(total / limit));
+                const currentPage = Math.max(1, Math.floor(offset / limit) + 1);
+                return {
+                    ...payload,
+                    data: memories,
+                    memories,
+                    pagination: {
+                        total,
+                        limit,
+                        offset,
+                        has_more: (offset + memories.length) < total,
+                        page: currentPage,
+                        pages
+                    }
+                };
+            }
+            throw error;
+        }
     }
     async getMemory(id) {
         const response = await this.client.get(`/api/v1/memories/${id}`);
-        return response.data;
+        return this.normalizeMemoryEntry(response.data);
     }
     async updateMemory(id, data) {
         const response = await this.client.put(`/api/v1/memories/${id}`, data);
-        return response.data;
+        return this.normalizeMemoryEntry(response.data);
     }
     async deleteMemory(id) {
         await this.client.delete(`/api/v1/memories/${id}`);

package/dist/utils/config.js

@@ -678,6 +678,9 @@ export class CLIConfig {
         return this.config.user;
     }
     async isAuthenticated() {
+        // Attempt refresh for OAuth sessions before checks (prevents intermittent auth dropouts).
+        // This is safe to call even when not using OAuth; it will no-op.
+        await this.refreshTokenIfNeeded();
         // Check if using vendor key authentication
         if (this.config.authMethod === 'vendor_key') {
             // Use async method to read from encrypted ApiKeyStorage
@@ -736,6 +739,16 @@ export class CLIConfig {
         const token = this.getToken();
         if (!token)
             return false;
+        // OAuth tokens are often opaque (not JWT). Prefer local expiry metadata when present.
+        if (this.config.authMethod === 'oauth') {
+            const tokenExpiresAt = this.get('token_expires_at');
+            if (typeof tokenExpiresAt === 'number') {
+                const isValid = Date.now() < tokenExpiresAt;
+                this.authCheckCache = { isValid, timestamp: Date.now() };
+                return isValid;
+            }
+            // Fall through to legacy validation when we don't have expiry metadata.
+        }
         // Check cache first
         if (this.authCheckCache && (Date.now() - this.authCheckCache.timestamp) < this.AUTH_CACHE_TTL) {
             return this.authCheckCache.isValid;
@@ -968,11 +981,85 @@ export class CLIConfig {
             return;
         }
         try {
+            // OAuth token refresh (opaque tokens + refresh_token + token_expires_at)
+            if (this.config.authMethod === 'oauth') {
+                const refreshToken = this.get('refresh_token');
+                if (!refreshToken) {
+                    return;
+                }
+                const tokenExpiresAtRaw = this.get('token_expires_at');
+                const tokenExpiresAt = (() => {
+                    const n = typeof tokenExpiresAtRaw === 'number'
+                        ? tokenExpiresAtRaw
+                        : typeof tokenExpiresAtRaw === 'string'
+                            ? Number(tokenExpiresAtRaw)
+                            : undefined;
+                    if (typeof n !== 'number' || !Number.isFinite(n) || n <= 0) {
+                        return undefined;
+                    }
+                    // Support both seconds and milliseconds since epoch.
+                    // Seconds are ~1.7e9; ms are ~1.7e12.
+                    return n < 1e11 ? n * 1000 : n;
+                })();
+                const nowMs = Date.now();
+                const refreshWindowMs = 5 * 60 * 1000; // 5 minutes
+                // If we don't know expiry, don't force a refresh.
+                if (typeof tokenExpiresAt !== 'number' || nowMs < (tokenExpiresAt - refreshWindowMs)) {
+                    return;
+                }
+                await this.discoverServices();
+                const authBase = this.getDiscoveredApiUrl();
+                const resp = await axios.post(`${authBase}/oauth/token`, {
+                    grant_type: 'refresh_token',
+                    refresh_token: refreshToken,
+                    client_id: 'lanonasis-cli'
+                }, {
+                    headers: { 'Content-Type': 'application/json' },
+                    timeout: 10000,
+                    proxy: false
+                });
+                // Some gateways wrap responses as `{ data: { ... } }`.
+                const raw = resp?.data;
+                const payload = raw && typeof raw === 'object' && raw.data && typeof raw.data === 'object'
+                    ? raw.data
+                    : raw;
+                const accessToken = payload?.access_token ?? payload?.token;
+                const refreshedRefreshToken = payload?.refresh_token;
+                const expiresIn = payload?.expires_in;
+                if (typeof accessToken !== 'string' || accessToken.length === 0) {
+                    throw new Error('Token refresh response missing access_token');
+                }
+                // setToken() assumes JWT by default; ensure authMethod stays oauth after storing.
+                await this.setToken(accessToken);
+                this.config.authMethod = 'oauth';
+                if (typeof refreshedRefreshToken === 'string' && refreshedRefreshToken.length > 0) {
+                    this.config.refresh_token = refreshedRefreshToken;
+                }
+                if (typeof expiresIn === 'number' && Number.isFinite(expiresIn)) {
+                    this.config.token_expires_at = Date.now() + (expiresIn * 1000);
+                }
+                // Keep the encrypted "vendor key" in sync for MCP/WebSocket clients that use X-API-Key.
+                // This does not change authMethod away from oauth (setVendorKey guards against that).
+                try {
+                    await this.setVendorKey(accessToken);
+                }
+                catch {
+                    // Non-fatal: bearer token refresh still helps API calls.
+                }
+                await this.save().catch(() => { });
+                return;
+            }
             // Check if token is JWT and if it's close to expiry
             if (token.startsWith('cli_')) {
                 // CLI tokens don't need refresh, they're long-lived
                 return;
             }
+            // Only attempt JWT refresh for tokens that look like JWTs.
+            // OAuth access tokens in this system can be opaque strings; treating them as JWTs
+            // creates noisy failures and can cause unwanted state writes.
+            if (token.split('.').length !== 3) {
+                return;
+            }
             const decoded = jwtDecode(token);
             const now = Date.now() / 1000;
             const exp = typeof decoded.exp === 'number' ? decoded.exp : 0;

package/dist/utils/mcp-client.js

@@ -469,7 +469,10 @@ export class MCPClient {
             this.sseConnection.onmessage = (event) => {
                 try {
                     const data = JSON.parse(event.data);
-                    console.log(chalk.blue('📡 Real-time update:'), data.type);
+                    // Only show SSE updates in verbose mode to avoid interfering with interactive prompts
+                    if (process.env.CLI_VERBOSE === 'true') {
+                        console.log(chalk.blue('📡 Real-time update:'), data.type);
+                    }
                 }
                 catch {
                     // Ignore parse errors
@@ -526,15 +529,20 @@ export class MCPClient {
                 this.wsConnection.on('message', (data) => {
                     try {
                         const message = JSON.parse(data.toString());
-                        const messageId = message.id ?? 'event';
-                        const messageType = message.method
-                            || (message.error ? 'error' : undefined)
-                            || (message.result ? 'result' : undefined)
-                            || 'response';
-                        console.log(chalk.blue('📡 MCP message:'), messageId, messageType);
+                        // Only show WebSocket messages in verbose mode to avoid interfering with interactive prompts
+                        if (process.env.CLI_VERBOSE === 'true') {
+                            const messageId = message.id ?? 'event';
+                            const messageType = message.method
+                                || (message.error ? 'error' : undefined)
+                                || (message.result ? 'result' : undefined)
+                                || 'response';
+                            console.log(chalk.blue('📡 MCP message:'), messageId, messageType);
+                        }
                     }
                     catch (error) {
-                        console.error('Failed to parse WebSocket message:', error);
+                        if (process.env.CLI_VERBOSE === 'true') {
+                            console.error('Failed to parse WebSocket message:', error);
+                        }
                     }
                 });
                 this.wsConnection.on('error', (error) => {

package/dist/ux/implementations/TextInputHandlerImpl.d.ts

@@ -47,6 +47,7 @@ export declare class TextInputHandlerImpl implements TextInputHandler {
      * Parse raw key event from buffer
      */
     private parseKeyEvent;
+    private resumeStdinIfSupported;
     /**
      * Check if a key event matches a key pattern
      */

package/dist/ux/implementations/TextInputHandlerImpl.js

@@ -46,46 +46,113 @@ export class TextInputHandlerImpl {
             options: mergedOptions,
             status: 'active',
         };
-        return new Promise((resolve, reject) => {
+        return new Promise(async (resolve, reject) => {
             let handleKeypress = null;
+            let sigintHandler = null;
             const cleanup = () => {
                 if (handleKeypress) {
                     process.stdin.removeListener('data', handleKeypress);
+                    handleKeypress = null;
+                }
+                if (sigintHandler) {
+                    process.removeListener('SIGINT', sigintHandler);
+                    sigintHandler = null;
                 }
                 this.disableRawMode();
+                // Restore terminal state
+                process.stdout.write('\x1b[?25h'); // Show cursor
+            };
+            // Set up completion handlers first
+            const complete = (result) => {
+                cleanup();
+                if (this.currentSession) {
+                    this.currentSession.status = 'completed';
+                }
+                resolve(result);
+            };
+            const cancel = () => {
+                cleanup();
+                if (this.currentSession) {
+                    this.currentSession.status = 'cancelled';
+                }
+                reject(new Error('Input cancelled by user'));
             };
+            // Store handlers for special key processing
+            this._completeHandler = complete;
+            this._cancelHandler = cancel;
             try {
+                // Check if we can use raw mode
+                if (!process.stdin.isTTY) {
+                    // Fall back to simple readline for non-TTY environments
+                    console.log('\nNote: Interactive text input not available. Using simple input mode.');
+                    console.log('Enter your text (empty line to finish):');
+                    const readline = require('readline');
+                    const rl = readline.createInterface({
+                        input: process.stdin,
+                        output: process.stdout
+                    });
+                    const lines = [];
+                    rl.on('line', (line) => {
+                        if (line === '') {
+                            rl.close();
+                            complete(lines.join('\n'));
+                        }
+                        else {
+                            lines.push(line);
+                        }
+                    });
+                    rl.on('close', () => {
+                        complete(lines.join('\n'));
+                    });
+                    return;
+                }
+                // Add SIGINT handler as fallback for Ctrl+C
+                sigintHandler = () => {
+                    cancel();
+                };
+                process.on('SIGINT', sigintHandler);
+                // Safety: Add a way to escape via triple-ESC (sends 3 escape chars quickly)
+                let escapeCount = 0;
+                let escapeTimer = null;
+                // Try to claim stdin from any previous handlers
+                process.stdin.removeAllListeners('data');
+                process.stdin.removeAllListeners('readable');
+                process.stdin.removeAllListeners('end');
                 this.enableRawMode();
+                // Verify raw mode is working
+                if (!this.isRawModeEnabled) {
+                    console.log('\nWarning: Could not enable raw mode. Falling back to editor mode.');
+                    cleanup();
+                    const { content } = await (await import('inquirer')).default.prompt([
+                        { type: 'editor', name: 'content', message: prompt, default: mergedOptions.defaultContent }
+                    ]);
+                    resolve(content);
+                    return;
+                }
                 this.displayInputPrompt(this.getCurrentContent());
                 handleKeypress = (chunk) => {
-                    const key = this.parseKeyEvent(chunk);
-                    if (this.handleSpecialKeys(key)) {
-                        return;
-                    }
-                    // Handle regular character input
-                    if (key.sequence && this.currentSession) {
-                        this.addCharacterToInput(key.sequence);
-                        this.displayInputPrompt(this.getCurrentContent());
-                    }
-                };
-                // Set up completion handlers
-                const complete = (result) => {
-                    cleanup();
-                    if (this.currentSession) {
-                        this.currentSession.status = 'completed';
+                    try {
+                        const key = this.parseKeyEvent(chunk);
+                        if (this.handleSpecialKeys(key)) {
+                            return;
+                        }
+                        // Handle regular character input
+                        if (key.sequence && this.currentSession) {
+                            // Filter out control characters that shouldn't be added as text
+                            if (key.sequence.charCodeAt(0) >= 32 || key.sequence === '\t') {
+                                this.addCharacterToInput(key.sequence);
+                                this.displayInputPrompt(this.getCurrentContent());
+                            }
+                        }
                     }
-                    resolve(result);
-                };
-                const cancel = () => {
-                    cleanup();
-                    if (this.currentSession) {
-                        this.currentSession.status = 'cancelled';
+                    catch (err) {
+                        // Don't let errors in key handling crash the input
+                        console.error('Key handling error:', err);
                     }
-                    reject(new Error('Input cancelled by user'));
                 };
-                // Store handlers for special key processing
-                this._completeHandler = complete;
-                this._cancelHandler = cancel;
+                // Ensure stdin is flowing before adding listener
+                // This is critical after inquirer prompts which may pause stdin
+                this.resumeStdinIfSupported();
                 process.stdin.on('data', handleKeypress);
             }
             catch (error) {
@@ -101,8 +168,14 @@ export class TextInputHandlerImpl {
         if (!this.isRawModeEnabled && process.stdin.isTTY) {
             this.originalStdinMode = process.stdin.isRaw;
             process.stdin.setRawMode(true);
+            this.resumeStdinIfSupported(); // Ensure stdin is flowing to receive data events
             this.isRawModeEnabled = true;
         }
+        else if (!process.stdin.isTTY) {
+            // Non-TTY mode - can't use raw mode, fall back to line mode
+            console.error('Warning: Not a TTY, inline text input may not work correctly');
+            this.resumeStdinIfSupported();
+        }
     }
     /**
      * Disable raw mode and return to normal terminal behavior
@@ -112,6 +185,7 @@ export class TextInputHandlerImpl {
             process.stdin.setRawMode(this.originalStdinMode || false);
             this.isRawModeEnabled = false;
         }
+        // Don't pause stdin here as other handlers may need it
     }
     /**
      * Handle special keyboard events
@@ -228,6 +302,11 @@ export class TextInputHandlerImpl {
         }
         return key;
     }
+    resumeStdinIfSupported() {
+        if (typeof process.stdin.resume === 'function') {
+            process.stdin.resume();
+        }
+    }
     /**
      * Check if a key event matches a key pattern
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lanonasis/cli",
-  "version": "3.9.3",
+  "version": "3.9.5",
   "description": "Professional CLI for LanOnasis Memory as a Service (MaaS) with MCP support, seamless inline editing, and enterprise-grade security",
   "keywords": [
     "lanonasis",
@@ -88,7 +88,7 @@
     "build": "rimraf dist && tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
     "postinstall": "node scripts/postinstall.js",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test": "[ -f node_modules/jest/bin/jest.js ] || bun install --no-save; node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:watch": "npm test -- --watch",
     "test:coverage": "npm test -- --coverage"
   }