@lanonasis/cli 3.9.4 → 3.9.5

package/README.md

@@ -242,6 +242,12 @@ onasis memory list --type context --limit 20
 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 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
@@ -258,6 +264,34 @@ 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 |
 |-------|------|-------------|
@@ -266,6 +300,8 @@ onasis memory stats                       # Memory statistics
 | `-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
 
@@ -637,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/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

@@ -152,7 +152,7 @@ export class TextInputHandlerImpl {
                 };
                 // Ensure stdin is flowing before adding listener
                 // This is critical after inquirer prompts which may pause stdin
-                process.stdin.resume();
+                this.resumeStdinIfSupported();
                 process.stdin.on('data', handleKeypress);
             }
             catch (error) {
@@ -168,13 +168,13 @@ export class TextInputHandlerImpl {
         if (!this.isRawModeEnabled && process.stdin.isTTY) {
             this.originalStdinMode = process.stdin.isRaw;
             process.stdin.setRawMode(true);
-            process.stdin.resume(); // Ensure stdin is flowing to receive data events
+            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');
-            process.stdin.resume();
+            this.resumeStdinIfSupported();
         }
     }
     /**
@@ -302,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.4",
+  "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"
   }