morpheus-cli 0.9.12 → 0.9.20

package/dist/http/routers/link.js

@@ -2,11 +2,11 @@ import { Router } from 'express';
 import multer from 'multer';
 import path from 'path';
 import fs from 'fs-extra';
-import { homedir } from 'os';
-import { LinkRepository } from '../../runtime/link-repository.js';
-import { LinkWorker } from '../../runtime/link-worker.js';
+import { LinkRepository } from '../../runtime/subagents/link/repository.js';
+import { LinkWorker } from '../../runtime/subagents/link/worker.js';
 import { ConfigManager } from '../../config/manager.js';
-const DOCS_PATH = path.join(homedir(), '.morpheus', 'docs');
+import { PATHS } from '../../config/paths.js';
+const DOCS_PATH = PATHS.docs;
 // Configure multer for file uploads
 const storage = multer.diskStorage({
     destination: async (req, file, cb) => {

package/dist/runtime/__tests__/telephonist-tts.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createTtsTelephonist, TTS_MAX_CHARS } from '../telephonist.js';
+// ─── createTtsTelephonist factory ─────────────────────────────────────────────
+describe('createTtsTelephonist', () => {
+    it('returns an instance with synthesize() for openai provider', () => {
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'openai',
+            model: 'tts-1',
+            voice: 'alloy',
+        });
+        expect(telephonist).toBeDefined();
+        expect(typeof telephonist.synthesize).toBe('function');
+    });
+    it('returns an instance with synthesize() for google provider', () => {
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'google',
+            model: 'gemini-2.5-flash',
+            voice: 'Kore',
+        });
+        expect(telephonist).toBeDefined();
+        expect(typeof telephonist.synthesize).toBe('function');
+    });
+    it('throws for unsupported provider', () => {
+        expect(() => createTtsTelephonist({
+            enabled: true,
+            provider: 'ollama',
+            model: 'some-model',
+            voice: 'default',
+        })).toThrow(/Unsupported TTS provider/);
+    });
+    it('does not expose transcribe() meaningfully (throws)', async () => {
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'openai',
+            model: 'tts-1',
+            voice: 'alloy',
+        });
+        await expect(telephonist.transcribe('', '', '')).rejects.toThrow();
+    });
+});
+// ─── Text truncation ──────────────────────────────────────────────────────────
+describe('TTS text truncation', () => {
+    it('TTS_MAX_CHARS constant is 4096', () => {
+        expect(TTS_MAX_CHARS).toBe(4096);
+    });
+    it('short text (under 4096 chars) passes through unchanged in OpenAI synthesize', async () => {
+        // We test the truncation logic indirectly by checking that the SDK call
+        // receives the correct (non-truncated) text. We mock the OpenAI client.
+        const mockCreate = vi.fn().mockResolvedValue({
+            arrayBuffer: async () => new ArrayBuffer(8),
+        });
+        vi.mock('openai', () => ({
+            default: vi.fn().mockImplementation(() => ({
+                audio: {
+                    speech: { create: mockCreate },
+                },
+            })),
+        }));
+        vi.mock('fs-extra', () => ({
+            default: { writeFile: vi.fn().mockResolvedValue(undefined) },
+        }));
+        const telephonist = createTtsTelephonist({
+            enabled: true,
+            provider: 'openai',
+            model: 'tts-1',
+            voice: 'alloy',
+        });
+        const shortText = 'Hello world';
+        await telephonist.synthesize(shortText, 'fake-key').catch(() => { });
+        // Verify the mock was called with the short text (not truncated)
+        if (mockCreate.mock.calls.length > 0) {
+            expect(mockCreate.mock.calls[0][0].input).toBe(shortText);
+        }
+    });
+    it('long text (over 4096 chars) is truncated to 4096', () => {
+        // Test the truncation logic directly by re-creating what truncateForTts does
+        const longText = 'a'.repeat(5000);
+        const truncated = longText.slice(0, 4096);
+        expect(truncated.length).toBe(4096);
+        expect(longText.length).toBeGreaterThan(4096);
+    });
+});

package/dist/runtime/adapters/AuditRepositoryAdapter.js

@@ -0,0 +1,6 @@
+import { AuditRepository } from '../audit/repository.js';
+export class AuditRepositoryAdapter {
+    emit(event) {
+        AuditRepository.getInstance().insert(event);
+    }
+}

package/dist/runtime/adapters/ChannelNotifierAdapter.js

@@ -0,0 +1,9 @@
+import { ChannelRegistry } from '../../channels/registry.js';
+export class ChannelNotifierAdapter {
+    async sendToUser(channel, userId, text) {
+        await ChannelRegistry.sendToUser(channel, userId, text);
+    }
+    async broadcast(text) {
+        await ChannelRegistry.broadcast(text);
+    }
+}

package/dist/runtime/adapters/LangChainProviderAdapter.js

@@ -0,0 +1,9 @@
+import { ProviderFactory } from '../providers/factory.js';
+export class LangChainProviderAdapter {
+    async createBare(config, tools = []) {
+        return ProviderFactory.createBare(config, tools);
+    }
+    async create(config, tools = []) {
+        return ProviderFactory.createBare(config, tools);
+    }
+}

package/dist/runtime/adapters/SQLiteChatHistoryAdapter.js

@@ -0,0 +1,15 @@
+import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
+export class SQLiteChatHistoryAdapter {
+    async getMessages(sessionId) {
+        const history = new SQLiteChatMessageHistory({ sessionId });
+        return history.getMessages();
+    }
+    async addMessage(sessionId, message) {
+        const history = new SQLiteChatMessageHistory({ sessionId });
+        await history.addMessage(message);
+    }
+    async clear(sessionId) {
+        const history = new SQLiteChatMessageHistory({ sessionId });
+        await history.clear();
+    }
+}

package/dist/runtime/adapters/SQLiteTaskEnqueuerAdapter.js

@@ -0,0 +1,6 @@
+import { TaskRepository } from '../tasks/repository.js';
+export class SQLiteTaskEnqueuerAdapter {
+    enqueue(input) {
+        return TaskRepository.getInstance().createTask(input);
+    }
+}

package/dist/runtime/adapters/index.js

@@ -0,0 +1,5 @@
+export { ChannelNotifierAdapter } from './ChannelNotifierAdapter.js';
+export { SQLiteTaskEnqueuerAdapter } from './SQLiteTaskEnqueuerAdapter.js';
+export { SQLiteChatHistoryAdapter } from './SQLiteChatHistoryAdapter.js';
+export { LangChainProviderAdapter } from './LangChainProviderAdapter.js';
+export { AuditRepositoryAdapter } from './AuditRepositoryAdapter.js';

package/dist/runtime/audit/repository.js

@@ -1,14 +1,14 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { randomUUID } from 'crypto';
 import { DisplayManager } from '../display.js';
+import { PATHS } from '../../config/paths.js';
 export class AuditRepository {
     static instance = null;
     db;
     constructor() {
-        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        const dbPath = PATHS.shortMemoryDb;
         fs.ensureDirSync(path.dirname(dbPath));
         this.db = new Database(dbPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');
@@ -59,6 +59,10 @@ export class AuditRepository {
             DisplayManager.getInstance().log(`AuditRepository.insert failed: ${err?.message ?? String(err)}`, { source: 'Audit', level: 'error' });
         }
     }
+    countBySession(sessionId) {
+        const row = this.db.prepare(`SELECT COUNT(*) as n FROM audit_events WHERE session_id = ?`).get(sessionId);
+        return row?.n ?? 0;
+    }
     getBySession(sessionId, opts) {
         const limit = opts?.limit ?? 500;
         const offset = opts?.offset ?? 0;

package/dist/runtime/chronos/repository.js

@@ -1,9 +1,9 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { randomUUID } from 'crypto';
 import { ConfigManager } from '../../config/manager.js';
+import { PATHS } from '../../config/paths.js';
 export class ChronosError extends Error {
     constructor(message) {
         super(message);
@@ -14,7 +14,7 @@ export class ChronosRepository {
     static instance = null;
     db;
     constructor() {
-        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        const dbPath = PATHS.shortMemoryDb;
         fs.ensureDirSync(path.dirname(dbPath));
         this.db = new Database(dbPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');
@@ -62,6 +62,7 @@ export class ChronosRepository {
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0`, 'updated_at');
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_by TEXT NOT NULL DEFAULT 'api'`, 'created_by');
         addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN notify_channels TEXT NOT NULL DEFAULT '[]'`, 'notify_channels');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN origin_session_id TEXT`, 'origin_session_id');
         const execInfo = this.db.pragma('table_info(chronos_executions)');
         const execCols = new Set(execInfo.map((c) => c.name));
         const addExecCol = (sql, col) => {
@@ -107,6 +108,7 @@ export class ChronosRepository {
             updated_at: row.updated_at,
             created_by: row.created_by,
             notify_channels,
+            origin_session_id: row.origin_session_id ?? null,
         };
     }
     deserializeExecution(row) {
@@ -132,9 +134,9 @@ export class ChronosRepository {
         this.db.prepare(`
       INSERT INTO chronos_jobs (
         id, prompt, schedule_type, schedule_expression, cron_normalized,
-        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by, notify_channels
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?, ?)
-    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by, JSON.stringify(input.notify_channels ?? []));
+        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by, notify_channels, origin_session_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?, ?, ?)
+    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by, JSON.stringify(input.notify_channels ?? []), input.origin_session_id ?? null);
         return this.getJob(id);
     }
     getJob(id) {

package/dist/runtime/chronos/worker.js

@@ -4,6 +4,7 @@ import { DisplayManager } from '../display.js';
 import { parseNextRun } from './parser.js';
 import { ChannelRegistry } from '../../channels/registry.js';
 import { AuditRepository } from '../audit/repository.js';
+import { SQLiteChatMessageHistory } from '../memory/sqlite.js';
 export class ChronosWorker {
     repo;
     oracle;
@@ -74,9 +75,27 @@ export class ChronosWorker {
         const display = DisplayManager.getInstance();
         const execId = randomUUID();
         display.log(`Job ${job.id} triggered — "${job.prompt.slice(0, 60)}"`, { source: 'Chronos' });
-        // Use the currently active Oracle session so Chronos executes in the
-        // user's conversation context — no session switching or isolation needed.
-        const activeSessionId = this.oracle.getCurrentSessionId() ?? 'default';
+        // Resolve session: prefer the session where the job was originally created,
+        // fall back to Oracle's current session, then to most recent active session.
+        const tmpHistory = new SQLiteChatMessageHistory({ sessionId: 'tmp' });
+        let activeSessionId;
+        try {
+            if (job.origin_session_id && tmpHistory.isSessionUsable(job.origin_session_id)) {
+                activeSessionId = job.origin_session_id;
+            }
+            else {
+                const oracleSession = this.oracle.getCurrentSessionId();
+                if (oracleSession && tmpHistory.isSessionUsable(oracleSession)) {
+                    activeSessionId = oracleSession;
+                }
+                else {
+                    activeSessionId = tmpHistory.getMostRecentSession() ?? 'default';
+                }
+            }
+        }
+        finally {
+            tmpHistory.close();
+        }
         this.repo.insertExecution({
             id: execId,
             job_id: job.id,
@@ -96,7 +115,7 @@ export class ChronosWorker {
             const taskOriginChannel = job.notify_channels.length === 1
                 ? job.notify_channels[0]
                 : 'chronos';
-            const taskContext = { origin_channel: taskOriginChannel, session_id: activeSessionId };
+            const taskContext = { origin_channel: taskOriginChannel, session_id: activeSessionId, source: 'chronos' };
             // Hard-block Chronos management tools during execution.
             ChronosWorker.isExecuting = true;
             const chronosStartMs = Date.now();
@@ -154,6 +173,10 @@ export class ChronosWorker {
         }
         else {
             for (const ch of job.notify_channels) {
+                // 'ui' has no adapter — it works by polling session messages from the DB.
+                // The response is already persisted via oracle.chat(), so skip silently.
+                if (ch === 'ui')
+                    continue;
                 const adapter = ChannelRegistry.get(ch);
                 if (adapter) {
                     await adapter.sendMessage(text).catch((err) => {

package/dist/runtime/chronos/worker.test.js

@@ -30,6 +30,7 @@ function makeJob(overrides = {}) {
         updated_at: Date.now() - 5000,
         created_by: 'ui',
         notify_channels: [],
+        origin_session_id: null,
         ...overrides,
     };
 }
@@ -91,7 +92,7 @@ describe('ChronosWorker.tick()', () => {
         await worker.tick();
         // Wait for fire-and-forget
         await new Promise((r) => setTimeout(r, 50));
-        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt), undefined, false, expect.objectContaining({ source: 'chronos' }));
         expect(repo.disableJob).toHaveBeenCalledWith(job.id);
         expect(repo.updateJob).not.toHaveBeenCalled();
     });
@@ -102,7 +103,7 @@ describe('ChronosWorker.tick()', () => {
         const worker = new ChronosWorker(repo, oracle);
         await worker.tick();
         await new Promise((r) => setTimeout(r, 50));
-        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt), undefined, false, expect.objectContaining({ source: 'chronos' }));
         expect(repo.disableJob).not.toHaveBeenCalled();
         expect(repo.updateJob).toHaveBeenCalledWith(job.id, expect.objectContaining({ next_run_at: expect.any(Number) }));
     });

package/dist/runtime/container.js

@@ -0,0 +1,50 @@
+/**
+ * ServiceContainer — Composition Root
+ *
+ * Simple typed registry for application services (ports).
+ * Configured once at startup in start.ts. No DI framework magic —
+ * just a Map with type-safe get/register.
+ *
+ * Usage:
+ *   // Registration (start.ts):
+ *   ServiceContainer.register('notifier', new ChannelNotifierAdapter());
+ *
+ *   // Consumption:
+ *   const notifier = ServiceContainer.get<INotifier>('notifier');
+ */
+export class ServiceContainer {
+    static services = new Map();
+    /** Register a service under a given key. Overwrites if already registered. */
+    static register(key, service) {
+        ServiceContainer.services.set(key, service);
+    }
+    /**
+     * Retrieve a registered service.
+     * @throws if the key is not registered.
+     */
+    static get(key) {
+        const service = ServiceContainer.services.get(key);
+        if (service === undefined) {
+            throw new Error(`ServiceContainer: "${key}" is not registered. Did you call register() in start.ts?`);
+        }
+        return service;
+    }
+    /** Returns true if a service is registered under the given key. */
+    static has(key) {
+        return ServiceContainer.services.has(key);
+    }
+    /** Remove all registered services (useful in tests). */
+    static reset() {
+        ServiceContainer.services.clear();
+    }
+}
+/**
+ * Well-known service keys — use these constants to avoid typo bugs.
+ */
+export const SERVICE_KEYS = {
+    notifier: 'notifier',
+    taskEnqueuer: 'taskEnqueuer',
+    chatHistory: 'chatHistory',
+    providerFactory: 'providerFactory',
+    auditEmitter: 'auditEmitter',
+};

package/dist/runtime/hot-reload.js

@@ -7,9 +7,7 @@
  */
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from './display.js';
-import { Apoc } from './apoc.js';
-import { Neo } from './neo.js';
-import { Trinity } from './trinity.js';
+import { SubagentRegistry } from './subagents/registry.js';
 let currentOracle = null;
 /**
  * Register the current Oracle instance for hot-reload.
@@ -44,12 +42,11 @@ export async function hotReloadConfig() {
             reinitialized.push('Oracle');
             display.log('Oracle reinitialized with new config', { source: 'HotReload', level: 'info' });
         }
-        // 3. Reset subagent singletons - they will reinitialize with new config on next use
-        Apoc.resetInstance();
-        Neo.resetInstance();
-        Trinity.resetInstance();
-        reinitialized.push('Apoc', 'Neo', 'Trinity');
-        display.log('Subagent singletons reset (will reinitialize on next use)', { source: 'HotReload', level: 'info' });
+        // 3. Reload all registered subagents via SubagentRegistry
+        await SubagentRegistry.reloadAll();
+        const agentNames = SubagentRegistry.getAll().map(r => r.label);
+        reinitialized.push(...agentNames);
+        display.log(`Subagents reloaded: ${agentNames.join(', ')}`, { source: 'HotReload', level: 'info' });
         return {
             success: true,
             reinitialized,

package/dist/runtime/memory/backfill-embeddings.js

@@ -1,9 +1,8 @@
 import Database from 'better-sqlite3';
 import { EmbeddingService } from './embedding.service.js';
-import path from 'path';
-import { homedir } from 'os';
 import loadVecExtension from './sqlite-vec.js';
-const db = new Database(path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db'));
+import { PATHS } from '../../config/paths.js';
+const db = new Database(PATHS.satiDb);
 db.pragma('journal_mode = WAL');
 // 🔥 ISSO AQUI É O QUE ESTÁ FALTANDO
 loadVecExtension(db);

package/dist/runtime/memory/sati/repository.js

@@ -1,11 +1,11 @@
 import Database from 'better-sqlite3';
-import path from 'path';
-import { homedir } from 'os';
 import fs from 'fs-extra';
+import path from 'path';
 import { randomUUID } from 'crypto';
 import loadVecExtension from '../sqlite-vec.js';
 import { DisplayManager } from '../../display.js';
 import { ConfigManager } from '../../../config/manager.js';
+import { PATHS } from '../../../config/paths.js';
 const EMBEDDING_DIM = 384;
 export class SatiRepository {
     db = null;
@@ -14,7 +14,7 @@ export class SatiRepository {
     display = DisplayManager.getInstance();
     constructor(dbPath) {
         this.dbPath =
-            dbPath || path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
+            dbPath || PATHS.satiDb;
     }
     static getInstance(dbPath) {
         if (!SatiRepository.instance) {

package/dist/runtime/memory/sqlite.js

@@ -3,7 +3,7 @@ import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/
 import Database from "better-sqlite3";
 import fs from "fs-extra";
 import * as path from "path";
-import { homedir } from "os";
+import { PATHS } from "../../config/paths.js";
 import { randomUUID } from 'crypto';
 import { DisplayManager } from "../display.js";
 export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
@@ -22,7 +22,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         this.sessionId = fields.sessionId && fields.sessionId !== '' ? fields.sessionId : '';
         this.limit = fields.limit ? fields.limit : 20;
         // Default path: ~/.morpheus/memory/short-memory.db
-        const dbPath = fields.databasePath || path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+        const dbPath = fields.databasePath || PATHS.shortMemoryDb;
         // Ensure the directory exists
         this.ensureDirectory(dbPath);
         // Initialize database with retry logic for locked databases
@@ -847,6 +847,10 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             embedding_status = 'pending'
         WHERE id = ?
       `).run(now, now, sessionId);
+            // Remove channel/user bindings so channels don't route to an archived session
+            this.db.prepare(`
+        DELETE FROM user_channel_sessions WHERE session_id = ?
+      `).run(sessionId);
             // Exportar mensagens → texto
             const messages = this.db.prepare(`
         SELECT type, content
@@ -870,7 +874,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         const sessionText = tx(); // Executar a transação
         // Criar chunks no banco Sati — conexão aberta localmente e fechada ao fim
         if (sessionText) {
-            const dbSatiPath = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
+            const dbSatiPath = PATHS.satiDb;
             this.ensureDirectory(dbSatiPath);
             const dbSati = new Database(dbSatiPath, { timeout: 5000 });
             dbSati.pragma('journal_mode = WAL');
@@ -936,6 +940,10 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             deleted_at = ?
         WHERE id = ?
       `).run(now, sessionId);
+            // Remove channel/user bindings so channels don't route to a deleted session
+            this.db.prepare(`
+        DELETE FROM user_channel_sessions WHERE session_id = ?
+      `).run(sessionId);
         });
         tx(); // Executar a transação
     }
@@ -977,6 +985,14 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'active')").run(sessionId, Date.now());
         }
     }
+    /**
+     * Checks whether a session exists and is usable (active or paused).
+     * Returns false for deleted, archived, or non-existent sessions.
+     */
+    isSessionUsable(sessionId) {
+        const row = this.db.prepare("SELECT status FROM sessions WHERE id = ?").get(sessionId);
+        return !!row && (row.status === 'active' || row.status === 'paused');
+    }
     /**
      * Validates that the target session exists and is usable (not archived/deleted).
      * No longer swaps active↔paused — sessions are independently usable from any channel.
@@ -1015,10 +1031,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async listSessions() {
         const sessions = this.db.prepare(`
-      SELECT id, title, status, started_at
-      FROM sessions
-      WHERE status IN ('active', 'paused')
-      ORDER BY started_at DESC
+      SELECT s.id, s.title, s.status, s.started_at,
+             (SELECT MAX(m.created_at) FROM messages m WHERE m.session_id = s.id) AS last_message_at
+      FROM sessions s
+      WHERE s.status IN ('active', 'paused')
+      ORDER BY COALESCE(last_message_at, s.started_at) DESC
     `).all();
         return sessions;
     }
@@ -1028,8 +1045,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async getUserChannelSession(channel, userId) {
         const result = this.db.prepare(`
-      SELECT session_id FROM user_channel_sessions
-      WHERE channel = ? AND user_id = ?
+      SELECT ucs.session_id
+      FROM user_channel_sessions ucs
+      JOIN sessions s ON s.id = ucs.session_id
+      WHERE ucs.channel = ? AND ucs.user_id = ?
+        AND s.status IN ('active', 'paused')
     `).get(channel, userId);
         return result ? result.session_id : null;
     }
@@ -1052,8 +1072,11 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     async listUserChannelSessions(channel) {
         const rows = this.db.prepare(`
-      SELECT user_id, session_id FROM user_channel_sessions
-      WHERE channel = ?
+      SELECT ucs.user_id, ucs.session_id
+      FROM user_channel_sessions ucs
+      JOIN sessions s ON s.id = ucs.session_id
+      WHERE ucs.channel = ?
+        AND s.status IN ('active', 'paused')
     `).all(channel);
         return rows.map(row => ({ userId: row.user_id, sessionId: row.session_id }));
     }
@@ -1075,9 +1098,12 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             return null;
         const placeholders = channels.map(() => '?').join(', ');
         const result = this.db.prepare(`
-      SELECT session_id FROM user_channel_sessions
-      WHERE channel IN (${placeholders})
-      ORDER BY updated_at DESC LIMIT 1
+      SELECT ucs.session_id
+      FROM user_channel_sessions ucs
+      JOIN sessions s ON s.id = ucs.session_id
+      WHERE ucs.channel IN (${placeholders})
+        AND s.status IN ('active', 'paused')
+      ORDER BY ucs.updated_at DESC LIMIT 1
     `).get(...channels);
         return result ? result.session_id : null;
     }

package/dist/runtime/memory/trinity-db.js

@@ -1,8 +1,8 @@
 import Database from 'better-sqlite3';
 import fs from 'fs-extra';
 import path from 'path';
-import { homedir } from 'os';
 import { encrypt, decrypt, canEncrypt } from '../trinity-crypto.js';
+import { PATHS } from '../../config/paths.js';
 function safeDecrypt(value) {
     if (!value)
         return null;
@@ -39,7 +39,7 @@ export class DatabaseRegistry {
     static instance = null;
     db;
     constructor() {
-        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'trinity.db');
+        const dbPath = PATHS.trinityDb;
         fs.ensureDirSync(path.dirname(dbPath));
         this.db = new Database(dbPath, { timeout: 5000 });
         this.db.pragma('journal_mode = WAL');