morpheus-cli 0.9.0 → 0.9.3

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

@@ -97,7 +97,7 @@ export class SatiService {
                 console.warn('[SatiService] Failed to persist input log:', e);
             }
             const satiStartMs = Date.now();
-            const response = await agent.invoke({ messages }, { recursionLimit: 100 });
+            const response = await agent.invoke({ messages }, { recursionLimit: 50 });
             const satiDurationMs = Date.now() - satiStartMs;
             const lastMessage = response.messages[response.messages.length - 1];
             let content = lastMessage.content.toString();
@@ -209,6 +209,33 @@ export class SatiService {
                     display.log(`Deletion skipped — memory not found: ${deletion.id}`, { source: 'Sati', level: 'warning' });
                 }
             }
+            // Emit audit event for memory persistence results
+            const inclusionsCount = (result.inclusions ?? []).filter(i => i.summary && i.category && i.importance).length;
+            const editsCount = (result.edits ?? []).filter(e => !!e.id).length;
+            const deletionsCount = (result.deletions ?? []).filter(d => !!d.id).length;
+            const totalOps = inclusionsCount + editsCount + deletionsCount;
+            if (totalOps > 0) {
+                try {
+                    AuditRepository.getInstance().insert({
+                        session_id: userSessionId ?? 'sati-persist',
+                        event_type: 'memory_persist',
+                        agent: 'sati',
+                        duration_ms: Date.now() - satiStartMs,
+                        status: 'success',
+                        metadata: {
+                            inclusions_count: inclusionsCount,
+                            edits_count: editsCount,
+                            deletions_count: deletionsCount,
+                            inclusions: (result.inclusions ?? []).filter(i => i.summary && i.category && i.importance).map(i => ({ category: i.category, importance: i.importance, summary: i.summary })),
+                            edits: (result.edits ?? []).filter(e => !!e.id).map(e => ({ id: e.id, summary: e.summary, reason: e.reason })),
+                            deletions: (result.deletions ?? []).filter(d => !!d.id).map(d => ({ id: d.id, reason: d.reason })),
+                        },
+                    });
+                }
+                catch {
+                    console.warn('[SatiService] Failed to log memory persistence audit event');
+                }
+            }
         }
         catch (error) {
             console.error('[SatiService] Evaluation failed:', error);

package/dist/runtime/memory/session-embedding-worker.js

@@ -18,77 +18,84 @@ export async function runSessionEmbeddingWorker() {
     // 🔥 importante: carregar vec0 no DB onde existe a tabela vetorial
     loadVecExtension(satiDb);
     const embeddingService = await EmbeddingService.getInstance();
-    while (true) {
-        const sessions = shortDb.prepare(`
+    try {
+        while (true) {
+            const sessions = shortDb.prepare(`
       SELECT id
       FROM sessions
       WHERE ended_at IS NOT NULL
         AND embedding_status = 'pending'
       LIMIT ?
     `).all(BATCH_LIMIT);
-        if (sessions.length === 0) {
-            // display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
-            break;
-        }
-        for (const session of sessions) {
-            const sessionId = session.id;
-            display.log(`🧠 Processando sessão ${sessionId}...`, { source: 'SessionEmbeddingWorker' });
-            try {
-                // Skip setting 'processing' as it violates CHECK constraint
-                // active_processing.add(sessionId); // If we needed concurrency control
-                const chunks = satiDb.prepare(`
+            if (sessions.length === 0) {
+                // display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
+                break;
+            }
+            for (const session of sessions) {
+                const sessionId = session.id;
+                display.log(`🧠 Processando sessão ${sessionId}...`, { source: 'SessionEmbeddingWorker' });
+                try {
+                    // Skip setting 'processing' as it violates CHECK constraint
+                    // active_processing.add(sessionId); // If we needed concurrency control
+                    const chunks = satiDb.prepare(`
           SELECT id, content
           FROM session_chunks
           WHERE session_id = ?
           ORDER BY chunk_index
         `).all(sessionId);
-                if (chunks.length === 0) {
-                    display.log(`⚠️ Sessão ${sessionId} não possui chunks.`, { source: 'SessionEmbeddingWorker' });
-                    shortDb.prepare(`
+                    if (chunks.length === 0) {
+                        display.log(`⚠️ Sessão ${sessionId} não possui chunks.`, { source: 'SessionEmbeddingWorker' });
+                        shortDb.prepare(`
             UPDATE sessions
             SET embedding_status = 'embedded',
                 embedded = 1
             WHERE id = ?
           `).run(sessionId);
-                    continue;
-                }
-                const insertVec = satiDb.prepare(`
+                        continue;
+                    }
+                    const insertVec = satiDb.prepare(`
           INSERT INTO session_vec (embedding)
           VALUES (?)
         `);
-                const insertMap = satiDb.prepare(`
+                    const insertMap = satiDb.prepare(`
           INSERT OR REPLACE INTO session_embedding_map
           (session_chunk_id, vec_rowid)
           VALUES (?, ?)
         `);
-                for (const chunk of chunks) {
-                    display.log(`   ↳ Embedding chunk ${chunk.id}`, { source: 'SessionEmbeddingWorker' });
-                    const embedding = await embeddingService.generate(chunk.content);
-                    if (!embedding || embedding.length !== EMBEDDING_DIM) {
-                        throw new Error(`Embedding inválido. Esperado ${EMBEDDING_DIM}, recebido ${embedding?.length}`);
+                    for (const chunk of chunks) {
+                        display.log(`   ↳ Embedding chunk ${chunk.id}`, { source: 'SessionEmbeddingWorker' });
+                        const embedding = await embeddingService.generate(chunk.content);
+                        if (!embedding || embedding.length !== EMBEDDING_DIM) {
+                            throw new Error(`Embedding inválido. Esperado ${EMBEDDING_DIM}, recebido ${embedding?.length}`);
+                        }
+                        const result = insertVec.run(new Float32Array(embedding));
+                        const vecRowId = result.lastInsertRowid;
+                        insertMap.run(chunk.id, vecRowId);
                     }
-                    const result = insertVec.run(new Float32Array(embedding));
-                    const vecRowId = result.lastInsertRowid;
-                    insertMap.run(chunk.id, vecRowId);
-                }
-                // ✅ finalizar sessão
-                shortDb.prepare(`
+                    // ✅ finalizar sessão
+                    shortDb.prepare(`
           UPDATE sessions
           SET embedding_status = 'embedded',
               embedded = 1
           WHERE id = ?
         `).run(sessionId);
-                display.log(`✅ Sessão ${sessionId} embedada com sucesso.`, { source: 'SessionEmbeddingWorker' });
-            }
-            catch (err) {
-                display.log(`❌ Erro na sessão ${sessionId}: ${err}`, { source: 'SessionEmbeddingWorker' });
-                shortDb.prepare(`
+                    display.log(`✅ Sessão ${sessionId} embedada com sucesso.`, { source: 'SessionEmbeddingWorker' });
+                }
+                catch (err) {
+                    display.log(`❌ Erro na sessão ${sessionId}: ${err}`, { source: 'SessionEmbeddingWorker' });
+                    shortDb.prepare(`
           UPDATE sessions
           SET embedding_status = 'failed'
           WHERE id = ?
         `).run(sessionId);
+                }
             }
         }
     }
+    finally {
+        // Always close connections when done
+        shortDb.close();
+        satiDb.close();
+    }
     // display.log('🏁 Worker finalizado.', { source: 'SessionEmbeddingWorker' });
 }

package/dist/runtime/memory/sqlite.js

@@ -716,36 +716,19 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     }
     async createNewSession() {
         const now = Date.now();
-        // Transação para garantir consistência
-        const tx = this.db.transaction(() => {
-            // Pegar a sessão atualmente ativa
-            const activeSession = this.db.prepare(`
-        SELECT id FROM sessions
-        WHERE status = 'active'
-      `).get();
-            // Se houver uma sessão ativa, mudar seu status para 'paused'
-            if (activeSession) {
-                this.db.prepare(`
-          UPDATE sessions
-          SET status = 'paused'
-          WHERE id = ?
-        `).run(activeSession.id);
-            }
-            // Criar uma nova sessão ativa
-            const newId = randomUUID();
-            this.db.prepare(`
-        INSERT INTO sessions (
-          id,
-          started_at,
-          status
-        ) VALUES (?, ?, 'active')
-      `).run(newId, now);
-            // Atualizar o ID da sessão atual desta instância
-            this.sessionId = newId;
-            this.titleSet = false; // reset cache for new session
-        });
-        tx(); // Executar a transação
-        this.display.log('✅ Nova sessão iniciada e sessão anterior pausada', { source: 'Sati' });
+        const newId = randomUUID();
+        this.db.prepare(`
+      INSERT INTO sessions (
+        id,
+        started_at,
+        status
+      ) VALUES (?, ?, 'active')
+    `).run(newId, now);
+        // Update this instance to point to the new session
+        this.sessionId = newId;
+        this.titleSet = false;
+        this.display.log('✅ New session created', { source: 'Sati' });
+        return newId;
     }
     chunkText(text, chunkSize = 500, overlap = 50) {
         if (!text || text.length === 0)
@@ -890,27 +873,6 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
       `).run(now, sessionId);
         });
         tx(); // Executar a transação
-        // Se a sessão era active, verificar se há outra para ativar
-        if (session.status === 'active') {
-            const nextSession = this.db.prepare(`
-        SELECT id FROM sessions
-        WHERE status = 'paused'
-        ORDER BY started_at DESC
-        LIMIT 1
-      `).get();
-            if (nextSession) {
-                // Promover a próxima sessão a ativa
-                this.db.prepare(`
-          UPDATE sessions
-          SET status = 'active'
-          WHERE id = ?
-        `).run(nextSession.id);
-            }
-            else {
-                // Nenhuma outra sessão, criar nova
-                this.createFreshSession();
-            }
-        }
     }
     /**
      * Renomear uma sessão ativa ou pausada.
@@ -941,101 +903,46 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         tx(); // Executar a transação
     }
     /**
-     * Trocar o contexto ativo entre sessões não finalizadas.
-     * Validar sessão alvo: existe e status ∈ (paused, active).
-     * Se já for active, não faz nada.
-     * Transação: sessão atual active → paused, sessão alvo → active.
-     */
-    /**
-     * Creates a session row with status 'paused' if it doesn't already exist.
+     * Creates a session row with status 'active' if it doesn't already exist.
      * Safe to call multiple times — idempotent.
      */
     ensureSession(sessionId) {
         const existing = this.db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
         if (!existing) {
-            this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'paused')").run(sessionId, Date.now());
+            this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'active')").run(sessionId, Date.now());
         }
     }
+    /**
+     * Validates that the target session exists and is usable (not archived/deleted).
+     * No longer swaps active↔paused — sessions are independently usable from any channel.
+     */
     async switchSession(targetSessionId) {
-        // Validar sessão alvo: existe e status ∈ (paused, active)
         const targetSession = this.db.prepare(`
       SELECT id, status FROM sessions
       WHERE id = ?
     `).get(targetSessionId);
         if (!targetSession) {
-            throw new Error(`Sessão alvo com ID ${targetSessionId} não encontrada.`);
+            throw new Error(`Session with ID ${targetSessionId} not found.`);
         }
-        if (targetSession.status !== 'active' && targetSession.status !== 'paused') {
-            throw new Error(`Sessão alvo com ID ${targetSessionId} não está em estado ativo ou pausado. Status atual: ${targetSession.status}`);
+        if (targetSession.status === 'archived' || targetSession.status === 'deleted') {
+            throw new Error(`Session ${targetSessionId} is ${targetSession.status} and cannot be used.`);
         }
-        // Se já for active, não faz nada
-        if (targetSession.status === 'active') {
-            return; // A sessão alvo já está ativa, não precisa fazer nada
-        }
-        // Transação: sessão atual active → paused, sessão alvo → active
-        const tx = this.db.transaction(() => {
-            // Pegar a sessão atualmente ativa
-            const currentActiveSession = this.db.prepare(`
-        SELECT id FROM sessions
-        WHERE status = 'active'
-      `).get();
-            // Se houver uma sessão ativa, mudar seu status para 'paused'
-            if (currentActiveSession) {
-                this.db.prepare(`
-          UPDATE sessions
-          SET status = 'paused'
-          WHERE id = ?
-        `).run(currentActiveSession.id);
-            }
-            // Mudar o status da sessão alvo para 'active'
-            this.db.prepare(`
-        UPDATE sessions
-        SET status = 'active'
-        WHERE id = ?
-      `).run(targetSessionId);
-        });
-        tx(); // Executar a transação
     }
     /**
-     * Garantir que sempre exista uma sessão ativa válida.
-     * Buscar sessão com status = 'active', retornar seu id se existir,
-     * ou criar nova sessão (createFreshSession) e retornar o novo id.
+     * Returns the most recently created usable session, or creates one if none exist.
+     * A session is usable if its status is 'active' or 'paused' (both are equivalent post-refactor).
      */
     async getCurrentSessionOrCreate() {
-        // Buscar sessão com status = 'active'
-        const activeSession = this.db.prepare(`
-      SELECT id FROM sessions
-      WHERE status = 'active'
-    `).get();
-        if (activeSession) {
-            // Se existir, retornar seu id
-            return activeSession.id;
-        }
-        else {
-            // Se não existir, criar nova sessão (createFreshSession) e retornar o novo id
-            const newId = await this.createFreshSession();
-            return newId;
-        }
-    }
-    async createFreshSession() {
-        // Validar que não existe sessão 'active'
-        const activeSession = this.db.prepare(`
+        const session = this.db.prepare(`
       SELECT id FROM sessions
-      WHERE status = 'active'
+      WHERE status IN ('active', 'paused')
+      ORDER BY started_at DESC
+      LIMIT 1
     `).get();
-        if (activeSession) {
-            throw new Error('Já existe uma sessão ativa. Não é possível criar uma nova sessão ativa.');
+        if (session) {
+            return session.id;
         }
-        const now = Date.now();
-        const newId = randomUUID();
-        this.db.prepare(`
-    INSERT INTO sessions (
-      id,
-      started_at,
-      status
-    ) VALUES (?, ?, 'active')
-  `).run(newId, now);
-        return newId;
+        return this.createNewSession();
     }
     /**
      * Lists all active and paused sessions with their basic information.

package/dist/runtime/neo.js

@@ -137,7 +137,7 @@ ${context ? `Context:\n${context}` : ""}
             };
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 100 }));
+            const response = await TaskRequestContext.run(invokeContext, () => this.agent.invoke({ messages }, { recursionLimit: 50 }));
             const durationMs = Date.now() - startMs;
             const lastMessage = response.messages[response.messages.length - 1];
             const content = typeof lastMessage.content === "string"

package/dist/runtime/oracle.js

@@ -17,6 +17,8 @@ import { MCPManager } from "../config/mcp-manager.js";
 import { SkillRegistry, SkillExecuteTool, SkillDelegateTool, updateSkillToolDescriptions } from "./skills/index.js";
 import { SmithRegistry } from "./smiths/registry.js";
 import { AuditRepository } from "./audit/repository.js";
+import { SetupRepository } from './setup/repository.js';
+import { buildSetupTool } from './tools/setup-tool.js';
 import { emitToolAuditEvents } from "./subagent-utils.js";
 const ORACLE_DELEGATION_TOOLS = new Set([
     'apoc_delegate', 'neo_delegate', 'trinity_delegate', 'smith_delegate',
@@ -154,7 +156,10 @@ export class Oracle {
             await Trinity.refreshDelegateCatalog().catch(() => { });
             updateSkillToolDescriptions();
             // Build tool list — conditionally include SmithDelegateTool based on config
+            // Initialize setup repository (creates table if needed)
+            SetupRepository.getInstance();
             const coreTools = [
+                buildSetupTool(),
                 TaskQueryTool,
                 Neo.getInstance().createDelegateTool(),
                 Apoc.getInstance().createDelegateTool(),
@@ -208,6 +213,8 @@ export class Oracle {
         if (!this.history) {
             throw new Error("Message history not initialized. Call initialize() first.");
         }
+        // Per-call scoped history — declared outside try so finally can close it.
+        let callHistory;
         try {
             this.display.log('Processing message...', { source: 'Oracle' });
             const userMessage = new HumanMessage(message);
@@ -220,8 +227,25 @@ export class Oracle {
             if (extraUsage) {
                 userMessage.usage_metadata = extraUsage;
             }
-            const systemMessage = new SystemMessage(`
-You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
+            // Build first-time setup block if setup is not yet completed
+            const setupRepo = SetupRepository.getInstance();
+            let setupBlock = '';
+            if (!setupRepo.isCompleted()) {
+                const missingFields = setupRepo.getMissingFields();
+                if (missingFields.length > 0) {
+                    setupBlock = `## [FIRST-TIME SETUP — ACTIVE]
+Before responding to any other request, you MUST collect the user's basic information.
+Ask for the following fields conversationally (one or two at a time — do NOT list them all at once):
+${missingFields.map((f) => `- ${f}`).join('\n')}
+
+Once the user provides a value, immediately call \`setup_save\` with the collected fields.
+Do NOT proceed with other tasks until all required fields have been collected and saved.
+---
+
+`;
+                }
+            }
+            const systemMessage = new SystemMessage(`${setupBlock}You are ${this.config.agent.name}, ${this.config.agent.personality}, the Oracle.
 
 You are an orchestrator and task router.
 
@@ -347,13 +371,20 @@ bad:
 ${SkillRegistry.getInstance().getSystemPromptSection()}
 ${SmithRegistry.getInstance().getSystemPromptSection()}
 `);
+            // Resolve the authoritative session ID for this call.
+            // Priority: explicit taskContext > current history instance > fallback.
+            const currentSessionId = taskContext?.session_id
+                ?? ((this.history instanceof SQLiteChatMessageHistory) ? this.history.currentSessionId : undefined);
+            // Create a per-call scoped history so concurrent chat() calls for
+            // different sessions never interfere with each other.
+            callHistory = new SQLiteChatMessageHistory({
+                sessionId: currentSessionId ?? 'default',
+                databasePath: this.databasePath,
+                limit: this.config.llm?.context_window ?? 100,
+            });
             // Load existing history from database in reverse order (most recent first)
-            let previousMessages = await this.history.getMessages();
+            let previousMessages = await callHistory.getMessages();
             previousMessages = previousMessages.reverse();
-            // Propagate current session to Apoc so its token usage lands in the right session
-            const currentSessionId = (this.history instanceof SQLiteChatMessageHistory)
-                ? this.history.currentSessionId
-                : undefined;
             // Sati Middleware: Retrieval
             let memoryMessage = null;
             try {
@@ -395,7 +426,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
             let syncDelegationCount = 0;
             const oracleStartMs = Date.now();
             const response = await TaskRequestContext.run(invokeContext, async () => {
-                const agentResponse = await this.provider.invoke({ messages }, { recursionLimit: 100 });
+                const agentResponse = await this.provider.invoke({ messages }, { recursionLimit: 50 });
                 contextDelegationAcks = TaskRequestContext.getDelegationAcks();
                 syncDelegationCount = TaskRequestContext.getSyncDelegationCount();
                 return agentResponse;
@@ -474,8 +505,8 @@ Use it to inform your response and tool selection (if needed), but do not assume
                     ackMessage.usage_metadata = ackResult.usage_metadata;
                 }
                 // Persist with addMessage so ack-provider usage is tracked per message row.
-                await this.history.addMessage(userMessage);
-                await this.history.addMessage(ackMessage);
+                await callHistory.addMessage(userMessage);
+                await callHistory.addMessage(ackMessage);
                 // Unblock tasks for execution: the ack message is now persisted and will be
                 // returned to the caller (Telegram / UI) immediately after this point.
                 this.taskRepository.markAckSent(validDelegationAcks.map(a => a.task_id));
@@ -489,7 +520,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
                     provider: this.config.llm.provider,
                     model: this.config.llm.model,
                 };
-                await this.history.addMessages([userMessage, failureMessage]);
+                await callHistory.addMessages([userMessage, failureMessage]);
             }
             else {
                 const lastMessage = response.messages[response.messages.length - 1];
@@ -510,11 +541,11 @@ Use it to inform your response and tool selection (if needed), but do not assume
                     if (usage) {
                         failureMessage.usage_metadata = usage;
                     }
-                    await this.history.addMessages([userMessage, failureMessage]);
+                    await callHistory.addMessages([userMessage, failureMessage]);
                 }
                 else {
                     // Persist user message + all generated messages in a single transaction
-                    await this.history.addMessages([userMessage, ...newGeneratedMessages]);
+                    await callHistory.addMessages([userMessage, ...newGeneratedMessages]);
                 }
             }
             this.display.log('Response generated.', { source: 'Oracle' });
@@ -539,6 +570,9 @@ Use it to inform your response and tool selection (if needed), but do not assume
         catch (err) {
             throw new ProviderError(this.config.llm.provider, err, "Chat request failed");
         }
+        finally {
+            callHistory?.close();
+        }
     }
     async getHistory() {
         if (!this.history) {
@@ -558,53 +592,19 @@ Use it to inform your response and tool selection (if needed), but do not assume
             throw new Error("Current history provider does not support session rollover.");
         }
     }
+    /**
+     * Updates the internal history pointer to the given session.
+     * No longer mutates DB session status — sessions are independently usable from any channel.
+     * Note: chat() uses per-call callHistory scoped to taskContext.session_id,
+     * so this method is only a fallback for callers that don't pass session in taskContext.
+     */
     async setSessionId(sessionId) {
         if (!this.history) {
             throw new Error("Message history not initialized. Call initialize() first.");
         }
-        // Check if the history provider supports switching sessions
-        // SQLiteChatMessageHistory does support it via constructor (new instance) or maybe we can add a method there too?
-        // Actually SQLiteChatMessageHistory has `switchSession(targetSessionId)` but that one logic is "pause current, activate target".
-        // For API usage, we might just want to *target* a session without necessarily changing the global "active" state regarding the Daemon?
-        //
-        // However, the user request implies this is "the" chat.
-        // If we use `switchSession` it pauses others. That seems correct for a single-user agent model.
-        //
-        // But `SQLiteChatMessageHistory` properties are `sessionId`.
-        // It seems `switchSession` in `sqlite.ts` updates the DB state.
-        // We also need to update the `sessionId` property of the `SQLiteChatMessageHistory` instance held by Oracle.
-        //
-        // Let's check `SQLiteChatMessageHistory` again.
-        // It has `sessionId` property.
-        // It does NOT have a method to just update `sessionId` property without DB side effects?
-        //
-        // Use `switchSession` from `sqlite.ts` is good for "Active/Paused" state management.
-        // But we also need the `history` instance to know it is now pointing to `sessionId`.
         if (this.history instanceof SQLiteChatMessageHistory) {
-            // Logic:
-            // 1. If currently active session is different, switch.
-            // 2. Update internal sessionId.
-            // Actually `switchSession` in `sqlite.ts` takes `targetSessionId`.
-            // It updates the DB status.
-            // It DOES NOT seem to update `this.sessionId` of the instance? 
-            // Wait, let me check `sqlite.ts` content from memory or view it again alongside.
-            //
-            // In `sqlite.ts`:
-            // public async switchSession(targetSessionId: string): Promise<void> { ... }
-            // It updates DB.
-            // It DOES NOT update `this.sessionId`.
-            //
-            // So we need to ensure `this.history` points to the new session.
-            // Since `SQLiteChatMessageHistory` might not allow changing `sessionId` publicly if it's protected/private...
-            // It is `private sessionId: string;`.
-            //
-            // So simple fix: Re-instantiate `this.history`?
-            // `this.history = new SQLiteChatMessageHistory({ sessionId: sessionId, ... })`
-            //
-            // This is safe and clean.
-            // Ensure the target session exists before switching (creates as 'paused' if not found).
+            // Ensure the target session exists in DB
             this.history.ensureSession(sessionId);
-            await this.history.switchSession(sessionId);
             // Close previous connection before re-instantiating to avoid file handle leaks
             this.history.close();
             // Re-instantiate to point to new session
@@ -645,6 +645,7 @@ Use it to inform your response and tool selection (if needed), but do not assume
         await Trinity.refreshDelegateCatalog().catch(() => { });
         updateSkillToolDescriptions();
         this.provider = await ProviderFactory.create(this.config.llm, [
+            buildSetupTool(),
             TaskQueryTool,
             Neo.getInstance().createDelegateTool(),
             Apoc.getInstance().createDelegateTool(),