@iletai/nzb 1.1.0

package/dist/copilot/orchestrator.js

@@ -0,0 +1,386 @@
+import { approveAll } from "@github/copilot-sdk";
+import { config, DEFAULT_MODEL } from "../config.js";
+import { SESSIONS_DIR } from "../paths.js";
+import { deleteState, getMemorySummary, getRecentConversation, getState, logConversation, setState, } from "../store/db.js";
+import { resetClient } from "./client.js";
+import { loadMcpConfig } from "./mcp-config.js";
+import { getSkillDirectories } from "./skills.js";
+import { getOrchestratorSystemMessage } from "./system-message.js";
+import { createTools } from "./tools.js";
+const MAX_RETRIES = 3;
+const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
+const HEALTH_CHECK_INTERVAL_MS = 30_000;
+const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
+let logMessage = () => { };
+export function setMessageLogger(fn) {
+    logMessage = fn;
+}
+let proactiveNotifyFn;
+export function setProactiveNotify(fn) {
+    proactiveNotifyFn = fn;
+}
+let copilotClient;
+const workers = new Map();
+let healthCheckTimer;
+// Persistent orchestrator session
+let orchestratorSession;
+// Coalesces concurrent ensureOrchestratorSession calls
+let sessionCreatePromise;
+const messageQueue = [];
+let processing = false;
+let currentCallback;
+/** The channel currently being processed — tools use this to tag new workers. */
+let currentSourceChannel;
+/** Get the channel that originated the message currently being processed. */
+export function getCurrentSourceChannel() {
+    return currentSourceChannel;
+}
+function getSessionConfig() {
+    const tools = createTools({
+        client: copilotClient,
+        workers,
+        onWorkerComplete: feedBackgroundResult,
+    });
+    const mcpServers = loadMcpConfig();
+    const skillDirectories = getSkillDirectories();
+    return { tools, mcpServers, skillDirectories };
+}
+/** Feed a background worker result into the orchestrator as a new turn. */
+export function feedBackgroundResult(workerName, result) {
+    const worker = workers.get(workerName);
+    const channel = worker?.originChannel;
+    const prompt = `[Background task completed] Worker '${workerName}' finished:\n\n${result}`;
+    sendToOrchestrator(prompt, { type: "background" }, (_text, done) => {
+        if (done && proactiveNotifyFn) {
+            proactiveNotifyFn(_text, channel);
+        }
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Ensure the SDK client is connected, resetting if necessary. Coalesces concurrent resets. */
+let resetPromise;
+async function ensureClient() {
+    if (copilotClient && copilotClient.getState() === "connected") {
+        return copilotClient;
+    }
+    if (!resetPromise) {
+        console.log(`[nzb] Client not connected (state: ${copilotClient?.getState() ?? "null"}), resetting…`);
+        resetPromise = resetClient()
+            .then((c) => {
+            console.log(`[nzb] Client reset successful, state: ${c.getState()}`);
+            copilotClient = c;
+            return c;
+        })
+            .finally(() => {
+            resetPromise = undefined;
+        });
+    }
+    return resetPromise;
+}
+/** Start periodic health check that proactively reconnects the client. */
+function startHealthCheck() {
+    if (healthCheckTimer)
+        return;
+    healthCheckTimer = setInterval(async () => {
+        if (!copilotClient)
+            return;
+        try {
+            const state = copilotClient.getState();
+            if (state !== "connected") {
+                console.log(`[nzb] Health check: client state is '${state}', resetting…`);
+                await ensureClient();
+                // Session may need recovery after client reset
+                orchestratorSession = undefined;
+            }
+        }
+        catch (err) {
+            console.error(`[nzb] Health check error:`, err instanceof Error ? err.message : err);
+        }
+    }, HEALTH_CHECK_INTERVAL_MS);
+}
+/** Create or resume the persistent orchestrator session. */
+async function ensureOrchestratorSession() {
+    if (orchestratorSession)
+        return orchestratorSession;
+    // Coalesce concurrent callers — wait for an in-flight creation
+    if (sessionCreatePromise)
+        return sessionCreatePromise;
+    sessionCreatePromise = createOrResumeSession();
+    try {
+        const session = await sessionCreatePromise;
+        orchestratorSession = session;
+        return session;
+    }
+    finally {
+        sessionCreatePromise = undefined;
+    }
+}
+/** Internal: actually create or resume a session (not concurrency-safe — use ensureOrchestratorSession). */
+async function createOrResumeSession() {
+    const client = await ensureClient();
+    const { tools, mcpServers, skillDirectories } = getSessionConfig();
+    const memorySummary = getMemorySummary();
+    const infiniteSessions = {
+        enabled: true,
+        backgroundCompactionThreshold: 0.8,
+        bufferExhaustionThreshold: 0.95,
+    };
+    // Try to resume a previous session
+    const savedSessionId = getState(ORCHESTRATOR_SESSION_KEY);
+    if (savedSessionId) {
+        try {
+            console.log(`[nzb] Resuming orchestrator session ${savedSessionId.slice(0, 8)}…`);
+            const session = await client.resumeSession(savedSessionId, {
+                model: config.copilotModel,
+                configDir: SESSIONS_DIR,
+                streaming: true,
+                systemMessage: {
+                    content: getOrchestratorSystemMessage(memorySummary || undefined, {
+                        selfEditEnabled: config.selfEditEnabled,
+                    }),
+                },
+                tools,
+                mcpServers,
+                skillDirectories,
+                onPermissionRequest: approveAll,
+                infiniteSessions,
+            });
+            console.log(`[nzb] Resumed orchestrator session successfully`);
+            return session;
+        }
+        catch (err) {
+            console.log(`[nzb] Could not resume session: ${err instanceof Error ? err.message : err}. Creating new.`);
+            deleteState(ORCHESTRATOR_SESSION_KEY);
+        }
+    }
+    // Create a fresh session
+    console.log(`[nzb] Creating new persistent orchestrator session`);
+    const session = await client.createSession({
+        model: config.copilotModel,
+        configDir: SESSIONS_DIR,
+        streaming: true,
+        systemMessage: {
+            content: getOrchestratorSystemMessage(memorySummary || undefined, { selfEditEnabled: config.selfEditEnabled }),
+        },
+        tools,
+        mcpServers,
+        skillDirectories,
+        onPermissionRequest: approveAll,
+        infiniteSessions,
+    });
+    // Persist the session ID for future restarts
+    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)
+    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] 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;
+        }
+    }
+    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)"}`);
+    console.log(`[nzb] Persistent session mode — conversation history maintained by SDK`);
+    startHealthCheck();
+    // Eagerly create/resume the orchestrator session
+    try {
+        await ensureOrchestratorSession();
+    }
+    catch (err) {
+        console.error(`[nzb] Failed to create initial session (will retry on first message):`, err instanceof Error ? err.message : err);
+    }
+}
+/** Send a prompt on the persistent session, return the response. */
+async function executeOnSession(prompt, callback, onToolEvent) {
+    const session = await ensureOrchestratorSession();
+    currentCallback = callback;
+    let accumulated = "";
+    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 unsubToolDone = session.on("tool.execution_complete", (event) => {
+        toolCallExecuted = true;
+        const toolName = event?.data?.toolName || event?.data?.name || "tool";
+        onToolEvent?.({ type: "tool_complete", toolName });
+    });
+    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 {
+        const result = await session.sendAndWait({ prompt }, 300_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);
+        if (/closed|destroy|disposed|invalid|expired|not found/i.test(msg)) {
+            console.log(`[nzb] Session appears dead, will recreate: ${msg}`);
+            orchestratorSession = undefined;
+            deleteState(ORCHESTRATOR_SESSION_KEY);
+        }
+        throw err;
+    }
+    finally {
+        unsubDelta();
+        unsubToolStart();
+        unsubToolDone();
+        currentCallback = undefined;
+    }
+}
+/** Process the message queue one at a time. */
+async function processQueue() {
+    if (processing) {
+        if (messageQueue.length > 0) {
+            console.log(`[nzb] Message queued (${messageQueue.length} waiting — orchestrator is busy)`);
+        }
+        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.resolve(result);
+        }
+        catch (err) {
+            item.reject(err);
+        }
+        currentSourceChannel = undefined;
+    }
+    processing = false;
+}
+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);
+}
+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}`;
+    // 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
+    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 });
+                    processQueue();
+                });
+                // Deliver response to user FIRST, then log best-effort
+                callback(finalContent, true);
+                try {
+                    logMessage("out", sourceLabel, finalContent);
+                }
+                catch {
+                    /* best-effort */
+                }
+                // Log both sides of the conversation after delivery
+                try {
+                    logConversation(logRole, prompt, sourceLabel);
+                }
+                catch {
+                    /* best-effort */
+                }
+                try {
+                    logConversation("assistant", finalContent, sourceLabel);
+                }
+                catch {
+                    /* best-effort */
+                }
+                return;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                // Don't retry cancelled messages
+                if (/cancelled|abort/i.test(msg)) {
+                    return;
+                }
+                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…`);
+                    await sleep(delay);
+                    // Reset client before retry in case the connection is stale
+                    try {
+                        await ensureClient();
+                    }
+                    catch {
+                        /* will fail again on next attempt */
+                    }
+                    continue;
+                }
+                console.error(`[nzb] Error processing message: ${msg}`);
+                callback(`Error: ${msg}`, true);
+                return;
+            }
+        }
+    })();
+}
+/** Cancel the in-flight message and drain the queue. */
+export async function cancelCurrentMessage() {
+    // Drain any queued messages
+    const drained = messageQueue.length;
+    while (messageQueue.length > 0) {
+        const item = messageQueue.shift();
+        item.reject(new Error("Cancelled"));
+    }
+    // Abort the active session request
+    if (orchestratorSession && currentCallback) {
+        try {
+            await orchestratorSession.abort();
+            console.log(`[nzb] Aborted in-flight request`);
+            return true;
+        }
+        catch (err) {
+            console.error(`[nzb] Abort failed:`, err instanceof Error ? err.message : err);
+        }
+    }
+    return drained > 0;
+}
+export function getWorkers() {
+    return workers;
+}
+export function getQueueSize() {
+    return messageQueue.length;
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/copilot/skills.js

@@ -0,0 +1,128 @@
+import { readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { SKILLS_DIR } from "../paths.js";
+/** User-local skills directory (~/.nzb/skills/) */
+const LOCAL_SKILLS_DIR = SKILLS_DIR;
+/** Global shared skills directory */
+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. */
+export function getSkillDirectories() {
+    const dirs = [];
+    if (existsSync(BUNDLED_SKILLS_DIR))
+        dirs.push(BUNDLED_SKILLS_DIR);
+    if (existsSync(LOCAL_SKILLS_DIR))
+        dirs.push(LOCAL_SKILLS_DIR);
+    if (existsSync(GLOBAL_SKILLS_DIR))
+        dirs.push(GLOBAL_SKILLS_DIR);
+    return dirs;
+}
+/** Scan all skill directories and return metadata for each skill found. */
+export function listSkills() {
+    const skills = [];
+    for (const [dir, source] of [
+        [BUNDLED_SKILLS_DIR, "bundled"],
+        [LOCAL_SKILLS_DIR, "local"],
+        [GLOBAL_SKILLS_DIR, "global"],
+    ]) {
+        if (!existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const skillDir = join(dir, entry);
+            const skillMd = join(skillDir, "SKILL.md");
+            if (!existsSync(skillMd))
+                continue;
+            try {
+                const content = readFileSync(skillMd, "utf-8");
+                const { name, description } = parseFrontmatter(content);
+                skills.push({
+                    slug: entry,
+                    name: name || entry,
+                    description: description || "(no description)",
+                    directory: skillDir,
+                    source,
+                });
+            }
+            catch {
+                skills.push({
+                    slug: entry,
+                    name: entry,
+                    description: "(could not read SKILL.md)",
+                    directory: skillDir,
+                    source,
+                });
+            }
+        }
+    }
+    return skills;
+}
+/** 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 + "/")) {
+        return `Invalid slug '${slug}': must be a simple kebab-case name without path separators.`;
+    }
+    if (existsSync(skillDir)) {
+        return `Skill '${slug}' already exists at ${skillDir}. Edit it directly or delete it first.`;
+    }
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "_meta.json"), JSON.stringify({ slug, version: "1.0.0" }, null, 2) + "\n");
+    const skillMd = `---
+name: ${name}
+description: ${description}
+---
+
+${instructions}
+`;
+    writeFileSync(join(skillDir, "SKILL.md"), skillMd);
+    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 + "/")) {
+        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 });
+    return {
+        ok: true,
+        message: `Skill '${slug}' removed from ${skillDir}. It will no longer be available on your next message.`,
+    };
+}
+/** Parse YAML frontmatter from a SKILL.md file. */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return { name: "", description: "" };
+    const frontmatter = match[1];
+    let name = "";
+    let description = "";
+    for (const line of frontmatter.split("\n")) {
+        const idx = line.indexOf(": ");
+        if (idx <= 0)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const value = line.slice(idx + 2).trim();
+        if (key === "name")
+            name = value;
+        if (key === "description")
+            description = value;
+    }
+    return { name, description };
+}
+//# sourceMappingURL=skills.js.map

package/dist/copilot/system-message.js

@@ -0,0 +1,128 @@
+export function getOrchestratorSystemMessage(memorySummary, opts) {
+    const memoryBlock = memorySummary
+        ? `\n## Long-Term Memory\nThese are things you've been asked to remember or have noted as important:\n\n${memorySummary}\n`
+        : "";
+    const selfEditBlock = opts?.selfEditEnabled
+        ? ""
+        : `\n## Self-Edit Protection
+
+**You must NEVER modify your own source code.** This includes the NZB codebase, configuration files in the project repo, your own system message, skill definitions that ship with you, or any file that is part of the NZB application itself.
+
+If you break yourself, you cannot repair yourself. If the user asks you to modify your own code, politely decline and explain that self-editing is disabled for safety. Suggest they make the changes manually or start NZB with \`--self-edit\` to temporarily allow it.
+
+This restriction does NOT apply to:
+- User project files (code the user asks you to work on)
+- Learned skills in ~/.nzb/skills/ (these are user data, not NZB source)
+- The ~/.nzb/.env config file (model switching, etc.)
+- 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.
+
+## Your Architecture
+
+You are a Node.js daemon process built with the Copilot SDK. Here's how you work:
+
+- **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.
+
+When no source tag is present, assume Telegram.
+
+## Your 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.
+
+## Your Role
+
+You receive messages and decide how to handle them:
+
+- **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.
+
+## 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.
+
+## 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.
+${selfEditBlock}${memoryBlock}`;
+}
+//# sourceMappingURL=system-message.js.map