@imisbahk/hive 0.1.3 → 0.1.6

package/dist/cli/commands/chat.js

@@ -1,11 +1,17 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { stdin, stdout } from "node:process";
 import * as readline from "node:readline";
 import { createInterface } from "node:readline/promises";
+import { spawnSync } from "node:child_process";
 import chalk from "chalk";
-import { buildBrowserAugmentedPrompt, HiveAgent } from "../../agent/agent.js";
-import { closeHiveDatabase, getPrimaryAgent, openHiveDatabase, } from "../../storage/db.js";
-import { createProvider } from "../../providers/index.js";
-import { renderError, renderHiveHeader, renderInfo, renderSeparator, } from "../ui.js";
+import fetch from "node-fetch";
+import { RUNTIME_SYSTEM_GUARDRAILS, buildBrowserAugmentedPrompt, HiveAgent, } from "../../agent/agent.js";
+import { initializeHiveCtxSession, } from "../../agent/hive-ctx.js";
+import { closeHiveDatabase, deleteKnowledge, findClosestKnowledge, getPrimaryAgent, getHiveHomeDir, insertKnowledge, listKnowledge, listConversationMessages, listRecentConversations, openHiveDatabase, updateConversationTitle, clearEpisodes, } from "../../storage/db.js";
+import { createProvider, pingProvider } from "../../providers/index.js";
+import { renderError, renderHiveHeader, renderInfo, renderSeparator, renderSuccess, } from "../ui.js";
+import { openPage } from "../../browser/browser.js";
 import { runConfigKeyCommandWithOptions, runConfigModelCommandWithOptions, runConfigProviderCommandWithOptions, runConfigShowCommandWithOptions, runConfigThemeCommandWithOptions, } from "./config.js";
 import { runStatusCommandWithOptions } from "./status.js";
 import { getTheme } from "../theme.js";
@@ -18,6 +24,24 @@ const COMMAND_HELP_TEXT = [
     "Commands:",
     "  /help           show commands",
     "  /new            start a new conversation",
+    "  /remember <fact> save a fact",
+    "  /forget <thing>  delete closest fact",
+    "  /pin <fact>      pin fact into context",
+    "  /summarize <url> summarize a web page",
+    "  /tldr            summarize this conversation",
+    "  /recap           summarize persona + knowledge",
+    "  /mode <name>     switch response mode",
+    "  /status          show mode/provider/model",
+    "  /export          export conversation markdown",
+    "  /save <title>    name this conversation",
+    "  /history         list recent conversations",
+    "  /clear           clear the screen",
+    "  /think <question>think step by step",
+    "  /retry           resend last message",
+    "  /copy            copy last reply",
+    "  /hive memory list  show knowledge items",
+    "  /hive memory clear clear episodic memory",
+    "  /hive memory show  show current persona",
     "  /browse <url>   read a webpage",
     "  browse <url>    same as /browse",
     "  /search <query> search the web",
@@ -36,6 +60,9 @@ const HIVE_SHORTCUT_HELP_TEXT = [
     "  /hive help         list shortcuts",
     "  /hive status       run hive status",
     "  /hive config show  run hive config show",
+    "  /hive memory list  list knowledge",
+    "  /hive memory clear clear episodes",
+    "  /hive memory show  show persona",
     "",
     "Interactive config commands (in chat):",
     "  /hive config provider",
@@ -53,6 +80,13 @@ const PREVIEW_AGENT_NAME = "jarvis";
 const PREVIEW_PROVIDER = "google";
 const PREVIEW_MODEL = "gemini-2.0-flash";
 const PREVIEW_NEW_MESSAGE = "Started a new preview conversation context.";
+const MODE_PROMPTS = {
+    default: null,
+    research: "Every answer must be grounded in current web evidence. Perform web search as needed and cite sources inline.",
+    code: "Think and respond like a focused software engineer. Prioritize concise technical answers and code.",
+    brainstorm: "Be creative and opinionated. Offer bold suggestions and push back on weak ideas when helpful.",
+    brief: "Keep every response to a maximum of 3 sentences while preserving key details.",
+};
 const COMMAND_SUGGESTIONS = [
     {
         label: "/help",
@@ -64,6 +98,81 @@ const COMMAND_SUGGESTIONS = [
         insertText: "/new",
         description: "start a new conversation",
     },
+    {
+        label: "/remember <fact>",
+        insertText: "/remember ",
+        description: "save to knowledge graph",
+    },
+    {
+        label: "/pin <fact>",
+        insertText: "/pin ",
+        description: "pin fact into context",
+    },
+    {
+        label: "/forget <thing>",
+        insertText: "/forget ",
+        description: "delete closest fact",
+    },
+    {
+        label: "/summarize <url>",
+        insertText: "/summarize ",
+        description: "summarize a web page",
+    },
+    {
+        label: "/tldr",
+        insertText: "/tldr",
+        description: "summarize this conversation",
+    },
+    {
+        label: "/recap",
+        insertText: "/recap",
+        description: "summarize persona & knowledge",
+    },
+    {
+        label: "/mode <name>",
+        insertText: "/mode ",
+        description: "switch response style",
+    },
+    {
+        label: "/export",
+        insertText: "/export",
+        description: "export conversation markdown",
+    },
+    {
+        label: "/save <title>",
+        insertText: "/save ",
+        description: "set conversation title",
+    },
+    {
+        label: "/history",
+        insertText: "/history",
+        description: "list recent conversations",
+    },
+    {
+        label: "/status",
+        insertText: "/status",
+        description: "show session status",
+    },
+    {
+        label: "/clear",
+        insertText: "/clear",
+        description: "clear the screen",
+    },
+    {
+        label: "/think <question>",
+        insertText: "/think ",
+        description: "think step by step",
+    },
+    {
+        label: "/retry",
+        insertText: "/retry",
+        description: "resend last message",
+    },
+    {
+        label: "/copy",
+        insertText: "/copy",
+        description: "copy last reply",
+    },
     {
         label: "/browse <url>",
         insertText: "/browse ",
@@ -94,6 +203,21 @@ const COMMAND_SUGGESTIONS = [
         insertText: "/hive config show",
         description: "run hive config show",
     },
+    {
+        label: "/hive memory list",
+        insertText: "/hive memory list",
+        description: "list knowledge entries",
+    },
+    {
+        label: "/hive memory clear",
+        insertText: "/hive memory clear",
+        description: "clear episodic memory",
+    },
+    {
+        label: "/hive memory show",
+        insertText: "/hive memory show",
+        description: "show current persona",
+    },
     {
         label: "/hive init",
         insertText: "/hive init",
@@ -142,6 +266,7 @@ export function registerChatCommand(program) {
 export async function runChatCommand(options, context = {}) {
     console.clear();
     renderHiveHeader("Chat");
+    void checkForUpdates();
     const entrypoint = context.entrypoint ?? "chat-command";
     if (entrypoint === "chat-command") {
         renderInfo("`hive chat` is deprecated. Run `hive`.");
@@ -159,16 +284,36 @@ export async function runChatCommand(options, context = {}) {
             return;
         }
         let activeProfile = profile;
+        const model = options.model ?? activeProfile.model;
+        const ctxStoragePath = join(getHiveHomeDir(), "ctx");
+        mkdirSync(ctxStoragePath, { recursive: true });
+        let hiveCtx = await initializeHiveCtxSession({
+            storagePath: ctxStoragePath,
+            profile: activeProfile,
+            model,
+        });
+        if (hiveCtx.warning) {
+            console.log(chalk.dim(hiveCtx.warning));
+        }
         let provider = await createProvider(activeProfile.provider);
         let agent = new HiveAgent(db, provider, activeProfile);
         let agentName = resolveAgentName(activeProfile.agent_name);
-        const model = options.model ?? activeProfile.model;
+        let currentMode = "default";
+        try {
+            await pingProvider(provider, model);
+        }
+        catch {
+            renderError("✗ Provider unreachable. Run `hive doctor` to diagnose.");
+            return;
+        }
         let conversationId = options.conversation;
         const runOptions = {
             model,
             title: options.title,
             temperature,
         };
+        const lastUserPromptRef = { value: null };
+        const lastAssistantRef = { value: "" };
         renderChatPreamble({
             agentName,
             provider: profile.provider,
@@ -176,9 +321,22 @@ export async function runChatCommand(options, context = {}) {
         });
         if (options.message) {
             const augmentedMessage = await buildBrowserAugmentedPrompt(options.message, {
-                locationHint: profile.location ?? undefined,
+                locationHint: activeProfile.location ?? undefined,
             });
-            conversationId = await streamReply(agent, augmentedMessage, conversationId, runOptions, agentName);
+            const systemAddition = getModeSystemPrompt(currentMode);
+            lastUserPromptRef.value = options.message;
+            const streamResult = await streamReply({
+                agent,
+                prompt: augmentedMessage,
+                rawPrompt: options.message,
+                conversationId,
+                options: runOptions,
+                agentName,
+                systemAddition,
+                hiveCtx: hiveCtx.session,
+            });
+            conversationId = streamResult.conversationId;
+            lastAssistantRef.value = streamResult.assistantText;
             renderInfo(`conversation: ${conversationId}`);
             return;
         }
@@ -187,25 +345,54 @@ export async function runChatCommand(options, context = {}) {
             if (prompt.length === 0) {
                 continue;
             }
+            const normalizedPrompt = prompt.trim().toLowerCase();
             if (prompt === "/") {
                 printChatHelp();
                 continue;
             }
-            if (prompt === "/help") {
+            if (normalizedPrompt === "/help") {
                 printChatHelp();
                 continue;
             }
-            if (prompt === "/exit" || prompt === "/quit") {
+            if (normalizedPrompt === "/exit" || normalizedPrompt === "/quit") {
                 break;
             }
-            if (prompt === "/new") {
+            if (normalizedPrompt === "/new") {
                 conversationId = undefined;
+                currentMode = "default";
+                lastUserPromptRef.value = null;
+                lastAssistantRef.value = "";
                 renderInfo("Started a new conversation context.");
                 continue;
             }
             try {
+                const handled = await handleChatSlashCommand({
+                    prompt,
+                    db,
+                    agent,
+                    provider,
+                    agentName,
+                    conversationId,
+                    activeProfilePersona: activeProfile.persona,
+                    mode: currentMode,
+                    providerName: activeProfile.provider,
+                    modelName: runOptions.model ?? activeProfile.model,
+                    setConversationId: (id) => {
+                        conversationId = id;
+                    },
+                    setMode: (mode) => {
+                        currentMode = mode;
+                    },
+                    lastUserPromptRef,
+                    lastAssistantRef,
+                    hiveCtx: hiveCtx.session,
+                });
+                if (handled) {
+                    continue;
+                }
                 const shortcutResult = await handleHiveShortcut(prompt, {
                     allowInteractiveConfig: true,
+                    db,
                 });
                 if (shortcutResult === "handled") {
                     continue;
@@ -217,29 +404,57 @@ export async function runChatCommand(options, context = {}) {
                         continue;
                     }
                     activeProfile = latestProfile;
+                    const resolvedModel = options.model ?? activeProfile.model;
+                    hiveCtx = await initializeHiveCtxSession({
+                        storagePath: ctxStoragePath,
+                        profile: activeProfile,
+                        model: resolvedModel,
+                    });
+                    if (hiveCtx.warning) {
+                        console.log(chalk.dim(hiveCtx.warning));
+                    }
                     provider = await createProvider(activeProfile.provider);
                     agent = new HiveAgent(db, provider, activeProfile);
                     agentName = resolveAgentName(activeProfile.agent_name);
                     if (!options.model) {
                         runOptions.model = activeProfile.model;
                     }
+                    try {
+                        await pingProvider(provider, runOptions.model ?? activeProfile.model);
+                    }
+                    catch {
+                        renderError("✗ Provider unreachable. Run `hive doctor` to diagnose.");
+                        continue;
+                    }
                     conversationId = undefined;
                     renderInfo(`Switched to ${activeProfile.provider} · ${runOptions.model ?? activeProfile.model}.`);
                     renderInfo("Started a new conversation context.");
                     continue;
                 }
                 if (isUnknownSlashCommand(prompt)) {
-                    renderError(`Unknown command: ${prompt}`);
-                    renderInfo("Run `/help` to view supported commands.");
+                    renderError("✗ Unknown command. Type /help for available commands.");
                     continue;
                 }
                 const augmentedPrompt = await buildBrowserAugmentedPrompt(prompt, {
-                    locationHint: profile.location ?? undefined,
+                    locationHint: activeProfile.location ?? undefined,
+                });
+                lastUserPromptRef.value = prompt;
+                const systemAddition = getModeSystemPrompt(currentMode);
+                const streamResult = await streamReply({
+                    agent,
+                    prompt: augmentedPrompt,
+                    rawPrompt: prompt,
+                    conversationId,
+                    options: runOptions,
+                    agentName,
+                    systemAddition,
+                    hiveCtx: hiveCtx.session,
                 });
-                conversationId = await streamReply(agent, augmentedPrompt, conversationId, runOptions, agentName);
+                conversationId = streamResult.conversationId;
+                lastAssistantRef.value = streamResult.assistantText;
             }
             catch (error) {
-                renderError(formatError(error));
+                renderAmberError(formatError(error));
             }
         }
     }
@@ -247,28 +462,84 @@ export async function runChatCommand(options, context = {}) {
         closeHiveDatabase(db);
     }
 }
-async function streamReply(agent, prompt, conversationId, options, agentName) {
-    process.stdout.write(getTheme().accent(`${agentName}${PROMPT_SYMBOL} `));
-    let activeConversationId = conversationId;
-    for await (const event of agent.chat(prompt, {
-        conversationId: activeConversationId,
-        model: options.model,
-        temperature: options.temperature,
-        title: options.title,
-    })) {
-        if (event.type === "token") {
-            process.stdout.write(event.token);
+async function streamReply(input) {
+    const theme = getTheme();
+    process.stdout.write(theme.accent(`${input.agentName}${PROMPT_SYMBOL} `));
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let frameIndex = 0;
+    let firstToken = false;
+    const spinner = setInterval(() => {
+        if (firstToken) {
+            return;
+        }
+        readline.cursorTo(stdout, 0);
+        readline.clearLine(stdout, 0);
+        stdout.write(`${theme.accent(`${input.agentName}${PROMPT_SYMBOL} `)}${chalk.dim(theme.accent(frames[frameIndex]))} thinking...`);
+        frameIndex = (frameIndex + 1) % frames.length;
+    }, 120);
+    let activeConversationId = input.conversationId;
+    let assistantText = "";
+    let ctxSystemPrompt;
+    let ctxTokenCount;
+    if (input.hiveCtx) {
+        const context = await input.hiveCtx.build(input.rawPrompt);
+        ctxSystemPrompt = context.system;
+        ctxTokenCount = context.tokens;
+    }
+    try {
+        for await (const event of input.agent.chat(input.prompt, {
+            conversationId: activeConversationId,
+            model: input.options.model,
+            temperature: input.options.temperature,
+            title: input.options.title,
+            systemAddition: input.systemAddition,
+            contextSystemPrompt: ctxSystemPrompt,
+            disableLegacyEpisodeStore: Boolean(input.hiveCtx),
+        })) {
+            if (event.type === "token") {
+                if (!firstToken) {
+                    firstToken = true;
+                    clearInterval(spinner);
+                    readline.cursorTo(stdout, 0);
+                    readline.clearLine(stdout, 0);
+                    stdout.write(theme.accent(`${input.agentName}${PROMPT_SYMBOL} `));
+                }
+                process.stdout.write(event.token);
+                activeConversationId = event.conversationId;
+                assistantText += event.token;
+                continue;
+            }
             activeConversationId = event.conversationId;
-            continue;
         }
-        activeConversationId = event.conversationId;
+    }
+    finally {
+        if (!firstToken) {
+            clearInterval(spinner);
+            readline.cursorTo(stdout, 0);
+            readline.clearLine(stdout, 0);
+            stdout.write(theme.accent(`${input.agentName}${PROMPT_SYMBOL} `));
+        }
+        else {
+            clearInterval(spinner);
+        }
+    }
+    if (!firstToken) {
+        stdout.write("✗ No response received.\n");
+        renderSeparator(EXCHANGE_SEPARATOR);
+        return { conversationId: activeConversationId ?? "", assistantText };
     }
     process.stdout.write("\n");
     renderSeparator(EXCHANGE_SEPARATOR);
+    if (input.hiveCtx) {
+        await Promise.resolve(input.hiveCtx.episode(input.rawPrompt, assistantText)).catch(() => { });
+    }
+    if (ctxTokenCount !== undefined) {
+        console.log(chalk.dim(`· ~${ctxTokenCount} ctx tokens`));
+    }
     if (!activeConversationId) {
         throw new Error("Conversation state was not returned by the agent.");
     }
-    return activeConversationId;
+    return { conversationId: activeConversationId, assistantText };
 }
 function parseTemperature(raw) {
     if (raw === undefined) {
@@ -286,6 +557,10 @@ function formatError(error) {
     }
     return String(error);
 }
+function renderAmberError(message) {
+    const accent = getTheme().accent;
+    console.error(accent(`✗ ${message}`));
+}
 function resolveAgentName(agentName) {
     const normalized = agentName?.trim();
     if (normalized && normalized.length > 0) {
@@ -355,6 +630,16 @@ function isHiveShortcut(prompt) {
     const normalized = prompt.trim().toLowerCase();
     return normalized === HIVE_SHORTCUT_PREFIX || normalized.startsWith(`${HIVE_SHORTCUT_PREFIX} `);
 }
+function getModeSystemPrompt(mode) {
+    return MODE_PROMPTS[mode] ?? undefined;
+}
+function combineSystemAdditions(parts) {
+    const merged = parts
+        .map((part) => part?.trim() ?? "")
+        .filter((part) => part.length > 0)
+        .join("\n\n");
+    return merged.length > 0 ? merged : undefined;
+}
 function isUnknownSlashCommand(prompt) {
     const normalized = prompt.trim().toLowerCase();
     if (!normalized.startsWith("/")) {
@@ -364,6 +649,26 @@ function isUnknownSlashCommand(prompt) {
         normalized === "/new" ||
         normalized === "/exit" ||
         normalized === "/quit" ||
+        normalized === "/remember" ||
+        normalized.startsWith("/remember ") ||
+        normalized === "/forget" ||
+        normalized.startsWith("/forget ") ||
+        normalized === "/summarize" ||
+        normalized.startsWith("/summarize ") ||
+        normalized === "/tldr" ||
+        normalized === "/recap" ||
+        normalized === "/mode" ||
+        normalized.startsWith("/mode ") ||
+        normalized === "/export" ||
+        normalized === "/history" ||
+        normalized === "/clear" ||
+        normalized === "/think" ||
+        normalized.startsWith("/think ") ||
+        normalized.startsWith("/save") ||
+        normalized.startsWith("/pin") ||
+        normalized === "/status" ||
+        normalized === "/retry" ||
+        normalized === "/copy" ||
         normalized === "/browse" ||
         normalized.startsWith("/browse ") ||
         normalized === "/search" ||
@@ -400,6 +705,52 @@ async function handleHiveShortcut(prompt, options = {}) {
         restoreChatInputAfterInteractiveCommand();
         return "handled";
     }
+    if (subcommand === "memory list") {
+        const db = options.db;
+        if (!db) {
+            renderError("Memory commands unavailable: database not open.");
+            return "handled";
+        }
+        const rows = listKnowledge(db, { limit: 1000 });
+        if (rows.length === 0) {
+            renderInfo("No knowledge stored.");
+            return "handled";
+        }
+        rows.forEach((row, index) => {
+            const pinnedLabel = row.pinned ? " (pinned)" : "";
+            renderInfo(`${index + 1}. ${row.content}${pinnedLabel}`);
+        });
+        return "handled";
+    }
+    if (subcommand === "memory clear") {
+        const db = options.db;
+        if (!db) {
+            renderError("Memory commands unavailable: database not open.");
+            return "handled";
+        }
+        const confirmed = await promptYesNo("This will delete all episodic memories. Continue? (y/n) ");
+        if (!confirmed) {
+            renderInfo("Cancelled.");
+            return "handled";
+        }
+        clearEpisodes(db);
+        renderSuccess("Episodes cleared.");
+        return "handled";
+    }
+    if (subcommand === "memory show") {
+        const db = options.db;
+        if (!db) {
+            renderError("Memory commands unavailable: database not open.");
+            return "handled";
+        }
+        const agent = getPrimaryAgent(db);
+        if (!agent) {
+            renderError("Hive is not initialized. Run `hive init` first.");
+            return "handled";
+        }
+        renderInfo(agent.persona);
+        return "handled";
+    }
     if (subcommand === "config provider") {
         if (!options.allowInteractiveConfig) {
             renderInfo("Interactive config commands are unavailable here.");
@@ -445,6 +796,335 @@ async function handleHiveShortcut(prompt, options = {}) {
     renderInfo("Use `/hive help` to list available shortcuts.");
     return "handled";
 }
+async function handleChatSlashCommand(input) {
+    const normalized = input.prompt.trim();
+    const lower = normalized.toLowerCase();
+    if (!lower.startsWith("/")) {
+        return false;
+    }
+    if (lower === "/clear") {
+        console.clear();
+        renderHiveHeader("Chat");
+        renderChatPreamble({
+            agentName: input.agentName,
+            provider: input.providerName,
+            model: input.modelName,
+        });
+        input.lastUserPromptRef.value = null;
+        input.lastAssistantRef.value = "";
+        return true;
+    }
+    if (lower.startsWith("/remember")) {
+        const fact = normalized.slice("/remember".length).trim();
+        if (fact.length === 0) {
+            renderError("Usage: /remember <fact>");
+            return true;
+        }
+        if (input.hiveCtx) {
+            await input.hiveCtx.remember(fact);
+        }
+        else {
+            insertKnowledge(input.db, { content: fact });
+        }
+        renderSuccess("✓ Remembered.");
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower.startsWith("/forget")) {
+        const query = normalized.slice("/forget".length).trim();
+        if (query.length === 0) {
+            renderError("Usage: /forget <thing>");
+            return true;
+        }
+        const match = findClosestKnowledge(input.db, query);
+        if (!match) {
+            renderError("No similar knowledge found.");
+            return true;
+        }
+        const confirmed = await promptYesNo(`Forget "${match.content}"? (y/n) `);
+        if (!confirmed) {
+            renderInfo("Kept.");
+            return true;
+        }
+        deleteKnowledge(input.db, match.id);
+        renderSuccess("✓ Forgotten.");
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower.startsWith("/mode")) {
+        const modeName = normalized.slice("/mode".length).trim().toLowerCase();
+        if (!modeName || !Object.hasOwn(MODE_PROMPTS, modeName)) {
+            renderError("Usage: /mode <default|research|code|brainstorm|brief>");
+            return true;
+        }
+        input.setMode(modeName);
+        renderSuccess(`✓ Mode set to ${modeName}.`);
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower.startsWith("/pin")) {
+        const fact = normalized.slice("/pin".length).trim();
+        if (fact.length === 0) {
+            renderError("Usage: /pin <fact>");
+            return true;
+        }
+        if (input.hiveCtx) {
+            await input.hiveCtx.remember(fact, { pinned: true });
+        }
+        else {
+            insertKnowledge(input.db, { content: fact, pinned: true });
+        }
+        renderSuccess("✓ Pinned.");
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower === "/export") {
+        if (!input.conversationId) {
+            renderError("No conversation to export. Start chatting first.");
+            return true;
+        }
+        const messages = listConversationMessages(input.db, input.conversationId);
+        const exportDir = join(getHiveHomeDir(), "exports");
+        mkdirSync(exportDir, { recursive: true });
+        const exportPath = join(exportDir, `${input.conversationId}.md`);
+        writeFileSync(exportPath, formatConversationMarkdown(messages, input.conversationId));
+        renderSuccess(`✓ Exported to ${exportPath}`);
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower === "/history") {
+        const rows = listRecentConversations(input.db, 10);
+        if (rows.length === 0) {
+            renderInfo("No past conversations found.");
+            return true;
+        }
+        rows.forEach((row, index) => {
+            const title = row.title?.trim().length ? row.title : "(untitled)";
+            renderInfo(`${index + 1}. ${title} · ${row.updated_at} · ${row.message_count} messages`);
+        });
+        const answer = await promptLine("Pick a conversation number (or blank to cancel): ");
+        if (!answer) {
+            return true;
+        }
+        const choice = Number.parseInt(answer, 10);
+        if (Number.isNaN(choice) || choice < 1 || choice > rows.length) {
+            renderError("Invalid selection.");
+            return true;
+        }
+        const selected = rows[choice - 1];
+        input.setConversationId(selected.id);
+        renderInfo(`Continuing conversation ${selected.title ?? selected.id}.`);
+        input.lastUserPromptRef.value = null;
+        input.lastAssistantRef.value = "";
+        return true;
+    }
+    if (lower === "/tldr") {
+        if (!input.conversationId) {
+            renderError("No conversation yet. Say something first.");
+            return true;
+        }
+        const history = listConversationMessages(input.db, input.conversationId);
+        if (history.length === 0) {
+            renderError("Nothing to summarize yet.");
+            return true;
+        }
+        await streamEphemeral({
+            provider: input.provider,
+            agentName: input.agentName,
+            model: input.modelName,
+            messages: buildEphemeralMessages({
+                persona: input.activeProfilePersona,
+                mode: input.mode,
+                systemInstruction: "Summarize this conversation in 3-5 bullet points.",
+                history,
+            }),
+        });
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower === "/recap") {
+        const knowledge = listKnowledge(input.db, { limit: 500 });
+        await streamEphemeral({
+            provider: input.provider,
+            agentName: input.agentName,
+            model: input.modelName,
+            messages: buildRecapMessages({
+                persona: input.activeProfilePersona,
+                knowledge,
+                mode: input.mode,
+            }),
+        });
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower.startsWith("/summarize")) {
+        const url = normalized.slice("/summarize".length).trim();
+        if (url.length === 0) {
+            renderError("Usage: /summarize <url>");
+            return true;
+        }
+        try {
+            const content = await openPage(url);
+            await streamEphemeral({
+                provider: input.provider,
+                agentName: input.agentName,
+                model: input.modelName,
+                messages: buildEphemeralMessages({
+                    persona: input.activeProfilePersona,
+                    mode: input.mode,
+                    userMessage: `Summarize this page concisely:\n\n${content}`,
+                }),
+            });
+        }
+        catch (error) {
+            renderError(`Unable to summarize page: ${formatError(error)}`);
+        }
+        return true;
+    }
+    if (lower.startsWith("/save")) {
+        const title = normalized.slice("/save".length).trim();
+        if (!input.conversationId) {
+            renderError("No active conversation to title.");
+            return true;
+        }
+        if (title.length === 0) {
+            renderError("Usage: /save <title>");
+            return true;
+        }
+        updateConversationTitle(input.db, input.conversationId, title);
+        renderSuccess(`✓ Saved title "${title}".`);
+        input.lastUserPromptRef.value = null;
+        return true;
+    }
+    if (lower.startsWith("/think")) {
+        const question = normalized.slice("/think".length).trim();
+        if (question.length === 0) {
+            renderError("Usage: /think <question>");
+            return true;
+        }
+        await streamEphemeral({
+            provider: input.provider,
+            agentName: input.agentName,
+            model: input.modelName,
+            messages: buildEphemeralMessages({
+                persona: input.activeProfilePersona,
+                mode: input.mode,
+                userMessage: `Think through this step by step, show your reasoning:\n\n${question}`,
+            }),
+        });
+        return true;
+    }
+    if (lower === "/status") {
+        const info = [
+            `mode=${input.mode}`,
+            `provider=${input.providerName}`,
+            `model=${input.modelName}`,
+            `conversation=${input.conversationId ?? "none"}`,
+        ].join(" · ");
+        renderInfo(info);
+        return true;
+    }
+    if (lower === "/retry") {
+        const userPrompt = input.lastUserPromptRef.value;
+        if (!userPrompt) {
+            renderError("Nothing to retry yet.");
+            return true;
+        }
+        const systemAddition = getModeSystemPrompt(input.mode);
+        const retryResult = await streamReply({
+            agent: input.agent,
+            prompt: userPrompt,
+            rawPrompt: userPrompt,
+            conversationId: input.conversationId,
+            options: { model: input.modelName },
+            agentName: input.agentName,
+            systemAddition,
+            hiveCtx: input.hiveCtx,
+        });
+        input.setConversationId(retryResult.conversationId);
+        input.lastAssistantRef.value = retryResult.assistantText;
+        return true;
+    }
+    if (lower === "/copy") {
+        if (!input.lastAssistantRef.value) {
+            renderError("Nothing to copy yet.");
+            return true;
+        }
+        const copied = copyToClipboard(input.lastAssistantRef.value);
+        if (copied) {
+            renderSuccess("✓ Copied last reply to clipboard.");
+        }
+        else {
+            renderError("Clipboard tool not available.");
+        }
+        return true;
+    }
+    return false;
+}
+function copyToClipboard(text) {
+    const platform = process.platform;
+    const buffer = Buffer.from(text, "utf8");
+    if (platform === "darwin") {
+        const result = spawnSync("pbcopy", [], { input: buffer });
+        return result.status === 0;
+    }
+    const result = spawnSync("xclip", ["-selection", "clipboard"], { input: buffer });
+    return result.status === 0;
+}
+let cachedLocalVersion = null;
+async function checkForUpdates() {
+    try {
+        const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 3000));
+        const latest = (await Promise.race([
+            fetch("https://registry.npmjs.org/@imisbahk/hive/latest").then((response) => response.json()),
+            timeout,
+        ]));
+        if (!latest?.version || typeof latest.version !== "string") {
+            return;
+        }
+        const localVersion = getLocalVersion();
+        if (isVersionNewer(latest.version, localVersion)) {
+            const amber = chalk.hex("#ffbf00");
+            console.log(amber.dim(`✦ Update available v${localVersion} → npm update -g @imisbahk/hive`));
+        }
+    }
+    catch {
+        // Silently ignore update check failures.
+    }
+}
+function getLocalVersion() {
+    if (cachedLocalVersion) {
+        return cachedLocalVersion;
+    }
+    try {
+        const raw = readFileSync(new URL("../../../package.json", import.meta.url), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed.version) {
+            cachedLocalVersion = parsed.version;
+            return cachedLocalVersion;
+        }
+    }
+    catch {
+        // ignore
+    }
+    cachedLocalVersion = "0.0.0";
+    return cachedLocalVersion;
+}
+function isVersionNewer(remote, local) {
+    const toNumbers = (value) => value.split(".").map((part) => Number.parseInt(part, 10));
+    const r = toNumbers(remote);
+    const l = toNumbers(local);
+    const length = Math.max(r.length, l.length);
+    for (let index = 0; index < length; index += 1) {
+        const rv = r[index] ?? 0;
+        const lv = l[index] ?? 0;
+        if (rv > lv)
+            return true;
+        if (rv < lv)
+            return false;
+    }
+    return false;
+}
 function getCommandSuggestions(input) {
     const normalized = input.trimStart().toLowerCase();
     if (!normalized.startsWith("/")) {
@@ -456,6 +1136,85 @@ function getCommandSuggestions(input) {
         suggestion.label.toLowerCase().includes(normalized.slice(1)));
     return [...prefixMatches, ...fallbackMatches];
 }
+async function promptLine(question) {
+    const rl = createInterface({
+        input: stdin,
+        output: stdout,
+        terminal: true,
+    });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptYesNo(question) {
+    const answer = (await promptLine(question)).toLowerCase();
+    return answer === "y" || answer === "yes";
+}
+async function streamEphemeral(input) {
+    process.stdout.write(getTheme().accent(`${input.agentName}${PROMPT_SYMBOL} `));
+    let hadOutput = false;
+    for await (const token of input.provider.streamChat({
+        model: input.model ?? input.provider.defaultModel,
+        messages: input.messages,
+    })) {
+        hadOutput = true;
+        process.stdout.write(token);
+    }
+    if (!hadOutput) {
+        process.stdout.write("(no response)");
+    }
+    process.stdout.write("\n");
+    renderSeparator(EXCHANGE_SEPARATOR);
+}
+function buildEphemeralMessages(input) {
+    const messages = [
+        { role: "system", content: RUNTIME_SYSTEM_GUARDRAILS },
+        { role: "system", content: input.persona },
+    ];
+    const modePrompt = getModeSystemPrompt(input.mode);
+    if (modePrompt) {
+        messages.push({ role: "system", content: modePrompt });
+    }
+    if (input.systemInstruction) {
+        messages.push({ role: "system", content: input.systemInstruction });
+    }
+    if (input.history) {
+        messages.push(...input.history.map((message) => ({
+            role: message.role,
+            content: message.content,
+        })));
+    }
+    if (input.userMessage) {
+        messages.push({ role: "user", content: input.userMessage });
+    }
+    return messages;
+}
+function buildRecapMessages(input) {
+    const knowledgeLines = input.knowledge.length > 0
+        ? input.knowledge.map((row) => `- ${row.content}`).join("\n")
+        : "No knowledge stored yet.";
+    const userMessage = `Summarize everything you know about the user based on persona and knowledge facts below. Be concise.\n\nPersona:\n${input.persona}\n\nKnowledge facts:\n${knowledgeLines}`;
+    return buildEphemeralMessages({
+        persona: input.persona,
+        mode: input.mode,
+        userMessage,
+    });
+}
+function formatConversationMarkdown(messages, conversationId) {
+    const lines = [`# Conversation ${conversationId}`, ""];
+    for (const message of messages) {
+        const speaker = message.role === "user"
+            ? "User"
+            : message.role === "assistant"
+                ? "Hive"
+                : "System";
+        lines.push(`**${speaker}:**`, message.content, "");
+    }
+    return lines.join("\n");
+}
 async function readPromptWithSuggestions() {
     const accent = getTheme().accent;
     const promptPrefix = accent(USER_PROMPT);