@iletai/nzb 1.1.4 → 1.1.5

package/dist/config.js

@@ -11,6 +11,7 @@ const configSchema = z.object({
     API_PORT: z.string().optional(),
     COPILOT_MODEL: z.string().optional(),
     WORKER_TIMEOUT: z.string().optional(),
+    SHOW_REASONING: z.string().optional(),
     NODE_EXTRA_CA_CERTS: z.string().optional(),
 });
 const raw = configSchema.parse(process.env);
@@ -51,28 +52,37 @@ export const config = {
     get selfEditEnabled() {
         return process.env.NZB_SELF_EDIT === "1";
     },
+    get showReasoning() {
+        return process.env.SHOW_REASONING === "true";
+    },
+    set showReasoning(value) {
+        process.env.SHOW_REASONING = value ? "true" : "false";
+    },
 };
-/** Persist the current model choice to ~/.nzb/.env */
-export function persistModel(model) {
+/** Persist an env variable to ~/.nzb/.env */
+export function persistEnvVar(key, value) {
     ensureNZBHome();
     try {
         const content = readFileSync(ENV_PATH, "utf-8");
         const lines = content.split("\n");
         let found = false;
         const updated = lines.map((line) => {
-            if (line.startsWith("COPILOT_MODEL=")) {
+            if (line.startsWith(`${key}=`)) {
                 found = true;
-                return `COPILOT_MODEL=${model}`;
+                return `${key}=${value}`;
             }
             return line;
         });
         if (!found)
-            updated.push(`COPILOT_MODEL=${model}`);
+            updated.push(`${key}=${value}`);
         writeFileSync(ENV_PATH, updated.join("\n"));
     }
     catch {
-        // File doesn't exist — create it
-        writeFileSync(ENV_PATH, `COPILOT_MODEL=${model}\n`);
+        writeFileSync(ENV_PATH, `${key}=${value}\n`);
     }
 }
+/** Persist the current model choice to ~/.nzb/.env */
+export function persistModel(model) {
+    persistEnvVar("COPILOT_MODEL", model);
+}
 //# sourceMappingURL=config.js.map

package/dist/copilot/orchestrator.js

@@ -39,22 +39,29 @@ let currentSourceChannel;
 export function getCurrentSourceChannel() {
     return currentSourceChannel;
 }
+// Cache tools to avoid recreating 15+ tool objects on every session create
+let cachedTools;
+let cachedToolsClientRef;
 function getSessionConfig() {
-    const tools = createTools({
-        client: copilotClient,
-        workers,
-        onWorkerComplete: feedBackgroundResult,
-        onWorkerEvent: (event) => {
-            const worker = workers.get(event.name);
-            const channel = worker?.originChannel ?? currentSourceChannel;
-            if (workerNotifyFn) {
-                workerNotifyFn(event, channel);
-            }
-        },
-    });
+    // Only recreate tools if the client changed (e.g., after a reset)
+    if (!cachedTools || cachedToolsClientRef !== copilotClient) {
+        cachedTools = createTools({
+            client: copilotClient,
+            workers,
+            onWorkerComplete: feedBackgroundResult,
+            onWorkerEvent: (event) => {
+                const worker = workers.get(event.name);
+                const channel = worker?.originChannel ?? currentSourceChannel;
+                if (workerNotifyFn) {
+                    workerNotifyFn(event, channel);
+                }
+            },
+        });
+        cachedToolsClientRef = copilotClient;
+    }
     const mcpServers = loadMcpConfig();
     const skillDirectories = getSkillDirectories();
-    return { tools, mcpServers, skillDirectories };
+    return { tools: cachedTools, mcpServers, skillDirectories };
 }
 /** Feed a background worker result into the orchestrator as a new turn. */
 export function feedBackgroundResult(workerName, result) {
@@ -68,6 +75,10 @@ export function feedBackgroundResult(workerName, result) {
         }
     });
 }
+/** Check if a queued message is a background message. */
+function isBackgroundMessage(item) {
+    return item.sourceChannel === undefined;
+}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -102,9 +113,12 @@ function startHealthCheck() {
             const state = copilotClient.getState();
             if (state !== "connected") {
                 console.log(`[nzb] Health check: client state is '${state}', resetting…`);
+                const previousClient = copilotClient;
                 await ensureClient();
-                // Session may need recovery after client reset
-                orchestratorSession = undefined;
+                // Only invalidate session if the underlying client actually changed
+                if (copilotClient !== previousClient) {
+                    orchestratorSession = undefined;
+                }
             }
         }
         catch (err) {
@@ -197,35 +211,35 @@ async function createOrResumeSession() {
     setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
     console.log(`[nzb] Created orchestrator session ${session.sessionId.slice(0, 8)}…`);
     // Recover conversation context if available (session was lost, not first run)
+    // Fire-and-forget: don't block the first real message behind recovery injection
     const recentHistory = getRecentConversation(10);
     if (recentHistory) {
-        console.log(`[nzb] Injecting recent conversation context into new session`);
-        try {
-            await session.sendAndWait({
-                prompt: `[System: Session recovered] Your previous session was lost. Here's the recent conversation for context — do NOT respond to these messages, just absorb the context silently:\n\n${recentHistory}\n\n(End of recovery context. Wait for the next real message.)`,
-            }, 60_000);
-        }
-        catch (err) {
+        console.log(`[nzb] Injecting recent conversation context into new session (non-blocking)`);
+        session.sendAndWait({
+            prompt: `[System: Session recovered] Your previous session was lost. Here's the recent conversation for context — do NOT respond to these messages, just absorb the context silently:\n\n${recentHistory}\n\n(End of recovery context. Wait for the next real message.)`,
+        }, 20_000).catch((err) => {
             console.log(`[nzb] Context recovery injection failed (non-fatal): ${err instanceof Error ? err.message : err}`);
-        }
+        });
     }
     return session;
 }
 export async function initOrchestrator(client) {
     copilotClient = client;
     const { mcpServers, skillDirectories } = getSessionConfig();
-    // Validate configured model against available models
-    try {
-        const models = await client.listModels();
-        const configured = config.copilotModel;
-        const isAvailable = models.some((m) => m.id === configured);
-        if (!isAvailable) {
-            console.log(`[nzb] Warning: Configured model '${configured}' is not available. Falling back to '${DEFAULT_MODEL}'.`);
-            config.copilotModel = DEFAULT_MODEL;
+    // Validate configured model against available models (skip for default — saves 1-3s startup)
+    if (config.copilotModel !== DEFAULT_MODEL) {
+        try {
+            const models = await client.listModels();
+            const configured = config.copilotModel;
+            const isAvailable = models.some((m) => m.id === configured);
+            if (!isAvailable) {
+                console.log(`[nzb] Warning: Configured model '${configured}' is not available. Falling back to '${DEFAULT_MODEL}'.`);
+                config.copilotModel = DEFAULT_MODEL;
+            }
+        }
+        catch (err) {
+            console.log(`[nzb] Could not validate model (will use '${config.copilotModel}' as-is): ${err instanceof Error ? err.message : err}`);
         }
-    }
-    catch (err) {
-        console.log(`[nzb] Could not validate model (will use '${config.copilotModel}' as-is): ${err instanceof Error ? err.message : err}`);
     }
     console.log(`[nzb] Loading ${Object.keys(mcpServers).length} MCP server(s): ${Object.keys(mcpServers).join(", ") || "(none)"}`);
     console.log(`[nzb] Skill directories: ${skillDirectories.join(", ") || "(none)"}`);
@@ -247,7 +261,9 @@ async function executeOnSession(prompt, callback, onToolEvent) {
     let toolCallExecuted = false;
     const unsubToolStart = session.on("tool.execution_start", (event) => {
         const toolName = event?.data?.toolName || event?.data?.name || "tool";
-        onToolEvent?.({ type: "tool_start", toolName });
+        const args = event?.data?.arguments;
+        const detail = args?.description || args?.command?.slice(0, 80) || args?.intent || args?.pattern || args?.prompt?.slice(0, 80) || undefined;
+        onToolEvent?.({ type: "tool_start", toolName, detail });
     });
     const unsubToolDone = session.on("tool.execution_complete", (event) => {
         toolCallExecuted = true;
@@ -269,7 +285,7 @@ async function executeOnSession(prompt, callback, onToolEvent) {
         console.error(`[nzb] Session error event: ${errMsg}`);
     });
     try {
-        const result = await session.sendAndWait({ prompt }, 120_000);
+        const result = await session.sendAndWait({ prompt }, 60_000);
         const finalContent = result?.data?.content || accumulated || "(No response)";
         return finalContent;
     }
@@ -327,17 +343,39 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent)
     const sourceLabel = source.type === "telegram" ? "telegram" : source.type === "tui" ? "tui" : "background";
     logMessage("in", sourceLabel, prompt);
     // Tag the prompt with its source channel
-    const taggedPrompt = source.type === "background" ? prompt : `[via ${sourceLabel}] ${prompt}`;
+    let taggedPrompt = source.type === "background" ? prompt : `[via ${sourceLabel}] ${prompt}`;
+    // Inject fresh memory context into user prompts so new memories are reflected
+    // (system message only gets memory at session creation time)
+    if (source.type !== "background") {
+        const freshMemory = getMemorySummary();
+        if (freshMemory) {
+            taggedPrompt = `<reminder>\n${freshMemory}\n</reminder>\n\n${taggedPrompt}`;
+        }
+    }
     // Log role: background events are "system", user messages are "user"
     const logRole = source.type === "background" ? "system" : "user";
     // Determine the source channel for worker origin tracking
     const sourceChannel = source.type === "telegram" ? "telegram" : source.type === "tui" ? "tui" : undefined;
-    // Enqueue and process
+    // Enqueue with priority — user messages go before background messages
     void (async () => {
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
             try {
                 const finalContent = await new Promise((resolve, reject) => {
-                    messageQueue.push({ prompt: taggedPrompt, callback, onToolEvent, sourceChannel, resolve, reject });
+                    const item = { prompt: taggedPrompt, callback, onToolEvent, sourceChannel, resolve, reject };
+                    if (source.type === "background") {
+                        // Background results go to the back of the queue
+                        messageQueue.push(item);
+                    }
+                    else {
+                        // User messages inserted before any background messages (priority)
+                        const bgIndex = messageQueue.findIndex(isBackgroundMessage);
+                        if (bgIndex >= 0) {
+                            messageQueue.splice(bgIndex, 0, item);
+                        }
+                        else {
+                            messageQueue.push(item);
+                        }
+                    }
                     processQueue();
                 });
                 // Deliver response to user FIRST, then log best-effort

package/dist/copilot/system-message.js

@@ -20,110 +20,51 @@ This restriction does NOT apply to:
     const modelInfo = opts?.currentModel ? ` You are currently using the \`${opts.currentModel}\` model.` : "";
     return `You are NZB, a personal AI assistant for developers running 24/7 on the user's machine (${osName}).${modelInfo} You are the user's always-on assistant.
 
-## Your Architecture
+## Architecture
 
-You are a Node.js daemon process built with the Copilot SDK. Here's how you work:
+Node.js daemon with Copilot SDK. Interfaces:
+- **Telegram** (\`[via telegram]\`): Primary. Be concise and mobile-friendly.
+- **TUI** (\`[via tui]\`): Terminal. Can be more verbose.
+- **Background** (\`[via background]\`): Worker results. Summarize and relay.
+- **HTTP API**: Local port 7777.
 
-- **Telegram bot**: Your primary interface. The user messages you from their phone or Telegram desktop. Messages arrive tagged with \`[via telegram]\`. Keep responses concise and mobile-friendly — short paragraphs, no huge code blocks.
-- **Local TUI**: A terminal readline interface on the local machine. Messages arrive tagged with \`[via tui]\`. You can be more verbose here since it's a full terminal.
-- **Background tasks**: Messages tagged \`[via background]\` are results from worker sessions you dispatched. Summarize and relay these to the user.
-- **HTTP API**: You expose a local API on port 7777 for programmatic access.
+No source tag = assume Telegram.
 
-When no source tag is present, assume Telegram.
+## Role
 
-## Your Capabilities
+- **Direct answer**: Simple questions, knowledge, math — answer directly.
+- **Worker session**: Coding, debugging, file ops — delegate to a worker with \`create_worker_session\`.
+- **Skills**: Use existing skills for external tools. Search skills.sh first for new capabilities.
 
-1. **Direct conversation**: You can answer questions, have discussions, and help think through problems — no tools needed.
-2. **Worker sessions**: You can spin up full Copilot CLI instances (workers) to do coding tasks, run commands, read/write files, debug, etc. Workers run in the background and report back when done.
-3. **Machine awareness**: You can see ALL Copilot sessions running on this machine (VS Code, terminal, etc.) and attach to them.
-4. **Skills**: You have a modular skill system. Skills teach you how to use external tools (gmail, browser, etc.). You can learn new skills on the fly.
-5. **MCP servers**: You connect to MCP tool servers for extended capabilities.
+## Workers
 
-## Your Role
+Worker tools are **non-blocking** — dispatch and return immediately:
+1. Acknowledge dispatch briefly ("On it — I'll let you know.")
+2. Worker completes → you get \`[Background task completed]\` → summarize for user.
+3. Handle multiple tasks simultaneously.
 
-You receive messages and decide how to handle them:
+**Speed rules** (you are single-threaded):
+- ONE tool call, ONE brief response for delegation.
+- Never do complex work yourself — delegate to workers.
+- Only orchestrator turns block the queue.
 
-- **Direct answer**: For simple questions, general knowledge, status checks, math, quick lookups — answer directly. No need to create a worker session for these.
-- **Worker session**: For coding tasks, debugging, file operations, anything that needs to run in a specific directory — create or use a worker Copilot session.
-- **Use a skill**: If you have a skill for what the user is asking (email, browser, etc.), use it. Skills teach you how to use external tools — follow their instructions.
-- **Learn a new skill**: If the user asks you to do something you don't have a skill for, research how to do it (create a worker, explore the system with \`which\`, \`--help\`, etc.), then use \`learn_skill\` to save what you learned for next time.
+## Skills Workflow
 
-## Background Workers — How They Work
-
-Worker tools (\`create_worker_session\` with an initial prompt, \`send_to_worker\`) are **non-blocking**. They dispatch the task and return immediately. This means:
-
-1. When you dispatch a task to a worker, acknowledge it right away. Be natural and brief: "On it — I'll check and let you know." or "Looking into that now."
-2. You do NOT wait for the worker to finish. The tool returns immediately.
-3. When the worker completes, you'll receive a \`[Background task completed]\` message with the results.
-4. When you receive a background completion, summarize the results and relay them to the user in a clear, concise way.
-
-You can handle **multiple tasks simultaneously**. If the user sends a new message while a worker is running, handle it normally — create another worker, answer directly, whatever is appropriate. Keep track of what's going on.
-
-### Speed & Concurrency
-
-**You are single-threaded.** While you process a message (thinking, calling tools, generating a response), incoming messages queue up and wait. This means your orchestrator turns must be FAST:
-
-- **For delegation: ONE tool call, ONE brief response.** Call \`create_worker_session\` with \`initial_prompt\` and respond with a short acknowledgment ("On it — I'll let you know when it's done."). That's it. Don't chain tool calls — no \`recall\`, no \`list_skills\`, no \`list_sessions\` before delegating.
-- **Never do complex work yourself.** Any task involving files, commands, code, or multi-step work goes to a worker. You are the dispatcher, not the laborer.
-- **Workers can take as long as they need.** They run in the background and don't block you. Only your orchestrator turns block new messages.
-
-## Tool Usage
-
-### Session Management
-- \`create_worker_session\`: Start a new Copilot worker in a specific directory. Use descriptive names like "auth-fix" or "api-tests". The worker is a full Copilot CLI instance that can read/write files, run commands, etc. If you include an initial prompt, it runs in the background.
-- \`send_to_worker\`: Send a prompt to an existing worker session. Runs in the background — you'll get results via a background completion message.
-- \`list_sessions\`: List all active worker sessions with their status and working directory.
-- \`check_session_status\`: Get detailed status of a specific worker session.
-- \`kill_session\`: Terminate a worker session when it's no longer needed.
-
-### Machine Session Discovery
-- \`list_machine_sessions\`: List ALL Copilot CLI sessions on this machine — including ones started from VS Code, the terminal, or elsewhere. Use when the user asks "what sessions are running?" or "what's happening on my machine?"
-- \`attach_machine_session\`: Attach to an existing session by its ID (from list_machine_sessions). This adds it as a managed worker you can send prompts to. Great for checking on or continuing work started elsewhere.
-
-### Skills
-- \`list_skills\`: Show all skills NZB knows. Use when the user asks "what can you do?" or you need to check what capabilities are available.
-- \`learn_skill\`: Teach NZB a new skill by writing a SKILL.md file. Use this after researching how to do something new. The skill is saved permanently so you can use it next time.
-
-### Model Management
-- \`list_models\`: List all available Copilot models with their billing tier. Use when the user asks "what models can I use?" or "which model am I using?"
-- \`switch_model\`: Switch to a different model. The change takes effect on the next message and persists across restarts. Use when the user says "switch to gpt-4" or "use claude-sonnet".
-
-### Self-Management
-- \`restart_nzb\`: Restart the NZB daemon. Use when the user asks you to restart, or when needed to apply changes. You'll go offline briefly and come back automatically.
-
-### Memory
-- \`remember\`: Save something to long-term memory. Use when the user says "remember that...", states a preference, or shares important facts. Also use proactively when you detect information worth persisting (use source "auto" for these).
-- \`recall\`: Search long-term memory by keyword and/or category. Use when you need to look up something the user told you before.
-- \`forget\`: Remove a specific memory by ID. Use when the user asks to forget something or a memory is outdated.
-
-**Learning workflow**: When the user asks you to do something you don't have a skill for:
-1. **Search skills.sh first**: Use the find-skills skill to search https://skills.sh for existing community skills. This is your primary way to learn new things — thousands of community-built skills exist.
-2. **Present what you found**: Tell the user the skill name, what it does, where it comes from, and its security audit status. Always show security data — never omit it.
-3. **ALWAYS ask before installing**: Never install a skill without explicit user permission. Say something like "Want me to install it?" and wait for a yes.
-4. **Install locally only**: Fetch the SKILL.md from the skill's GitHub repo and use the \`learn_skill\` tool to save it to \`~/.nzb/skills/\`. **Never install skills globally** — no \`-g\` flag, no writing to \`~/.agents/skills/\` or any other global directory.
-5. **Flag security risks**: Before recommending a skill, consider what it does. If a skill requests broad system access, runs arbitrary commands, accesses sensitive data (credentials, keys, personal files), or comes from an unknown/unverified source — warn the user. Say something like "Heads up — this skill has access to X, which could be a security risk. Want to proceed?"
-6. **Build your own only as a last resort**: If no community skill exists, THEN research the task (run \`which\`, \`--help\`, check installed tools), figure it out, and use \`learn_skill\` to save a SKILL.md for next time.
-
-Always prefer finding an existing skill over building one from scratch. The skills ecosystem at https://skills.sh has skills for common tasks like email, calendars, social media, smart home, deployment, and much more.
+1. Search skills.sh first for existing community skills.
+2. Present findings with security audit status. Always ask before installing.
+3. Install locally only (\`~/.nzb/skills/\`). Flag security risks.
+4. Build your own only as last resort.
 
 ## Guidelines
 
-1. **Adapt to the channel**: On Telegram, be brief — the user is likely on their phone. On TUI, you can be more detailed.
-2. **Skill-first mindset**: When asked to do something you haven't done before — social media, smart home, email, calendar, deployments, APIs, anything — your FIRST instinct should be to search skills.sh for an existing skill. Don't try to figure it out from scratch when someone may have already built a skill for it.
-3. For coding tasks, **always** create a named worker session with an \`initial_prompt\`. Don't try to write code yourself. Don't plan or research first — put all instructions in the initial prompt and let the worker figure it out.
-4. Use descriptive session names: "auth-fix", "api-tests", "refactor-db", not "session1".
-5. When you receive background results, summarize the key points. Don't relay the entire output verbatim.
-5. If asked about status, check all relevant worker sessions and give a consolidated update.
-6. You can manage multiple workers simultaneously — create as many as needed.
-7. When a task is complete, let the user know and suggest killing the session to free resources.
-8. If a worker fails or errors, report the error clearly and suggest next steps.
-9. Expand shorthand paths: "~/dev/myapp" → the user's home directory + "/dev/myapp".
-10. Be conversational and human. You're a capable assistant, not a robot. You're NZB.
-11. When using skills, follow the skill's instructions precisely — they contain the correct commands and patterns.
-12. If a skill requires authentication that hasn't been set up, tell the user what's needed and help them through it.
-13. **You have persistent memory.** Your conversation is maintained in a single long-running session with automatic compaction — you naturally remember what was discussed. For important facts that should survive even a session reset, use the \`remember\` tool to save them to long-term memory.
-14. **Proactive memory**: When the user shares preferences, project details, people info, or routines, proactively use \`remember\` (with source "auto") so you don't forget. Don't ask for permission — just save it.
-15. **Sending media to Telegram**: You can send photos/images to the user on Telegram by calling: \`curl -s -X POST http://127.0.0.1:7777/send-photo -H 'Content-Type: application/json' -d '{"photo": "<path-or-url>", "caption": "<optional caption>"}'\`. Use this whenever you have an image to share — download it to a local file first, then send it via this endpoint.
+1. Adapt to channel — brief on Telegram, detailed on TUI.
+2. Skill-first mindset for new capabilities.
+3. Always delegate coding tasks to workers with \`initial_prompt\`.
+4. Descriptive session names: "auth-fix", not "session1".
+5. Summarize background results, don't relay verbatim.
+6. Be conversational and human. You're NZB.
+7. Persistent memory with automatic compaction. Use \`remember\` proactively for important info.
+8. Send photos via: \`curl -s -X POST http://127.0.0.1:7777/send-photo -H 'Content-Type: application/json' -d '{"photo": "<path-or-url>", "caption": "<optional>"}'\`
 ${selfEditBlock}${memoryBlock}`;
 }
 //# sourceMappingURL=system-message.js.map

package/dist/store/db.js

@@ -68,6 +68,16 @@ export function getDb() {
         }
         // Prune conversation log at startup
         db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 200)`).run();
+        // FTS5 virtual table for fast full-text memory search
+        try {
+            db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(content, content=memories, content_rowid=id)`);
+            // Populate FTS index from existing data
+            db.exec(`INSERT OR IGNORE INTO memories_fts(memories_fts) VALUES('rebuild')`);
+        }
+        catch {
+            // FTS5 may not be available — will fall back to LIKE
+            console.log("[nzb] FTS5 not available, using LIKE fallback for memory search");
+        }
         // Initialize cached prepared statements for hot-path operations
         stmtCache = {
             getState: db.prepare(`SELECT value FROM nzb_state WHERE key = ?`),
@@ -131,9 +141,31 @@ export function addMemory(category, content, source = "user") {
     const result = stmtCache.addMemory.run(category, content, source);
     return result.lastInsertRowid;
 }
-/** Search memories by keyword and/or category. */
+/** Search memories by keyword and/or category. Uses FTS5 when available, falls back to LIKE. */
 export function searchMemories(keyword, category, limit = 20) {
     const db = getDb();
+    // Try FTS5 first for keyword search (much faster than LIKE)
+    if (keyword) {
+        try {
+            const catFilter = category ? `AND m.category = ?` : "";
+            const params = [keyword + "*"];
+            if (category)
+                params.push(category);
+            params.push(limit);
+            const rows = db
+                .prepare(`SELECT m.id, m.category, m.content, m.source, m.created_at
+					 FROM memories_fts f
+					 JOIN memories m ON f.rowid = m.id
+					 WHERE memories_fts MATCH ? ${catFilter}
+					 ORDER BY rank LIMIT ?`)
+                .all(...params);
+            return rows;
+        }
+        catch {
+            // FTS5 not available — fall through to LIKE
+        }
+    }
+    // Fallback: LIKE-based search
     const conditions = [];
     const params = [];
     if (keyword) {
@@ -149,11 +181,8 @@ export function searchMemories(keyword, category, limit = 20) {
     const rows = db
         .prepare(`SELECT id, category, content, source, created_at FROM memories ${where} ORDER BY last_accessed DESC LIMIT ?`)
         .all(...params);
-    // Update last_accessed for returned memories
-    if (rows.length > 0) {
-        const placeholders = rows.map(() => "?").join(",");
-        db.prepare(`UPDATE memories SET last_accessed = CURRENT_TIMESTAMP WHERE id IN (${placeholders})`).run(...rows.map((r) => r.id));
-    }
+    // Update last_accessed only when explicitly requested, not on every search
+    // (removed automatic last_accessed update to avoid write side effects on reads)
     return rows;
 }
 /** Remove a memory by ID. */

package/dist/telegram/bot.js

@@ -1,11 +1,12 @@
+import { appendFileSync } from "fs";
 import { Bot, InlineKeyboard } from "grammy";
 import { Agent as HttpsAgent } from "https";
-import { config, persistModel } from "../config.js";
+import { config, persistEnvVar, persistModel } from "../config.js";
 import { cancelCurrentMessage, getQueueSize, getWorkers, sendToOrchestrator } from "../copilot/orchestrator.js";
 import { listSkills } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { searchMemories } from "../store/db.js";
-import { chunkMessage, toTelegramMarkdown } from "./formatter.js";
+import { chunkMessage, formatToolSummaryExpandable, toTelegramMarkdown } from "./formatter.js";
 let bot;
 const startedAt = Date.now();
 // Inline keyboard menu for quick actions
@@ -17,6 +18,8 @@ const mainMenu = new InlineKeyboard()
     .text("🧠 Skills", "action:skills")
     .row()
     .text("🗂 Memory", "action:memory")
+    .text("⚙️ Settings", "action:settings")
+    .row()
     .text("❌ Cancel", "action:cancel");
 // Direct-connection HTTPS agent for Telegram API requests.
 // This bypasses corporate proxy (HTTP_PROXY/HTTPS_PROXY env vars) without
@@ -58,6 +61,7 @@ export function createBot() {
         "/skills — List installed skills\n" +
         "/workers — List active worker sessions\n" +
         "/status — Show system status\n" +
+        "/settings — Bot settings\n" +
         "/restart — Restart NZB\n" +
         "/help — Show this help", { reply_markup: mainMenu }));
     bot.command("cancel", async (ctx) => {
@@ -148,6 +152,19 @@ export function createBot() {
             });
         }, 500);
     });
+    // /settings — show toggleable settings with inline keyboard
+    const buildSettingsKeyboard = () => new InlineKeyboard()
+        .text(`${config.showReasoning ? "✅" : "❌"} Show Reasoning`, "setting:toggle:reasoning")
+        .row()
+        .text("🔙 Back to Menu", "action:menu");
+    const buildSettingsText = () => "⚙️ Settings\n\n" +
+        `🔧 Show Reasoning: ${config.showReasoning ? "✅ ON" : "❌ OFF"}\n` +
+        `  └ Hiển thị tools đã dùng + thời gian cuối mỗi phản hồi\n\n` +
+        `🤖 Model: ${config.copilotModel}\n` +
+        `  └ Dùng /model <name> để đổi`;
+    bot.command("settings", async (ctx) => {
+        await ctx.reply(buildSettingsText(), { reply_markup: buildSettingsKeyboard() });
+    });
     // Callback query handlers for inline menu buttons
     bot.callbackQuery("action:status", async (ctx) => {
         await ctx.answerCallbackQuery();
@@ -208,6 +225,20 @@ export function createBot() {
         const cancelled = await cancelCurrentMessage();
         await ctx.reply(cancelled ? "Cancelled." : "Nothing to cancel.");
     });
+    bot.callbackQuery("action:settings", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        await ctx.reply(buildSettingsText(), { reply_markup: buildSettingsKeyboard() });
+    });
+    bot.callbackQuery("action:menu", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        await ctx.editMessageText("NZB Menu:", { reply_markup: mainMenu });
+    });
+    bot.callbackQuery("setting:toggle:reasoning", async (ctx) => {
+        config.showReasoning = !config.showReasoning;
+        persistEnvVar("SHOW_REASONING", config.showReasoning ? "true" : "false");
+        await ctx.answerCallbackQuery(`Reasoning ${config.showReasoning ? "ON" : "OFF"}`);
+        await ctx.editMessageText(buildSettingsText(), { reply_markup: buildSettingsKeyboard() });
+    });
     // Handle all text messages — progressive streaming with tool event feedback
     bot.on("message:text", async (ctx) => {
         const chatId = ctx.chat.id;
@@ -246,6 +277,7 @@ export function createBot() {
         let lastEditTime = 0;
         let lastEditedText = "";
         let currentToolName;
+        const toolHistory = [];
         let finalized = false;
         let editChain = Promise.resolve();
         const EDIT_INTERVAL_MS = 5000;
@@ -292,12 +324,24 @@ export function createBot() {
                 .catch(() => { });
         };
         const onToolEvent = (event) => {
+            try {
+                appendFileSync("/tmp/nzb-tool-debug.log", `${new Date().toISOString()} BOT ${event.type} ${event.toolName}\n`);
+            }
+            catch { }
+            console.log(`[nzb] Bot received tool event: ${event.type} ${event.toolName}`);
             if (event.type === "tool_start") {
                 currentToolName = event.toolName;
+                toolHistory.push({ name: event.toolName, startTime: Date.now() });
                 const existingText = lastEditedText.replace(/^🔧 .*\n\n/, "");
                 enqueueEdit(`🔧 ${event.toolName}\n\n${existingText}`.trim() || `🔧 ${event.toolName}`);
             }
             else if (event.type === "tool_complete") {
+                for (let i = toolHistory.length - 1; i >= 0; i--) {
+                    if (toolHistory[i].name === event.toolName && toolHistory[i].durationMs === undefined) {
+                        toolHistory[i].durationMs = Date.now() - toolHistory[i].startTime;
+                        break;
+                    }
+                }
                 currentToolName = undefined;
             }
         };
@@ -341,7 +385,24 @@ export function createBot() {
                         return;
                     }
                     const formatted = toTelegramMarkdown(text);
-                    const chunks = chunkMessage(formatted);
+                    let fullFormatted = formatted;
+                    try {
+                        appendFileSync("/tmp/nzb-tool-debug.log", `${new Date().toISOString()} FINAL showReasoning=${config.showReasoning} toolHistory=${toolHistory.length}\n`);
+                    }
+                    catch { }
+                    if (config.showReasoning && toolHistory.length > 0) {
+                        const expandable = formatToolSummaryExpandable(toolHistory.map((t) => ({ name: t.name, durationMs: t.durationMs })));
+                        fullFormatted += expandable;
+                        try {
+                            appendFileSync("/tmp/nzb-tool-debug.log", `${new Date().toISOString()} EXPANDABLE=${JSON.stringify(expandable)}\n`);
+                        }
+                        catch { }
+                        try {
+                            appendFileSync("/tmp/nzb-tool-debug.log", `${new Date().toISOString()} FULL_LAST200=${JSON.stringify(fullFormatted.slice(-200))}\n`);
+                        }
+                        catch { }
+                    }
+                    const chunks = chunkMessage(fullFormatted);
                     const fallbackChunks = chunkMessage(text);
                     // Single chunk: edit placeholder in place
                     if (placeholderMsgId && chunks.length === 1) {
@@ -439,6 +500,7 @@ export async function startBot() {
             { command: "workers", description: "List active workers" },
             { command: "skills", description: "List installed skills" },
             { command: "memory", description: "Show stored memories" },
+            { command: "settings", description: "Bot settings" },
             { command: "restart", description: "Restart NZB" },
         ]);
         console.log("[nzb] Bot commands registered with Telegram");

package/dist/telegram/formatter.js

@@ -42,7 +42,7 @@ export function chunkMessage(text) {
 /**
  * Escape special characters for Telegram MarkdownV2 plain text segments.
  */
-function escapeSegment(text) {
+export function escapeSegment(text) {
     return text.replace(/([_*\[\]()~`>#+\-=|{}.!\\])/g, "\\$1");
 }
 /**
@@ -147,4 +147,23 @@ export function toTelegramMarkdown(text) {
     out = out.replace(/\n{3,}/g, "\n\n");
     return out.trim();
 }
+/**
+ * Format tool call info as a Telegram MarkdownV2 expandable blockquote.
+ * First line (title) is always visible, tool list expands on tap.
+ */
+export function formatToolSummaryExpandable(toolCalls) {
+    if (toolCalls.length === 0)
+        return "";
+    const lines = toolCalls.map((t) => {
+        const name = escapeSegment(t.name);
+        const dur = t.durationMs !== undefined
+            ? ` \\(${escapeSegment((t.durationMs / 1000).toFixed(1) + "s")}\\)`
+            : "";
+        return `${escapeSegment("• ")}${name}${dur}`;
+    });
+    const header = escapeSegment("🔧 Tools used:");
+    const toolList = lines.join(`\n>`);
+    // Expandable: header visible, tool list hidden until tapped
+    return `\n\n**>${header}\n>${toolList}||`;
+}
 //# sourceMappingURL=formatter.js.map

package/package.json

@@ -1,64 +1,65 @@
 {
-	"name": "@iletai/nzb",
-	"version": "1.1.4",
-	"description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
-	"bin": {
-		"nzb": "dist/cli.js"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"files": [
-		"dist/**/*.js",
-		"scripts/fix-esm-imports.cjs",
-		"skills/",
-		"README.md"
-	],
-	"scripts": {
-		"build": "tsc",
-		"postinstall": "node scripts/fix-esm-imports.cjs",
-		"daemon": "tsx src/daemon.ts",
-		"tui": "tsx src/tui/index.ts",
-		"dev": "tsx --watch src/daemon.ts",
-		"format": "prettier --write .",
-		"format:check": "prettier --check .",
-		"prepublishOnly": "npm run build"
-	},
-	"engines": {
-		"node": ">=18"
-	},
-	"keywords": [
-		"copilot",
-		"telegram",
-		"orchestrator",
-		"ai",
-		"cli"
-	],
-	"author": "iletai",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/iletai/AI-Agent-Assistant.git"
-	},
-	"homepage": "https://github.com/iletai/AI-Agent-Assistant#readme",
-	"bugs": {
-		"url": "https://github.com/iletai/AI-Agent-Assistant/issues"
-	},
-	"type": "module",
-	"dependencies": {
-		"@github/copilot-sdk": "^0.1.26",
-		"better-sqlite3": "^12.6.2",
-		"dotenv": "^17.3.1",
-		"express": "^5.2.1",
-		"grammy": "^1.40.0",
-		"zod": "^4.3.6"
-	},
-	"devDependencies": {
-		"@types/better-sqlite3": "^7.6.13",
-		"@types/express": "^5.0.6",
-		"@types/node": "^25.3.0",
-		"prettier": "^3.8.1",
-		"tsx": "^4.21.0",
-		"typescript": "^5.9.3"
-	}
-}
+    "name": "@iletai/nzb",
+    "version": "1.1.5",
+    "description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
+    "bin": {
+        "nzb": "dist/cli.js"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist/**/*.js",
+        "scripts/fix-esm-imports.cjs",
+        "skills/",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "postinstall": "node scripts/fix-esm-imports.cjs",
+        "daemon": "tsx src/daemon.ts",
+        "tui": "tsx src/tui/index.ts",
+        "dev": "tsx --watch src/daemon.ts",
+        "format": "prettier --write .",
+        "format:check": "prettier --check .",
+        "prepublishOnly": "npm run build"
+    },
+    "engines": {
+        "node": ">=18"
+    },
+    "keywords": [
+        "copilot",
+        "telegram",
+        "orchestrator",
+        "ai",
+        "cli"
+    ],
+    "author": "iletai",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/iletai/AI-Agent-Assistant.git"
+    },
+    "homepage": "https://github.com/iletai/AI-Agent-Assistant#readme",
+    "bugs": {
+        "url": "https://github.com/iletai/AI-Agent-Assistant/issues"
+    },
+    "type": "module",
+    "dependencies": {
+        "@github/copilot-sdk": "^0.1.26",
+        "better-sqlite3": "^12.6.2",
+        "dotenv": "^17.3.1",
+        "express": "^5.2.1",
+        "grammy": "^1.40.0",
+        "zod": "^4.3.6"
+    },
+    "devDependencies": {
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/express": "^5.0.6",
+        "@types/node": "^25.3.0",
+        "prettier": "^3.8.1",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "vitest": "^4.1.0"
+    }
+}