@iletai/nzb 1.6.4 → 1.7.3

package/dist/api/server.js

@@ -6,7 +6,7 @@ import { cancelCurrentMessage, getWorkers, sendToOrchestrator } from "../copilot
 import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH, ensureNZBHome } from "../paths.js";
-import { searchMemories } from "../store/db.js";
+import { searchMemories } from "../store/memory.js";
 import { sendPhoto } from "../telegram/bot.js";
 // Ensure token file exists (generate on first run)
 let apiToken = null;
@@ -26,9 +26,9 @@ catch (err) {
 }
 const app = express();
 app.use(express.json());
-// Bearer token authentication middleware (skip /status health check)
+// Bearer token authentication middleware (skip /ping health check only)
 app.use((req, res, next) => {
-    if (!apiToken || req.path === "/status")
+    if (!apiToken || req.path === "/ping")
         return next();
     const auth = req.headers.authorization;
     if (!auth || auth !== `Bearer ${apiToken}`) {
@@ -40,7 +40,11 @@ app.use((req, res, next) => {
 // Active SSE connections
 const sseClients = new Map();
 let connectionCounter = 0;
-// Health check
+// Minimal unauthenticated health check — no internal details
+app.get("/ping", (_req, res) => {
+    res.json({ status: "ok" });
+});
+// Authenticated status with worker details
 app.get("/status", (_req, res) => {
     res.json({
         status: "ok",
@@ -175,7 +179,12 @@ app.post("/restart", (_req, res) => {
 app.post("/send-photo", async (req, res) => {
     const { photo, caption } = req.body;
     if (!photo || typeof photo !== "string") {
-        res.status(400).json({ error: "Missing 'photo' (file path or URL) in request body" });
+        res.status(400).json({ error: "Missing 'photo' (file path or HTTPS URL) in request body" });
+        return;
+    }
+    // Basic input validation before passing to sendPhoto
+    if (photo.startsWith("http://")) {
+        res.status(400).json({ error: "Only HTTPS URLs are allowed for photos" });
         return;
     }
     try {

package/dist/cli.js

@@ -28,6 +28,7 @@ function getVersion() {
         return pkg.version || "0.0.0";
     }
     catch {
+        // Expected: package.json may not be found in dev/bundled environments
         return "0.0.0";
     }
 }

package/dist/config.js

@@ -15,6 +15,7 @@ const configSchema = z.object({
     LOG_CHANNEL_ID: z.string().optional(),
     NODE_EXTRA_CA_CERTS: z.string().optional(),
     OPENAI_API_KEY: z.string().optional(),
+    REASONING_EFFORT: z.string().optional(),
 });
 const raw = configSchema.parse(process.env);
 // Apply NODE_EXTRA_CA_CERTS from .env if not already set via environment.
@@ -37,6 +38,14 @@ if (!Number.isInteger(parsedWorkerTimeout) || parsedWorkerTimeout <= 0) {
 }
 const parsedLogChannelId = raw.LOG_CHANNEL_ID ? raw.LOG_CHANNEL_ID.trim() : undefined;
 export const DEFAULT_MODEL = "claude-sonnet-4.6";
+function validateEnum(value, validValues, defaultValue, name) {
+    if (!value)
+        return defaultValue;
+    if (validValues.includes(value))
+        return value;
+    console.log(`[nzb] Invalid ${name} value "${value}", using default "${defaultValue}"`);
+    return defaultValue;
+}
 let _copilotModel = raw.COPILOT_MODEL || DEFAULT_MODEL;
 export const config = {
     telegramBotToken: raw.TELEGRAM_BOT_TOKEN,
@@ -64,13 +73,15 @@ export const config = {
         process.env.SHOW_REASONING = value ? "true" : "false";
     },
     /** Usage display mode: off | tokens | full */
-    usageMode: (process.env.USAGE_MODE || "off"),
+    usageMode: validateEnum(process.env.USAGE_MODE, ["off", "tokens", "full"], "off", "USAGE_MODE"),
     /** Verbose mode: when on, instructs the AI to be more detailed */
     verboseMode: process.env.VERBOSE_MODE === "true",
     /** Thinking level: off | low | medium | high */
-    thinkingLevel: (process.env.THINKING_LEVEL || "off"),
+    thinkingLevel: validateEnum(process.env.THINKING_LEVEL, ["off", "low", "medium", "high"], "off", "THINKING_LEVEL"),
     /** Group chat: when true, bot only responds when mentioned in groups */
     groupMentionOnly: process.env.GROUP_MENTION_ONLY !== "false",
+    /** Reasoning effort: low | medium | high */
+    reasoningEffort: validateEnum(process.env.REASONING_EFFORT, ["low", "medium", "high"], "medium", "REASONING_EFFORT"),
 };
 /** Persist an env variable to ~/.nzb/.env */
 export function persistEnvVar(key, value) {
@@ -91,6 +102,7 @@ export function persistEnvVar(key, value) {
         writeFileSync(ENV_PATH, updated.join("\n"));
     }
     catch {
+        // Expected: .env file may not exist yet on first run
         writeFileSync(ENV_PATH, `${key}=${value}\n`);
     }
 }

package/dist/copilot/client.js

@@ -1,4 +1,5 @@
 import { CopilotClient } from "@github/copilot-sdk";
+import { withTimeout } from "../utils.js";
 let client;
 /** Coalesces concurrent resetClient() calls into a single reset operation. */
 let pendingResetPromise;
@@ -6,9 +7,8 @@ export async function getClient() {
     if (!client) {
         client = new CopilotClient({
             autoStart: true,
-            autoRestart: true,
         });
-        await client.start();
+        await withTimeout(client.start(), 30_000, "client.start()");
     }
     return client;
 }
@@ -17,27 +17,27 @@ export async function resetClient() {
     if (pendingResetPromise)
         return pendingResetPromise;
     pendingResetPromise = (async () => {
-        if (client) {
-            try {
-                await client.stop();
+        try {
+            if (client) {
+                try {
+                    await withTimeout(client.stop(), 10_000, "client.stop()");
+                }
+                catch (err) {
+                    console.error("[nzb] Error stopping client during reset:", err);
+                }
+                client = undefined;
             }
-            catch {
-                /* best-effort */
-            }
-            client = undefined;
+            return await getClient();
+        }
+        finally {
+            pendingResetPromise = undefined;
         }
-        return getClient();
     })();
-    try {
-        return await pendingResetPromise;
-    }
-    finally {
-        pendingResetPromise = undefined;
-    }
+    return pendingResetPromise;
 }
 export async function stopClient() {
     if (client) {
-        await client.stop();
+        await withTimeout(client.stop(), 10_000, "client.stop()");
         client = undefined;
     }
 }

package/dist/copilot/mcp-config.js

@@ -10,6 +10,7 @@ const isWSL = (() => {
         return readFileSync("/proc/version", "utf-8").toLowerCase().includes("microsoft");
     }
     catch {
+        // Expected: /proc/version may not exist on non-Linux systems
         return false;
     }
 })();
@@ -86,6 +87,7 @@ export function loadMcpConfig() {
         return cachedConfig;
     }
     catch {
+        // Expected: config file may not exist or be malformed
         cachedConfig = {};
         return cachedConfig;
     }

package/dist/copilot/orchestrator.js

@@ -1,7 +1,11 @@
 import { approveAll } from "@github/copilot-sdk";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { SESSIONS_DIR } from "../paths.js";
-import { completeTeam, deleteState, getMemorySummary, getRecentConversation, getState, logConversation, setState, updateTeamMemberResult, } from "../store/db.js";
+import { deleteState, getState, setState } from "../store/db.js";
+import { getRecentConversation, logConversation } from "../store/conversation.js";
+import { getMemorySummary } from "../store/memory.js";
+import { completeTeam, updateTeamMemberResult } from "../store/team-store.js";
+import { formatAge, withTimeout } from "../utils.js";
 import { resetClient } from "./client.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
@@ -27,10 +31,13 @@ let copilotClient;
 const workers = new Map();
 const teams = new Map();
 let healthCheckTimer;
+let workerReaperTimer;
 // Persistent orchestrator session
 let orchestratorSession;
 // Coalesces concurrent ensureOrchestratorSession calls
 let sessionCreatePromise;
+// Tracks when the orchestrator session was created for TTL enforcement
+let sessionCreatedAt;
 // Tracks in-flight context recovery injection so we don't race with real messages
 let recoveryInjectionPromise;
 const messageQueue = [];
@@ -60,6 +67,7 @@ function getSessionConfig() {
                     workerNotifyFn(event, channel);
                 }
             },
+            getCurrentSourceChannel,
         });
         cachedToolsClientRef = copilotClient;
     }
@@ -138,27 +146,35 @@ async function ensureClient() {
     return resetPromise;
 }
 /** Start periodic health check that proactively reconnects the client. */
+let healthCheckRunning = false;
 function startHealthCheck() {
     if (healthCheckTimer)
         return;
     healthCheckTimer = setInterval(async () => {
         if (!copilotClient)
             return;
+        if (healthCheckRunning)
+            return;
+        healthCheckRunning = true;
         try {
             const state = copilotClient.getState();
             if (state !== "connected") {
                 console.log(`[nzb] Health check: client state is '${state}', resetting…`);
                 const previousClient = copilotClient;
-                await ensureClient();
+                await withTimeout(ensureClient(), 15_000, "health check");
                 // Only invalidate session if the underlying client actually changed
                 if (copilotClient !== previousClient) {
                     orchestratorSession = undefined;
+                    sessionCreatedAt = undefined;
                 }
             }
         }
         catch (err) {
             console.error(`[nzb] Health check error:`, err instanceof Error ? err.message : err);
         }
+        finally {
+            healthCheckRunning = false;
+        }
     }, HEALTH_CHECK_INTERVAL_MS);
 }
 /** Stop the periodic health check timer. Call during shutdown. */
@@ -168,17 +184,64 @@ export function stopHealthCheck() {
         healthCheckTimer = undefined;
     }
 }
+/** Periodically kills workers that have exceeded 2× their configured timeout. */
+function startWorkerReaper() {
+    if (workerReaperTimer)
+        return;
+    workerReaperTimer = setInterval(() => {
+        const maxAge = config.workerTimeoutMs * 2;
+        const now = Date.now();
+        for (const [name, worker] of workers) {
+            if (worker.startedAt && now - worker.startedAt > maxAge) {
+                console.log(`[nzb] Reaping stuck worker '${name}' (age: ${formatAge(worker.startedAt)})`);
+                try {
+                    worker.session.disconnect().catch(() => { });
+                }
+                catch {
+                    // Session may already be destroyed
+                }
+                workers.delete(name);
+                feedBackgroundResult(name, `⚠ Worker '${name}' was automatically killed after exceeding timeout.`);
+            }
+        }
+    }, 5 * 60 * 1000);
+    workerReaperTimer.unref();
+}
+const SESSION_MAX_AGE_MS = 4 * 60 * 60 * 1000; // 4 hours
 /** Create or resume the persistent orchestrator session. */
 async function ensureOrchestratorSession() {
-    if (orchestratorSession)
-        return orchestratorSession;
+    if (orchestratorSession) {
+        // Validate session is still usable — check client connectivity
+        try {
+            const clientState = copilotClient?.getState?.();
+            if (clientState && clientState !== "connected") {
+                console.log(`[nzb] Session stale (client state: ${clientState}), recreating…`);
+                orchestratorSession = undefined;
+                sessionCreatedAt = undefined;
+            }
+        }
+        catch {
+            console.log("[nzb] Session validation failed, recreating…");
+            orchestratorSession = undefined;
+            sessionCreatedAt = undefined;
+        }
+        // Enforce session TTL
+        if (sessionCreatedAt && Date.now() - sessionCreatedAt > SESSION_MAX_AGE_MS) {
+            console.log("[nzb] Session TTL expired, recreating…");
+            orchestratorSession = undefined;
+            sessionCreatedAt = undefined;
+        }
+        if (orchestratorSession)
+            return orchestratorSession;
+    }
     // Coalesce concurrent callers — wait for an in-flight creation
     if (sessionCreatePromise)
         return sessionCreatePromise;
-    sessionCreatePromise = createOrResumeSession();
+    sessionCreatePromise = withTimeout(createOrResumeSession(), 30_000, "session create/resume");
     try {
         const session = await sessionCreatePromise;
         orchestratorSession = session;
+        sessionCreatedAt = Date.now();
         return session;
     }
     finally {
@@ -204,6 +267,7 @@ async function createOrResumeSession() {
                 model: config.copilotModel,
                 configDir: SESSIONS_DIR,
                 streaming: true,
+                reasoningEffort: config.reasoningEffort,
                 systemMessage: {
                     content: getOrchestratorSystemMessage(memorySummary || undefined, {
                         selfEditEnabled: config.selfEditEnabled,
@@ -230,6 +294,7 @@ async function createOrResumeSession() {
         model: config.copilotModel,
         configDir: SESSIONS_DIR,
         streaming: true,
+        reasoningEffort: config.reasoningEffort,
         systemMessage: {
             content: getOrchestratorSystemMessage(memorySummary || undefined, {
                 selfEditEnabled: config.selfEditEnabled,
@@ -248,7 +313,7 @@ async function createOrResumeSession() {
     // Recover conversation context if available (session was lost, not first run)
     // Runs concurrently but is awaited before any real message is sent on the session
     const recentHistory = getRecentConversation(10);
-    if (recentHistory) {
+    if (!recoveryInjectionPromise && recentHistory) {
         console.log(`[nzb] Injecting recent conversation context into new session`);
         recoveryInjectionPromise = session
             .sendAndWait({
@@ -288,6 +353,7 @@ export async function initOrchestrator(client) {
     console.log(`[nzb] Skill directories: ${skillDirectories.join(", ") || "(none)"}`);
     console.log(`[nzb] Persistent session mode — conversation history maintained by SDK`);
     startHealthCheck();
+    startWorkerReaper();
     // Eagerly create/resume the orchestrator session
     try {
         await ensureOrchestratorSession();
@@ -297,60 +363,96 @@ export async function initOrchestrator(client) {
     }
 }
 /** Send a prompt on the persistent session, return the response. */
-async function executeOnSession(prompt, callback, onToolEvent, onUsage) {
+async function executeOnSession(prompt, callback, onToolEvent, onUsage, attachments) {
     const session = await ensureOrchestratorSession();
     // Wait for any in-flight context recovery injection to finish before sending
     if (recoveryInjectionPromise) {
-        console.log(`[nzb] Waiting for context recovery injection to complete before sending…`);
-        await recoveryInjectionPromise;
+        console.log("[nzb] Waiting for context recovery…");
+        await withTimeout(recoveryInjectionPromise, 25_000, "recovery injection wait").catch(() => {
+            console.log("[nzb] Recovery injection wait timed out, proceeding anyway");
+        });
     }
     currentCallback = callback;
     let accumulated = "";
     let toolCallExecuted = false;
     const unsubToolStart = session.on("tool.execution_start", (event) => {
-        const toolName = event?.data?.toolName || event?.data?.name || "tool";
-        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 });
+        try {
+            const toolName = event?.data?.toolName || event?.data?.name || "tool";
+            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 });
+        }
+        catch (err) {
+            console.error("[nzb] Error in tool.execution_start listener:", err instanceof Error ? err.message : err);
+        }
     });
     const unsubToolDone = session.on("tool.execution_complete", (event) => {
-        toolCallExecuted = true;
-        const toolName = event?.data?.toolName || event?.data?.name || "tool";
-        onToolEvent?.({ type: "tool_complete", toolName });
+        try {
+            toolCallExecuted = true;
+            const toolName = event?.data?.toolName || event?.data?.name || "tool";
+            onToolEvent?.({ type: "tool_complete", toolName });
+        }
+        catch (err) {
+            console.error("[nzb] Error in tool.execution_complete listener:", err instanceof Error ? err.message : err);
+        }
     });
     const unsubDelta = session.on("assistant.message_delta", (event) => {
-        // After a tool call completes, ensure a line break separates the text blocks
-        // so they don't visually run together in the TUI.
-        if (toolCallExecuted && accumulated.length > 0 && !accumulated.endsWith("\n")) {
-            accumulated += "\n";
-        }
-        toolCallExecuted = false;
-        accumulated += event.data.deltaContent;
-        callback(accumulated, false);
+        try {
+            // After a tool call completes, ensure a line break separates the text blocks
+            // so they don't visually run together in the TUI.
+            if (toolCallExecuted && accumulated.length > 0 && !accumulated.endsWith("\n")) {
+                accumulated += "\n";
+            }
+            toolCallExecuted = false;
+            accumulated += event.data.deltaContent;
+            callback(accumulated, false);
+        }
+        catch (err) {
+            console.error("[nzb] Error in message_delta listener:", err instanceof Error ? err.message : err);
+        }
     });
     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 errMsg = event?.data?.message || event?.data?.error || "Unknown session error";
+            console.error(`[nzb] Session error event: ${errMsg}`);
+        }
+        catch (err) {
+            console.error("[nzb] Error in session.error listener:", err instanceof Error ? err.message : err);
+        }
     });
     const unsubPartialResult = session.on("tool.execution_partial_result", (event) => {
-        const toolName = event?.data?.toolName || event?.data?.name || "tool";
-        const partialOutput = event?.data?.partialOutput || "";
-        onToolEvent?.({ type: "tool_partial_result", toolName, detail: partialOutput });
+        try {
+            const toolName = event?.data?.toolName || event?.data?.name || "tool";
+            const partialOutput = event?.data?.partialOutput || "";
+            onToolEvent?.({ type: "tool_partial_result", toolName, detail: partialOutput });
+        }
+        catch (err) {
+            console.error("[nzb] Error in tool.execution_partial_result listener:", err instanceof Error ? err.message : err);
+        }
     });
     const unsubUsage = session.on("assistant.usage", (event) => {
-        const inputTokens = event?.data?.inputTokens || 0;
-        const outputTokens = event?.data?.outputTokens || 0;
-        const model = event?.data?.model || undefined;
-        const duration = event?.data?.duration || undefined;
-        onUsage?.({ inputTokens, outputTokens, model, duration });
+        try {
+            const inputTokens = event?.data?.inputTokens || 0;
+            const outputTokens = event?.data?.outputTokens || 0;
+            const model = event?.data?.model || undefined;
+            const duration = event?.data?.duration || undefined;
+            onUsage?.({ inputTokens, outputTokens, model, duration });
+        }
+        catch (err) {
+            console.error("[nzb] Error in assistant.usage listener:", err instanceof Error ? err.message : err);
+        }
     });
     try {
-        const result = await session.sendAndWait({ prompt }, 60_000);
+        const sendPayload = { prompt };
+        if (attachments?.length) {
+            sendPayload.attachments = attachments;
+        }
+        const result = await session.sendAndWait(sendPayload, 60_000);
         // Allow late-arriving events (e.g. assistant.usage) to be processed
         await new Promise((r) => setTimeout(r, 150));
         const finalContent = result?.data?.content || accumulated || "(No response)";
@@ -358,6 +460,16 @@ async function executeOnSession(prompt, callback, onToolEvent, onUsage) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
+        // Vision not supported — the session is now tainted with image data in its history,
+        // so ALL subsequent messages would fail. Force-recreate the session to recover.
+        // The retry (with stripped attachments) is handled by sendToOrchestrator's retry loop.
+        if (/not supported for vision/i.test(msg)) {
+            console.log(`[nzb] Model '${config.copilotModel}' does not support vision — destroying tainted session`);
+            orchestratorSession = undefined;
+            sessionCreatedAt = undefined;
+            deleteState(ORCHESTRATOR_SESSION_KEY);
+            throw 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`);
@@ -367,6 +479,7 @@ async function executeOnSession(prompt, callback, onToolEvent, onUsage) {
         if (/closed|destroy|disposed|invalid|expired|not found/i.test(msg)) {
             console.log(`[nzb] Session appears dead, will recreate: ${msg}`);
             orchestratorSession = undefined;
+            sessionCreatedAt = undefined;
             deleteState(ORCHESTRATOR_SESSION_KEY);
         }
         throw err;
@@ -390,26 +503,34 @@ async function processQueue() {
         return;
     }
     processing = true;
-    while (messageQueue.length > 0) {
-        const item = messageQueue.shift();
-        currentSourceChannel = item.sourceChannel;
-        try {
-            const result = await executeOnSession(item.prompt, item.callback, item.onToolEvent, item.onUsage);
-            item.resolve(result);
-        }
-        catch (err) {
-            item.reject(err);
+    try {
+        while (messageQueue.length > 0) {
+            const item = messageQueue.shift();
+            currentSourceChannel = item.sourceChannel;
+            try {
+                const result = await executeOnSession(item.prompt, item.callback, item.onToolEvent, item.onUsage, item.attachments);
+                item.resolve(result);
+            }
+            catch (err) {
+                item.reject(err);
+            }
+            currentSourceChannel = undefined;
         }
-        currentSourceChannel = undefined;
     }
-    processing = false;
+    finally {
+        processing = false;
+    }
+    // Re-check for messages that arrived during the last executeOnSession call
+    if (messageQueue.length > 0) {
+        void processQueue();
+    }
 }
 function isRecoverableError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return /timeout|disconnect|connection|EPIPE|ECONNRESET|ECONNREFUSED|socket|closed|ENOENT|spawn|not found|expired|stale/i.test(msg);
 }
 const MAX_AUTO_CONTINUE = 3;
-export async function sendToOrchestrator(prompt, source, callback, onToolEvent, onUsage, _autoContinueCount = 0) {
+export async function sendToOrchestrator(prompt, source, callback, onToolEvent, onUsage, _autoContinueCount = 0, attachments) {
     const sourceLabel = source.type === "telegram" ? "telegram" : source.type === "tui" ? "tui" : "background";
     logMessage("in", sourceLabel, prompt);
     // Tag the prompt with its source channel
@@ -444,6 +565,7 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                 const finalContent = await new Promise((resolve, reject) => {
                     const item = {
                         prompt: taggedPrompt,
+                        attachments,
                         callback,
                         onToolEvent,
                         onUsage,
@@ -505,6 +627,19 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                 if (/cancelled|abort/i.test(msg)) {
                     return;
                 }
+                // Vision not supported — strip attachments and retry with text-only prompt.
+                // executeOnSession already destroyed the tainted session.
+                if (/not supported for vision/i.test(msg)) {
+                    console.log(`[nzb] Vision not supported — retrying without attachments`);
+                    attachments = undefined;
+                    taggedPrompt =
+                        `[System: The current model '${config.copilotModel}' does not support image/vision analysis. ` +
+                            `The image path is already included in the user's message below. ` +
+                            `Please inform the user that the current model doesn't support direct image analysis, ` +
+                            `and suggest switching to a vision-capable model (e.g. gpt-4o, claude-sonnet-4, gemini-2.0-flash) ` +
+                            `using the /model command.]\n\n${taggedPrompt}`;
+                    continue;
+                }
                 if (isRecoverableError(err) && attempt < MAX_RETRIES) {
                     const delay = RECONNECT_DELAYS_MS[Math.min(attempt, RECONNECT_DELAYS_MS.length - 1)];
                     console.error(`[nzb] Recoverable error: ${msg}. Retry ${attempt + 1}/${MAX_RETRIES} after ${delay}ms…`);
@@ -523,9 +658,10 @@ export async function sendToOrchestrator(prompt, source, callback, onToolEvent,
                 return;
             }
         }
-    })();
+    })().catch((err) => {
+        console.error(`[nzb] Unhandled error in sendToOrchestrator: ${err instanceof Error ? err.message : String(err)}`);
+    });
 }
-/** Cancel the in-flight message and drain the queue. */
 export async function cancelCurrentMessage() {
     // Drain any queued messages
     const drained = messageQueue.length;
@@ -572,10 +708,11 @@ export async function resetSession() {
     // Destroy the existing session
     if (orchestratorSession) {
         try {
-            await orchestratorSession.destroy();
+            await orchestratorSession.disconnect();
         }
         catch { }
         orchestratorSession = undefined;
+        sessionCreatedAt = undefined;
     }
     // Clear persisted session ID so a fresh session is created
     deleteState(ORCHESTRATOR_SESSION_KEY);

package/dist/copilot/skills.js

@@ -41,7 +41,8 @@ export function listSkills() {
         try {
             entries = readdirSync(dir);
         }
-        catch {
+        catch (err) {
+            console.error("[nzb] Failed to read skill directory", dir + ":", err instanceof Error ? err.message : err);
             continue;
         }
         for (const entry of entries) {
@@ -60,7 +61,8 @@ export function listSkills() {
                     source,
                 });
             }
-            catch {
+            catch (err) {
+                console.error("[nzb] Failed to parse SKILL.md for", entry + ":", err instanceof Error ? err.message : err);
                 skills.push({
                     slug: entry,
                     name: entry,