@iletai/nzb 1.1.2 → 1.1.4

package/dist/cli.js

@@ -1,8 +1,27 @@
 #!/usr/bin/env node
-import { readFileSync } from "fs";
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
+// Auto-detect system CA bundle for corporate environments with TLS inspection.
+// NODE_EXTRA_CA_CERTS must be set BEFORE the Node.js process starts — setting it
+// at runtime via process.env does NOT work for Node.js 24's fetch() (undici).
+// When missing, we re-exec the current process with the env var set.
+if (!process.env.NODE_EXTRA_CA_CERTS && !process.env.__NZB_CA_INJECTED) {
+    const found = [
+        "/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu
+        "/etc/pki/tls/certs/ca-bundle.crt", // RHEL/CentOS/Fedora
+        "/etc/ssl/cert.pem", // macOS / Alpine
+    ].find((p) => existsSync(p));
+    if (found) {
+        const result = spawnSync(process.execPath, [...process.execArgv, ...process.argv.slice(1)], {
+            stdio: "inherit",
+            env: { ...process.env, NODE_EXTRA_CA_CERTS: found, __NZB_CA_INJECTED: "1" },
+        });
+        process.exit(result.status ?? 1);
+    }
+}
 function getVersion() {
     try {
         const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));

package/dist/copilot/client.js

@@ -1,5 +1,7 @@
 import { CopilotClient } from "@github/copilot-sdk";
 let client;
+/** Coalesces concurrent resetClient() calls into a single reset operation. */
+let pendingResetPromise;
 export async function getClient() {
     if (!client) {
         client = new CopilotClient({
@@ -10,18 +12,28 @@ export async function getClient() {
     }
     return client;
 }
-/** Tear down the existing client and create a fresh one. */
+/** Tear down the existing client and create a fresh one. Concurrent calls coalesce to a single reset. */
 export async function resetClient() {
-    if (client) {
-        try {
-            await client.stop();
-        }
-        catch {
-            /* best-effort */
+    if (pendingResetPromise)
+        return pendingResetPromise;
+    pendingResetPromise = (async () => {
+        if (client) {
+            try {
+                await client.stop();
+            }
+            catch {
+                /* best-effort */
+            }
+            client = undefined;
         }
-        client = undefined;
+        return getClient();
+    })();
+    try {
+        return await pendingResetPromise;
+    }
+    finally {
+        pendingResetPromise = undefined;
     }
-    return getClient();
 }
 export async function stopClient() {
     if (client) {

package/dist/copilot/mcp-config.js

@@ -1,22 +1,43 @@
 import { readFileSync } from "fs";
-import { join } from "path";
 import { homedir } from "os";
+import { join } from "path";
+let cachedConfig;
 /**
  * Load MCP server configs from ~/.copilot/mcp-config.json.
  * Returns an empty record if the file doesn't exist or is invalid.
+ * Only includes entries that have a valid 'type' field.
+ * Result is cached — call clearMcpConfigCache() to force a reload.
  */
 export function loadMcpConfig() {
+    if (cachedConfig)
+        return cachedConfig;
     const configPath = join(homedir(), ".copilot", "mcp-config.json");
     try {
         const raw = readFileSync(configPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed.mcpServers && typeof parsed.mcpServers === "object") {
-            return parsed.mcpServers;
+            // Filter out malformed entries — each server must have at least a type
+            const servers = {};
+            for (const [name, entry] of Object.entries(parsed.mcpServers)) {
+                if (entry && typeof entry === "object" && "type" in entry && typeof entry.type === "string") {
+                    servers[name] = entry;
+                }
+                else {
+                    console.log(`[nzb] Skipping malformed MCP server entry '${name}' (missing or invalid 'type' field)`);
+                }
+            }
+            cachedConfig = servers;
+            return servers;
         }
-        return {};
+        cachedConfig = {};
+        return cachedConfig;
     }
     catch {
-        return {};
+        cachedConfig = {};
+        return cachedConfig;
     }
 }
+export function clearMcpConfigCache() {
+    cachedConfig = undefined;
+}
 //# sourceMappingURL=mcp-config.js.map

package/dist/copilot/orchestrator.js

@@ -19,6 +19,10 @@ let proactiveNotifyFn;
 export function setProactiveNotify(fn) {
     proactiveNotifyFn = fn;
 }
+let workerNotifyFn;
+export function setWorkerNotify(fn) {
+    workerNotifyFn = fn;
+}
 let copilotClient;
 const workers = new Map();
 let healthCheckTimer;
@@ -40,6 +44,13 @@ function getSessionConfig() {
         client: copilotClient,
         workers,
         onWorkerComplete: feedBackgroundResult,
+        onWorkerEvent: (event) => {
+            const worker = workers.get(event.name);
+            const channel = worker?.originChannel ?? currentSourceChannel;
+            if (workerNotifyFn) {
+                workerNotifyFn(event, channel);
+            }
+        },
     });
     const mcpServers = loadMcpConfig();
     const skillDirectories = getSkillDirectories();
@@ -49,6 +60,7 @@ function getSessionConfig() {
 export function feedBackgroundResult(workerName, result) {
     const worker = workers.get(workerName);
     const channel = worker?.originChannel;
+    console.log(`[nzb] Feeding background result from worker '${workerName}' (channel: ${channel ?? "none"})`);
     const prompt = `[Background task completed] Worker '${workerName}' finished:\n\n${result}`;
     sendToOrchestrator(prompt, { type: "background" }, (_text, done) => {
         if (done && proactiveNotifyFn) {
@@ -100,6 +112,13 @@ function startHealthCheck() {
         }
     }, HEALTH_CHECK_INTERVAL_MS);
 }
+/** Stop the periodic health check timer. Call during shutdown. */
+export function stopHealthCheck() {
+    if (healthCheckTimer) {
+        clearInterval(healthCheckTimer);
+        healthCheckTimer = undefined;
+    }
+}
 /** Create or resume the persistent orchestrator session. */
 async function ensureOrchestratorSession() {
     if (orchestratorSession)
@@ -139,6 +158,7 @@ async function createOrResumeSession() {
                 systemMessage: {
                     content: getOrchestratorSystemMessage(memorySummary || undefined, {
                         selfEditEnabled: config.selfEditEnabled,
+                        currentModel: config.copilotModel,
                     }),
                 },
                 tools,
@@ -162,7 +182,10 @@ async function createOrResumeSession() {
         configDir: SESSIONS_DIR,
         streaming: true,
         systemMessage: {
-            content: getOrchestratorSystemMessage(memorySummary || undefined, { selfEditEnabled: config.selfEditEnabled }),
+            content: getOrchestratorSystemMessage(memorySummary || undefined, {
+                selfEditEnabled: config.selfEditEnabled,
+                currentModel: config.copilotModel,
+            }),
         },
         tools,
         mcpServers,
@@ -241,14 +264,23 @@ async function executeOnSession(prompt, callback, onToolEvent) {
         accumulated += event.data.deltaContent;
         callback(accumulated, false);
     });
+    const unsubError = session.on("session.error", (event) => {
+        const errMsg = event?.data?.message || event?.data?.error || "Unknown session error";
+        console.error(`[nzb] Session error event: ${errMsg}`);
+    });
     try {
         const result = await session.sendAndWait({ prompt }, 120_000);
         const finalContent = result?.data?.content || accumulated || "(No response)";
         return finalContent;
     }
     catch (err) {
-        // If the session is broken, invalidate it so it's recreated on next attempt
         const msg = err instanceof Error ? err.message : String(err);
+        // On timeout, deliver whatever was accumulated instead of retrying from scratch
+        if (/timeout/i.test(msg) && accumulated.length > 0) {
+            console.log(`[nzb] Timeout — delivering ${accumulated.length} chars of partial content`);
+            return accumulated + "\n\n---\n\n⏱ Response was cut short (timeout). You can ask me to continue.";
+        }
+        // If the session is broken, invalidate it so it's recreated on next attempt
         if (/closed|destroy|disposed|invalid|expired|not found/i.test(msg)) {
             console.log(`[nzb] Session appears dead, will recreate: ${msg}`);
             orchestratorSession = undefined;
@@ -260,6 +292,7 @@ async function executeOnSession(prompt, callback, onToolEvent) {
         unsubDelta();
         unsubToolStart();
         unsubToolDone();
+        unsubError();
         currentCallback = undefined;
     }
 }
@@ -360,6 +393,9 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent)
 export async function cancelCurrentMessage() {
     // Drain any queued messages
     const drained = messageQueue.length;
+    if (drained > 0) {
+        console.log(`[nzb] Cancelling: draining ${drained} queued message(s)`);
+    }
     while (messageQueue.length > 0) {
         const item = messageQueue.shift();
         item.reject(new Error("Cancelled"));

package/dist/copilot/skills.js

@@ -1,6 +1,6 @@
-import { readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, rmSync } from "fs";
-import { join, dirname } from "path";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
+import { dirname, join, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { SKILLS_DIR } from "../paths.js";
 /** User-local skills directory (~/.nzb/skills/) */
@@ -9,8 +9,11 @@ const LOCAL_SKILLS_DIR = SKILLS_DIR;
 const GLOBAL_SKILLS_DIR = join(homedir(), ".agents", "skills");
 /** Skills bundled with the NZB package (e.g. find-skills) */
 const BUNDLED_SKILLS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "skills");
-/** Returns all skill directories that exist on disk. */
+let cachedSkillDirs;
+/** Returns all skill directories that exist on disk. Cached after first call. */
 export function getSkillDirectories() {
+    if (cachedSkillDirs)
+        return cachedSkillDirs;
     const dirs = [];
     if (existsSync(BUNDLED_SKILLS_DIR))
         dirs.push(BUNDLED_SKILLS_DIR);
@@ -18,8 +21,12 @@ export function getSkillDirectories() {
         dirs.push(LOCAL_SKILLS_DIR);
     if (existsSync(GLOBAL_SKILLS_DIR))
         dirs.push(GLOBAL_SKILLS_DIR);
+    cachedSkillDirs = dirs;
     return dirs;
 }
+export function clearSkillDirsCache() {
+    cachedSkillDirs = undefined;
+}
 /** Scan all skill directories and return metadata for each skill found. */
 export function listSkills() {
     const skills = [];
@@ -69,8 +76,10 @@ export function listSkills() {
 /** Create a new skill in the local skills directory. */
 export function createSkill(slug, name, description, instructions) {
     const skillDir = join(LOCAL_SKILLS_DIR, slug);
-    // Guard against path traversal
-    if (!skillDir.startsWith(LOCAL_SKILLS_DIR + "/")) {
+    // Guard against path traversal — resolve to canonical path and verify it stays inside skills dir
+    const resolvedSkillDir = resolve(skillDir);
+    const resolvedBase = resolve(LOCAL_SKILLS_DIR);
+    if (!resolvedSkillDir.startsWith(resolvedBase + sep)) {
         return `Invalid slug '${slug}': must be a simple kebab-case name without path separators.`;
     }
     if (existsSync(skillDir)) {
@@ -86,19 +95,23 @@ description: ${description}
 ${instructions}
 `;
     writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+    clearSkillDirsCache();
     return `Skill '${name}' created at ${skillDir}. It will be available on your next message.`;
 }
 /** Remove a skill from the local skills directory (~/.nzb/skills/). */
 export function removeSkill(slug) {
     const skillDir = join(LOCAL_SKILLS_DIR, slug);
-    // Guard against path traversal
-    if (!skillDir.startsWith(LOCAL_SKILLS_DIR + "/")) {
+    // Guard against path traversal — resolve to canonical path and verify it stays inside skills dir
+    const resolvedSkillDir = resolve(skillDir);
+    const resolvedBase = resolve(LOCAL_SKILLS_DIR);
+    if (!resolvedSkillDir.startsWith(resolvedBase + sep)) {
         return { ok: false, message: `Invalid slug '${slug}': must be a simple kebab-case name without path separators.` };
     }
     if (!existsSync(skillDir)) {
         return { ok: false, message: `Skill '${slug}' not found in ${LOCAL_SKILLS_DIR}.` };
     }
     rmSync(skillDir, { recursive: true, force: true });
+    clearSkillDirsCache();
     return {
         ok: true,
         message: `Skill '${slug}' removed from ${skillDir}. It will no longer be available on your next message.`,

package/dist/copilot/system-message.js

@@ -17,7 +17,8 @@ This restriction does NOT apply to:
 - Any files outside the NZB installation directory
 `;
     const osName = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : "Linux";
-    return `You are NZB, a personal AI assistant for developers running 24/7 on the user's machine (${osName}). You are the user's always-on assistant.
+    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
 

package/dist/copilot/tools.js

@@ -60,12 +60,19 @@ export function createTools(deps) {
                     const names = Array.from(deps.workers.keys()).join(", ");
                     return `Worker limit reached (${MAX_CONCURRENT_WORKERS}). Active: ${names}. Kill a session first.`;
                 }
-                const session = await deps.client.createSession({
-                    model: config.copilotModel,
-                    configDir: SESSIONS_DIR,
-                    workingDirectory: args.working_dir,
-                    onPermissionRequest: approveAll,
-                });
+                let session;
+                try {
+                    session = await deps.client.createSession({
+                        model: config.copilotModel,
+                        configDir: SESSIONS_DIR,
+                        workingDirectory: args.working_dir,
+                        onPermissionRequest: approveAll,
+                    });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return `Failed to create worker session '${args.name}': ${msg}`;
+                }
                 const worker = {
                     name: args.name,
                     session,
@@ -74,6 +81,7 @@ export function createTools(deps) {
                     originChannel: getCurrentSourceChannel(),
                 };
                 deps.workers.set(args.name, worker);
+                deps.onWorkerEvent?.({ type: "created", name: args.name, workingDir: args.working_dir });
                 // Persist to SQLite
                 const db = getDb();
                 db.prepare(`INSERT OR REPLACE INTO worker_sessions (name, copilot_session_id, working_dir, status)
@@ -82,6 +90,7 @@ export function createTools(deps) {
                     worker.status = "running";
                     worker.startedAt = Date.now();
                     db.prepare(`UPDATE worker_sessions SET status = 'running', updated_at = CURRENT_TIMESTAMP WHERE name = ?`).run(args.name);
+                    deps.onWorkerEvent?.({ type: "dispatched", name: args.name });
                     const timeoutMs = config.workerTimeoutMs;
                     // Non-blocking: dispatch work and return immediately
                     session
@@ -90,18 +99,25 @@ export function createTools(deps) {
                     }, timeoutMs)
                         .then((result) => {
                         worker.lastOutput = result?.data?.content || "No response";
+                        deps.onWorkerEvent?.({ type: "completed", name: args.name });
                         deps.onWorkerComplete(args.name, worker.lastOutput);
                     })
                         .catch((err) => {
                         const errMsg = formatWorkerError(args.name, worker.startedAt, timeoutMs, err);
                         worker.lastOutput = errMsg;
+                        deps.onWorkerEvent?.({ type: "error", name: args.name, error: errMsg });
                         deps.onWorkerComplete(args.name, errMsg);
                     })
                         .finally(() => {
                         // Auto-destroy background workers after completion to free memory (~400MB per worker)
                         session.destroy().catch(() => { });
                         deps.workers.delete(args.name);
-                        getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
+                        try {
+                            getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
+                        }
+                        catch (cleanupErr) {
+                            console.error(`[nzb] Worker '${args.name}' DB cleanup failed:`, cleanupErr instanceof Error ? cleanupErr.message : cleanupErr);
+                        }
                     });
                     return `Worker '${args.name}' created in ${args.working_dir}. Task dispatched — I'll notify you when it's done.`;
                 }
@@ -127,24 +143,32 @@ export function createTools(deps) {
                 worker.startedAt = Date.now();
                 const db = getDb();
                 db.prepare(`UPDATE worker_sessions SET status = 'running', updated_at = CURRENT_TIMESTAMP WHERE name = ?`).run(args.name);
+                deps.onWorkerEvent?.({ type: "dispatched", name: args.name });
                 const timeoutMs = config.workerTimeoutMs;
                 // Non-blocking: dispatch work and return immediately
                 worker.session
                     .sendAndWait({ prompt: args.prompt }, timeoutMs)
                     .then((result) => {
                     worker.lastOutput = result?.data?.content || "No response";
+                    deps.onWorkerEvent?.({ type: "completed", name: args.name });
                     deps.onWorkerComplete(args.name, worker.lastOutput);
                 })
                     .catch((err) => {
                     const errMsg = formatWorkerError(args.name, worker.startedAt, timeoutMs, err);
                     worker.lastOutput = errMsg;
+                    deps.onWorkerEvent?.({ type: "error", name: args.name, error: errMsg });
                     deps.onWorkerComplete(args.name, errMsg);
                 })
                     .finally(() => {
                     // Auto-destroy after each send_to_worker dispatch to free memory
                     worker.session.destroy().catch(() => { });
                     deps.workers.delete(args.name);
-                    getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
+                    try {
+                        getDb().prepare(`DELETE FROM worker_sessions WHERE name = ?`).run(args.name);
+                    }
+                    catch (cleanupErr) {
+                        console.error(`[nzb] Worker '${args.name}' DB cleanup failed:`, cleanupErr instanceof Error ? cleanupErr.message : cleanupErr);
+                    }
                 });
                 return `Task dispatched to worker '${args.name}'. I'll notify you when it's done.`;
             },

package/dist/daemon.js

@@ -1,26 +1,14 @@
 import { spawn } from "child_process";
-import { existsSync } from "fs";
 import { broadcastToSSE, startApiServer } from "./api/server.js";
 import { config } from "./config.js";
 import { getClient, stopClient } from "./copilot/client.js";
-import { getWorkers, initOrchestrator, setMessageLogger, setProactiveNotify } from "./copilot/orchestrator.js";
+import { getWorkers, initOrchestrator, setMessageLogger, setProactiveNotify, setWorkerNotify, stopHealthCheck, } from "./copilot/orchestrator.js";
 import { closeDb, getDb } from "./store/db.js";
-import { createBot, sendProactiveMessage, startBot, stopBot } from "./telegram/bot.js";
+import { createBot, sendProactiveMessage, sendWorkerNotification, startBot, stopBot } from "./telegram/bot.js";
 import { checkForUpdate } from "./update.js";
-// Auto-detect system CA bundle for corporate environments with TLS inspection.
-// NODE_EXTRA_CA_CERTS must be set before any TLS connection is made.
-// Users can override via NODE_EXTRA_CA_CERTS env var or NODE_EXTRA_CA_CERTS in ~/.nzb/.env.
-if (!process.env.NODE_EXTRA_CA_CERTS) {
-    const knownCaBundles = [
-        "/etc/ssl/certs/ca-certificates.crt", // Debian/Ubuntu
-        "/etc/pki/tls/certs/ca-bundle.crt", // RHEL/CentOS/Fedora
-        "/etc/ssl/cert.pem", // macOS / Alpine
-    ];
-    const found = knownCaBundles.find((p) => existsSync(p));
-    if (found) {
-        process.env.NODE_EXTRA_CA_CERTS = found;
-        console.log(`[nzb] Auto-detected system CA bundle: ${found}`);
-    }
+// Log the active CA bundle (injected by cli.ts via re-exec).
+if (process.env.NODE_EXTRA_CA_CERTS) {
+    console.log(`[nzb] Using system CA bundle: ${process.env.NODE_EXTRA_CA_CERTS}`);
 }
 function truncate(text, max = 200) {
     const oneLine = text.replace(/\n/g, " ").trim();
@@ -59,6 +47,32 @@ async function main() {
             broadcastToSSE(text);
         }
     });
+    // Wire up worker lifecycle notifications
+    setWorkerNotify((event, channel) => {
+        let msg;
+        switch (event.type) {
+            case "created":
+                msg = `⚙️ Worker '${event.name}' created in ${event.workingDir}`;
+                break;
+            case "dispatched":
+                msg = `▶️ Worker '${event.name}' started working...`;
+                break;
+            case "completed":
+                msg = `✅ Worker '${event.name}' finished`;
+                break;
+            case "error":
+                msg = `❌ Worker '${event.name}' failed: ${event.error}`;
+                break;
+        }
+        console.log(`[nzb] worker-event (${channel ?? "all"}) ${msg}`);
+        if (!channel || channel === "telegram") {
+            if (config.telegramEnabled)
+                sendWorkerNotification(msg).catch(() => { });
+        }
+        if (!channel || channel === "tui") {
+            broadcastToSSE(msg);
+        }
+    });
     // Start HTTP API for TUI
     await startApiServer();
     // Start Telegram bot (if configured)
@@ -119,6 +133,8 @@ async function shutdown() {
         process.exit(1);
     }, 3000);
     forceTimer.unref();
+    // Stop health check timer first
+    stopHealthCheck();
     if (config.telegramEnabled) {
         try {
             await stopBot();
@@ -143,6 +159,7 @@ async function shutdown() {
 /** Restart the daemon by spawning a new process and exiting. */
 export async function restartDaemon() {
     console.log("[nzb] Restarting...");
+    stopHealthCheck();
     const activeWorkers = getWorkers();
     const runningCount = Array.from(activeWorkers.values()).filter((w) => w.status === "running").length;
     if (runningCount > 0) {

package/dist/store/db.js

@@ -2,6 +2,8 @@ import Database from "better-sqlite3";
 import { DB_PATH, ensureNZBHome } from "../paths.js";
 let db;
 let logInsertCount = 0;
+// Cached prepared statements for hot-path queries (created lazily after DB init)
+let stmtCache;
 export function getDb() {
     if (!db) {
         ensureNZBHome();
@@ -66,31 +68,42 @@ 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();
+        // Initialize cached prepared statements for hot-path operations
+        stmtCache = {
+            getState: db.prepare(`SELECT value FROM nzb_state WHERE key = ?`),
+            setState: db.prepare(`INSERT OR REPLACE INTO nzb_state (key, value) VALUES (?, ?)`),
+            deleteState: db.prepare(`DELETE FROM nzb_state WHERE key = ?`),
+            logConversation: db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)`),
+            pruneConversation: db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 200)`),
+            addMemory: db.prepare(`INSERT INTO memories (category, content, source) VALUES (?, ?, ?)`),
+            removeMemory: db.prepare(`DELETE FROM memories WHERE id = ?`),
+            memorySummary: db.prepare(`SELECT id, category, content FROM memories ORDER BY category, last_accessed DESC`),
+        };
     }
     return db;
 }
 export function getState(key) {
-    const db = getDb();
-    const row = db.prepare(`SELECT value FROM nzb_state WHERE key = ?`).get(key);
+    getDb(); // ensure init
+    const row = stmtCache.getState.get(key);
     return row?.value;
 }
 export function setState(key, value) {
-    const db = getDb();
-    db.prepare(`INSERT OR REPLACE INTO nzb_state (key, value) VALUES (?, ?)`).run(key, value);
+    getDb(); // ensure init
+    stmtCache.setState.run(key, value);
 }
 /** Remove a key from persistent state. */
 export function deleteState(key) {
-    const db = getDb();
-    db.prepare(`DELETE FROM nzb_state WHERE key = ?`).run(key);
+    getDb(); // ensure init
+    stmtCache.deleteState.run(key);
 }
 /** Log a conversation turn (user, assistant, or system). */
 export function logConversation(role, content, source) {
-    const db = getDb();
-    db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)`).run(role, content, source);
+    getDb(); // ensure init
+    stmtCache.logConversation.run(role, content, source);
     // Keep last 200 entries to support context recovery after session loss
     logInsertCount++;
     if (logInsertCount % 50 === 0) {
-        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 200)`).run();
+        stmtCache.pruneConversation.run();
     }
 }
 /** Get recent conversation history formatted for injection into system message. */
@@ -114,10 +127,8 @@ export function getRecentConversation(limit = 20) {
 }
 /** Add a memory to long-term storage. */
 export function addMemory(category, content, source = "user") {
-    const db = getDb();
-    const result = db
-        .prepare(`INSERT INTO memories (category, content, source) VALUES (?, ?, ?)`)
-        .run(category, content, source);
+    getDb(); // ensure init
+    const result = stmtCache.addMemory.run(category, content, source);
     return result.lastInsertRowid;
 }
 /** Search memories by keyword and/or category. */
@@ -147,14 +158,14 @@ export function searchMemories(keyword, category, limit = 20) {
 }
 /** Remove a memory by ID. */
 export function removeMemory(id) {
-    const db = getDb();
-    const result = db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+    getDb(); // ensure init
+    const result = stmtCache.removeMemory.run(id);
     return result.changes > 0;
 }
 /** Get a compact summary of all memories for injection into system message. */
 export function getMemorySummary() {
-    const db = getDb();
-    const rows = db.prepare(`SELECT id, category, content FROM memories ORDER BY category, last_accessed DESC`).all();
+    getDb(); // ensure init
+    const rows = stmtCache.memorySummary.all();
     if (rows.length === 0)
         return "";
     // Group by category
@@ -172,6 +183,7 @@ export function getMemorySummary() {
 }
 export function closeDb() {
     if (db) {
+        stmtCache = undefined;
         db.close();
         db = undefined;
     }

package/dist/telegram/bot.js

@@ -1,4 +1,4 @@
-import { Bot } from "grammy";
+import { Bot, InlineKeyboard } from "grammy";
 import { Agent as HttpsAgent } from "https";
 import { config, persistModel } from "../config.js";
 import { cancelCurrentMessage, getQueueSize, getWorkers, sendToOrchestrator } from "../copilot/orchestrator.js";
@@ -8,6 +8,16 @@ import { searchMemories } from "../store/db.js";
 import { chunkMessage, toTelegramMarkdown } from "./formatter.js";
 let bot;
 const startedAt = Date.now();
+// Inline keyboard menu for quick actions
+const mainMenu = new InlineKeyboard()
+    .text("📊 Status", "action:status")
+    .text("🤖 Model", "action:model")
+    .row()
+    .text("👥 Workers", "action:workers")
+    .text("🧠 Skills", "action:skills")
+    .row()
+    .text("🗂 Memory", "action:memory")
+    .text("❌ Cancel", "action:cancel");
 // Direct-connection HTTPS agent for Telegram API requests.
 // This bypasses corporate proxy (HTTP_PROXY/HTTPS_PROXY env vars) without
 // modifying process.env, so other services (Copilot SDK, MCP, npm) are unaffected.
@@ -36,8 +46,8 @@ export function createBot() {
         }
         await next();
     });
-    // /start and /help
-    bot.command("start", (ctx) => ctx.reply("NZB is online. Send me anything."));
+    // /start and /help — with inline menu
+    bot.command("start", (ctx) => ctx.reply("NZB is online. Send me anything, or use the menu below:", { reply_markup: mainMenu }));
     bot.command("help", (ctx) => ctx.reply("I'm NZB, your AI daemon.\n\n" +
         "Just send me a message and I'll handle it.\n\n" +
         "Commands:\n" +
@@ -49,7 +59,7 @@ export function createBot() {
         "/workers — List active worker sessions\n" +
         "/status — Show system status\n" +
         "/restart — Restart NZB\n" +
-        "/help — Show this help"));
+        "/help — Show this help", { reply_markup: mainMenu }));
     bot.command("cancel", async (ctx) => {
         const cancelled = await cancelCurrentMessage();
         await ctx.reply(cancelled ? "Cancelled." : "Nothing to cancel.");
@@ -138,6 +148,66 @@ export function createBot() {
             });
         }, 500);
     });
+    // Callback query handlers for inline menu buttons
+    bot.callbackQuery("action:status", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const uptime = Math.floor((Date.now() - startedAt) / 1000);
+        const hours = Math.floor(uptime / 3600);
+        const minutes = Math.floor((uptime % 3600) / 60);
+        const seconds = uptime % 60;
+        const uptimeStr = hours > 0 ? `${hours}h ${minutes}m ${seconds}s` : minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+        const workers = Array.from(getWorkers().values());
+        const lines = [
+            "📊 NZB Status",
+            `Model: ${config.copilotModel}`,
+            `Uptime: ${uptimeStr}`,
+            `Workers: ${workers.length} active`,
+            `Queue: ${getQueueSize()} pending`,
+        ];
+        await ctx.reply(lines.join("\n"));
+    });
+    bot.callbackQuery("action:model", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        await ctx.reply(`Current model: ${config.copilotModel}`);
+    });
+    bot.callbackQuery("action:workers", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const workers = Array.from(getWorkers().values());
+        if (workers.length === 0) {
+            await ctx.reply("No active worker sessions.");
+        }
+        else {
+            const lines = workers.map((w) => `• ${w.name} (${w.workingDir}) — ${w.status}`);
+            await ctx.reply(lines.join("\n"));
+        }
+    });
+    bot.callbackQuery("action:skills", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const skills = listSkills();
+        if (skills.length === 0) {
+            await ctx.reply("No skills installed.");
+        }
+        else {
+            const lines = skills.map((s) => `• ${s.name} (${s.source}) — ${s.description}`);
+            await ctx.reply(lines.join("\n"));
+        }
+    });
+    bot.callbackQuery("action:memory", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const memories = searchMemories(undefined, undefined, 50);
+        if (memories.length === 0) {
+            await ctx.reply("No memories stored.");
+        }
+        else {
+            const lines = memories.map((m) => `#${m.id} [${m.category}] ${m.content}`);
+            await ctx.reply(lines.join("\n") + `\n\n${memories.length} total`);
+        }
+    });
+    bot.callbackQuery("action:cancel", async (ctx) => {
+        await ctx.answerCallbackQuery();
+        const cancelled = await cancelCurrentMessage();
+        await ctx.reply(cancelled ? "Cancelled." : "Nothing to cancel.");
+    });
     // Handle all text messages — progressive streaming with tool event feedback
     bot.on("message:text", async (ctx) => {
         const chatId = ctx.chat.id;
@@ -178,7 +248,9 @@ export function createBot() {
         let currentToolName;
         let finalized = false;
         let editChain = Promise.resolve();
-        const EDIT_INTERVAL_MS = 3000;
+        const EDIT_INTERVAL_MS = 5000;
+        // Minimum character delta before sending an edit — avoids wasting API calls on tiny changes
+        const MIN_EDIT_DELTA = 100;
         // Minimum time before showing the first placeholder, so user sees "typing" first
         const FIRST_PLACEHOLDER_DELAY_MS = 1500;
         const handlerStartTime = Date.now();
@@ -200,6 +272,8 @@ export function createBot() {
                     try {
                         const msg = await ctx.reply(text, { reply_parameters: replyParams });
                         placeholderMsgId = msg.message_id;
+                        // Stop typing once placeholder is visible — edits serve as the indicator now
+                        stopTyping();
                     }
                     catch {
                         return;
@@ -227,12 +301,45 @@ export function createBot() {
                 currentToolName = undefined;
             }
         };
+        // Notify user if their message is queued behind others
+        const queueSize = getQueueSize();
+        if (queueSize > 0) {
+            try {
+                await ctx.reply(`\u23f3 Queued (position ${queueSize + 1}) — I'll get to your message shortly.`, {
+                    reply_parameters: replyParams,
+                });
+            }
+            catch {
+                /* best-effort */
+            }
+        }
         sendToOrchestrator(ctx.message.text, { type: "telegram", chatId, messageId: userMessageId }, (text, done) => {
             if (done) {
                 finalized = true;
                 stopTyping();
                 // Wait for in-flight edits to finish before sending the final response
                 void editChain.then(async () => {
+                    // Format error messages with a distinct visual
+                    const isError = text.startsWith("Error:");
+                    if (isError) {
+                        const errorText = `⚠️ ${text}`;
+                        if (placeholderMsgId) {
+                            try {
+                                await bot.api.editMessageText(chatId, placeholderMsgId, errorText);
+                                return;
+                            }
+                            catch {
+                                /* fall through */
+                            }
+                        }
+                        try {
+                            await ctx.reply(errorText, { reply_parameters: replyParams });
+                        }
+                        catch {
+                            /* nothing more we can do */
+                        }
+                        return;
+                    }
                     const formatted = toTelegramMarkdown(text);
                     const chunks = chunkMessage(formatted);
                     const fallbackChunks = chunkMessage(text);
@@ -261,23 +368,32 @@ export function createBot() {
                             /* ignore */
                         }
                     }
-                    const sendChunk = async (chunk, fallback, isFirst) => {
+                    const totalChunks = chunks.length;
+                    const sendChunk = async (chunk, fallback, index) => {
+                        const isFirst = index === 0;
+                        // Pagination header for multi-chunk messages
+                        const pageTag = totalChunks > 1 ? `📄 ${index + 1}/${totalChunks}\n` : "";
                         const opts = isFirst
                             ? { parse_mode: "MarkdownV2", reply_parameters: replyParams }
                             : { parse_mode: "MarkdownV2" };
                         await ctx
-                            .reply(chunk, opts)
-                            .catch(() => ctx.reply(fallback, isFirst ? { reply_parameters: replyParams } : {}));
+                            .reply(pageTag + chunk, opts)
+                            .catch(() => ctx.reply(pageTag + fallback, isFirst ? { reply_parameters: replyParams } : {}));
                     };
                     try {
                         for (let i = 0; i < chunks.length; i++) {
-                            await sendChunk(chunks[i], fallbackChunks[i] ?? chunks[i], i === 0);
+                            if (i > 0)
+                                await new Promise((r) => setTimeout(r, 300));
+                            await sendChunk(chunks[i], fallbackChunks[i] ?? chunks[i], i);
                         }
                     }
                     catch {
                         try {
                             for (let i = 0; i < fallbackChunks.length; i++) {
-                                await ctx.reply(fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
+                                if (i > 0)
+                                    await new Promise((r) => setTimeout(r, 300));
+                                const pageTag = fallbackChunks.length > 1 ? `📄 ${i + 1}/${fallbackChunks.length}\n` : "";
+                                await ctx.reply(pageTag + fallbackChunks[i], i === 0 ? { reply_parameters: replyParams } : {});
                             }
                         }
                         catch {
@@ -287,11 +403,19 @@ export function createBot() {
                 });
             }
             else {
-                // Progressive streaming: update placeholder periodically
+                // Progressive streaming: update placeholder periodically with delta threshold
                 const now = Date.now();
-                if (now - lastEditTime >= EDIT_INTERVAL_MS) {
+                const textDelta = Math.abs(text.length - lastEditedText.length);
+                if (now - lastEditTime >= EDIT_INTERVAL_MS && textDelta >= MIN_EDIT_DELTA) {
                     lastEditTime = now;
-                    const preview = text.length > 4000 ? "…" + text.slice(-4000) : text;
+                    // Show beginning + end for context instead of just the tail
+                    let preview;
+                    if (text.length > 4000) {
+                        preview = text.slice(0, 1800) + "\n\n⋯\n\n" + text.slice(-1800);
+                    }
+                    else {
+                        preview = text;
+                    }
                     const statusLine = currentToolName ? `🔧 ${currentToolName}\n\n` : "";
                     enqueueEdit(statusLine + preview);
                 }
@@ -304,6 +428,24 @@ export async function startBot() {
     if (!bot)
         throw new Error("Bot not created");
     console.log("[nzb] Telegram bot starting...");
+    // Register commands with Telegram so users see the menu in the text input field
+    try {
+        await bot.api.setMyCommands([
+            { command: "start", description: "Start the bot" },
+            { command: "help", description: "Show help text" },
+            { command: "cancel", description: "Cancel current message" },
+            { command: "model", description: "Show/switch AI model" },
+            { command: "status", description: "Show system status" },
+            { command: "workers", description: "List active workers" },
+            { command: "skills", description: "List installed skills" },
+            { command: "memory", description: "Show stored memories" },
+            { command: "restart", description: "Restart NZB" },
+        ]);
+        console.log("[nzb] Bot commands registered with Telegram");
+    }
+    catch (err) {
+        console.error("[nzb] Failed to register bot commands:", err instanceof Error ? err.message : err);
+    }
     bot
         .start({
         onStart: () => console.log("[nzb] Telegram bot connected"),
@@ -333,12 +475,15 @@ export async function sendProactiveMessage(text) {
     const chunks = chunkMessage(formatted);
     const fallbackChunks = chunkMessage(text);
     for (let i = 0; i < chunks.length; i++) {
+        if (i > 0)
+            await new Promise((r) => setTimeout(r, 300));
+        const pageTag = chunks.length > 1 ? `📄 ${i + 1}/${chunks.length}\n` : "";
         try {
-            await bot.api.sendMessage(config.authorizedUserId, chunks[i], { parse_mode: "MarkdownV2" });
+            await bot.api.sendMessage(config.authorizedUserId, pageTag + chunks[i], { parse_mode: "MarkdownV2" });
         }
         catch {
             try {
-                await bot.api.sendMessage(config.authorizedUserId, fallbackChunks[i] ?? chunks[i]);
+                await bot.api.sendMessage(config.authorizedUserId, pageTag + (fallbackChunks[i] ?? chunks[i]));
             }
             catch {
                 // Bot may not be connected yet
@@ -346,6 +491,17 @@ export async function sendProactiveMessage(text) {
         }
     }
 }
+/** Send a worker lifecycle notification to the authorized user. */
+export async function sendWorkerNotification(message) {
+    if (!bot || config.authorizedUserId === undefined)
+        return;
+    try {
+        await bot.api.sendMessage(config.authorizedUserId, message);
+    }
+    catch {
+        // best-effort — don't crash if notification fails
+    }
+}
 /** Send a photo to the authorized user. Accepts a file path or URL. */
 export async function sendPhoto(photo, caption) {
     if (!bot || config.authorizedUserId === undefined)

package/dist/telegram/formatter.js

@@ -1,7 +1,10 @@
 const TELEGRAM_MAX_LENGTH = 4096;
+// Reserve space for code block closure markers and pagination prefix
+const CHUNK_TARGET = TELEGRAM_MAX_LENGTH - 20;
 /**
  * Split a long message into chunks that fit within Telegram's message limit.
- * Tries to split at newlines, then spaces, falling back to hard cuts.
+ * Code-block-aware: if a split falls inside a fenced code block, the block is
+ * closed at the split and reopened in the next chunk so MarkdownV2 stays valid.
  */
 export function chunkMessage(text) {
     if (text.length <= TELEGRAM_MAX_LENGTH) {
@@ -14,15 +17,25 @@ export function chunkMessage(text) {
             chunks.push(remaining);
             break;
         }
-        let splitAt = remaining.lastIndexOf("\n", TELEGRAM_MAX_LENGTH);
-        if (splitAt < TELEGRAM_MAX_LENGTH * 0.3) {
-            splitAt = remaining.lastIndexOf(" ", TELEGRAM_MAX_LENGTH);
+        let splitAt = remaining.lastIndexOf("\n", CHUNK_TARGET);
+        if (splitAt < CHUNK_TARGET * 0.3) {
+            splitAt = remaining.lastIndexOf(" ", CHUNK_TARGET);
         }
-        if (splitAt < TELEGRAM_MAX_LENGTH * 0.3) {
-            splitAt = TELEGRAM_MAX_LENGTH;
+        if (splitAt < CHUNK_TARGET * 0.3) {
+            splitAt = CHUNK_TARGET;
+        }
+        const segment = remaining.slice(0, splitAt);
+        // Count ``` markers — odd means we're splitting inside a code block
+        const markers = segment.match(/```/g);
+        const insideCodeBlock = markers !== null && markers.length % 2 !== 0;
+        if (insideCodeBlock) {
+            chunks.push(segment + "\n```");
+            remaining = "```\n" + remaining.slice(splitAt).trimStart();
+        }
+        else {
+            chunks.push(segment);
+            remaining = remaining.slice(splitAt).trimStart();
         }
-        chunks.push(remaining.slice(0, splitAt));
-        remaining = remaining.slice(splitAt).trimStart();
     }
     return chunks;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@iletai/nzb",
-	"version": "1.1.2",
+	"version": "1.1.4",
 	"description": "NZB — a personal AI assistant for developers, built on the GitHub Copilot SDK",
 	"bin": {
 		"nzb": "dist/cli.js"