@pentoshi/clai 0.5.10 → 0.7.1

package/dist/prompts/index.js

@@ -1,4 +1,4 @@
-import { detectSystem } from '../os/detect.js';
+import { detectSystem } from "../os/detect.js";
 const askPrompt = `You are clai in /ask mode — a cybersecurity and pentesting assistant. Do NOT execute anything.
 OS: {{os}} | Shell: {{shell}} | CWD: {{cwd}}
 
@@ -19,10 +19,11 @@ TOOLS (use EXACT arg names — wrong names = failure):
 - fs.list: {"path":"<dir>"} — list directory
 - fs.search: {"pattern":"<regex>","path":"<dir>"} — search file CONTENTS (NOT filenames)
 - pkg.install: {"tool":"<name>"} — install package (only if user asks or command not found)
-- net.scan: {"target":"<ip/host>","ports":"<optional>"} — nmap scan
-- http.fetch: {"url":"<url>","method":"<optional>","body":"<optional>","headers":{"Key":"Value"}} — HTTP request with optional headers
+- net.scan: {"target":"<ip|cidr|hostname>","ports":"<optional 80,443,1-1000>","profile":{"scanType":"syn|tcp|udp|ping","serviceDetect":bool,"topPorts":int,"timing":"T0|T1|T2|T3|T4|T5","scripts":["safe-script-name"]},"iOwnThis":bool} — nmap scan. Target/ports/flags are strictly validated (no shell injection). Prefer the structured profile field; the legacy flags string still works but every token must be safe.
+- http.fetch: {"url":"<url>","method":"<optional GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS>","body":"<optional>","headers":{"Key":"Value"},"maxBytes":<optional>,"iOwnThis":<optional bool>} — HTTP request. GET/HEAD auto-execute against public URLs; non-GET/HEAD and private/loopback/metadata addresses require confirmation; pass iOwnThis=true to allow private targets you own.
 - sysinfo: {} — OS info
 - pentest.recon: {"target":"<ip/host>"} — whois + dig + nmap top-100
+- tool.batch: {"calls":[{"name":"<tool>","args":{...}}, ...],"concurrency":<optional 1-4>} — run up to 8 read-only tools (fs.read/list/search, http.fetch GET/HEAD, sysinfo) in parallel and aggregate their outputs. Use this for independent recon lookups (e.g. resolve a hostname AND read robots.txt) instead of a chain of single calls.
 
 FORMAT — one tool per response:
 \`\`\`tool
@@ -78,13 +79,20 @@ Do NOT: run sysinfo after answering, list home dirs, scan localhost unprompted,
 function render(template, values) {
     return Object.entries(values).reduce((current, [key, value]) => current.replaceAll(`{{${key}}}`, value), template);
 }
+/**
+ * Internal exports for tests that verify the canonical inline templates
+ * have not drifted from the markdown copies in src/prompts/. These are
+ * not part of the public API.
+ */
+export const _ASK_TEMPLATE = askPrompt;
+export const _AGENT_TEMPLATE = agentPrompt;
 export function renderAskSystemPrompt() {
     const system = detectSystem();
     return render(askPrompt, {
         os: `${system.osName} ${system.release} ${system.arch}`,
         shell: system.shell,
         cwd: system.cwd,
-        tool_list: 'none',
+        tool_list: "none",
     });
 }
 export function renderAgentSystemPrompt(toolList) {

package/dist/prompts/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,SAAS,GAAG;;;;;;;;;0LASwK,CAAC;AAE3L,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2KAiEuJ,CAAC;AAG5K,SAAS,MAAM,CAAC,QAAgB,EAAE,MAA8B;IAC9D,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC;AACrH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,OAAO,MAAM,CAAC,SAAS,EAAE;QACvB,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE;QACvD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS,EAAE,MAAM;KAClB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,QAAgB;IACtD,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,OAAO,MAAM,CAAC,WAAW,EAAE;QACzB,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE;QACvD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,SAAS,GAAG;;;;;;;;;0LASwK,CAAC;AAE3L,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2KAkEuJ,CAAC;AAE5K,SAAS,MAAM,CAAC,QAAgB,EAAE,MAA8B;IAC9D,OAAO,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAClC,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,UAAU,CAAC,KAAK,GAAG,IAAI,EAAE,KAAK,CAAC,EAClE,QAAQ,CACT,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,SAAS,CAAC;AACvC,MAAM,CAAC,MAAM,eAAe,GAAG,WAAW,CAAC;AAE3C,MAAM,UAAU,qBAAqB;IACnC,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,OAAO,MAAM,CAAC,SAAS,EAAE;QACvB,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE;QACvD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS,EAAE,MAAM;KAClB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,uBAAuB,CAAC,QAAgB;IACtD,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,OAAO,MAAM,CAAC,WAAW,EAAE;QACzB,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,IAAI,EAAE;QACvD,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS,EAAE,QAAQ;KACpB,CAAC,CAAC;AACL,CAAC"}

package/dist/repl.d.ts

@@ -3,6 +3,7 @@ export interface ReplOptions {
     mode?: Mode | undefined;
     provider?: ProviderId | undefined;
     model?: string | undefined;
+    noHistory?: boolean | undefined;
 }
 export interface SlashCommand {
     command: string;

package/dist/repl.js

@@ -3,17 +3,19 @@ import { stdin as input, stdout as output } from "node:process";
 import chalk from "chalk";
 import { search } from "@inquirer/prompts";
 import { runAskStream } from "./modes/ask.js";
-import { runAgent } from "./modes/agent.js";
+import { runAgent, createSessionPolicy, } from "./modes/agent.js";
 import { providerSwitcher, printProviderKeys, setProviderKey, unsetProviderKey, } from "./commands/providers.js";
 import { getConfig, getProviderModel, setDefaultMode, setProviderModel, setThinking, updateConfig, } from "./store/config.js";
 import { listSessions, saveSession } from "./store/history.js";
 import { assertProvider, defaultModels } from "./llm/provider.js";
-import { runUpdate, checkForUpdateSilent, getCurrentVersion } from "./commands/update.js";
+import { runUpdate, checkForUpdateSilent, getCurrentVersion, } from "./commands/update.js";
 import { renderBanner, renderSessionInfo, renderSuggestions, renderModeSwitch, renderProviderSwitch, PROMPT, } from "./ui/banner.js";
 import { clearThinking, createThinkingStreamParser, getLastThinking, rememberThinkingFromText, renderThinkingBlock, renderThinkingSummary, renderThinkingToggleMessage, } from "./ui/thinking.js";
 import { createMarkdownStreamWriter, renderMarkdown } from "./ui/markdown.js";
 import { startThinkingSpinner } from "./ui/spinner.js";
 import { modelSupportsThinking } from "./llm/capabilities.js";
+import { getLastViewport, getViewport, listViewports, toggleViewport, } from "./ui/output-pane.js";
+import { compactMessages, estimateMessagesTokens, } from "./agent/context-manager.js";
 const slashCommands = [
     { command: "/ask", description: "switch to ask mode" },
     { command: "/agent", description: "switch to agent mode" },
@@ -49,9 +51,40 @@ const slashCommands = [
     { command: "/history", description: "show past sessions" },
     { command: "/save", usage: "<name>", description: "save session" },
     { command: "/cwd", usage: "<path>", description: "change working directory" },
-    { command: "/allow", usage: "<tool>", description: "allow a tool for session" },
+    {
+        command: "/allow",
+        usage: "<tool>|list",
+        description: "allow a tool for this session (not persisted)",
+    },
+    {
+        command: "/disallow",
+        usage: "<tool>",
+        description: "revoke a session allow",
+    },
     { command: "/think", description: "show thinking from last response" },
     { command: "/thinking", description: "alias for /think" },
+    {
+        command: "/output",
+        usage: "[last|<id>|list]",
+        description: "toggle full tool output (same as Ctrl+O)",
+    },
+    {
+        command: "/freeonly",
+        usage: "[on|off]",
+        description: "skip paid providers in fallback (off by default)",
+    },
+    { command: "/compact", description: "compact session history now" },
+    { command: "/context", description: "show estimated context size" },
+    {
+        command: "/scope",
+        usage: "[show|clear|new <targets>]",
+        description: "manage pentest engagement scope",
+    },
+    {
+        command: "/privacy",
+        usage: "[status|clear-history|clear-logs|clear-artifacts|clear-all|on|off]",
+        description: "control retention and private mode (in-memory only)",
+    },
     { command: "/update", description: "check for updates" },
     { command: "/exit", description: "quit" },
     { command: "/quit", description: "alias for /exit" },
@@ -184,7 +217,9 @@ function isAbortLikeError(error) {
     return false;
 }
 function slashCommandLabel(command) {
-    return command.usage ? `${command.command} ${command.usage}` : command.command;
+    return command.usage
+        ? `${command.command} ${command.usage}`
+        : command.command;
 }
 function slashCommandFilter(line) {
     if (!line.startsWith("/") || /\s/.test(line))
@@ -344,7 +379,8 @@ async function readPromptLine(options) {
             if (key.name === "up") {
                 if (menu.visible && menu.suggestions.length > 0) {
                     selectedIndex =
-                        (selectedIndex - 1 + menu.suggestions.length) % menu.suggestions.length;
+                        (selectedIndex - 1 + menu.suggestions.length) %
+                            menu.suggestions.length;
                     refresh();
                     return;
                 }
@@ -509,7 +545,8 @@ async function withAbortableInput(run) {
         return await run(ac.signal);
     }
     catch (error) {
-        if (ac.signal.aborted || (error instanceof Error && error.name === "AbortError")) {
+        if (ac.signal.aborted ||
+            (error instanceof Error && error.name === "AbortError")) {
             throw new AbortRunError();
         }
         throw error;
@@ -528,7 +565,8 @@ function help() {
         return `  ${chalk.cyan(label)}${chalk.dim(command.description)}`;
     })
         .join("\n");
-    return lines + chalk.dim("\n\n  ESC abort  │  Ctrl+C clears input (twice to exit)  │  Ctrl+T toggle thinking");
+    return (lines +
+        chalk.dim("\n\n  ESC abort  │  Ctrl+C clears input (twice to exit)  │  Ctrl+T toggle thinking  │  Ctrl+O / /output last toggle tool output"));
 }
 async function pickModelInteractively(provider, currentModel) {
     const models = knownModels[provider] ?? [];
@@ -763,17 +801,224 @@ async function handleSlash(line, state) {
         }
         case "/allow": {
             const tool = args[0];
-            if (!tool)
-                console.log(chalk.dim("usage: /allow <tool>"));
+            if (!tool) {
+                console.log(chalk.dim("usage: /allow <tool>|list"));
+                return true;
+            }
+            if (tool === "list" || tool === "ls") {
+                if (state.session.allow.size === 0) {
+                    console.log(chalk.dim("  no session allows"));
+                }
+                else {
+                    for (const allowed of state.session.allow) {
+                        console.log(chalk.dim(`  ✓ ${allowed}`));
+                    }
+                }
+                return true;
+            }
+            state.session.allow.add(tool);
+            console.log(chalk.dim(`  allowed ${tool} for this session only ✓`));
+            return true;
+        }
+        case "/disallow": {
+            const tool = args[0];
+            if (!tool) {
+                console.log(chalk.dim("usage: /disallow <tool>"));
+                return true;
+            }
+            if (state.session.allow.delete(tool)) {
+                console.log(chalk.dim(`  revoked ${tool} ✓`));
+            }
             else {
-                const config = getConfig();
-                updateConfig({
-                    allowAlwaysTools: Array.from(new Set([...config.allowAlwaysTools, tool])),
-                });
-                console.log(chalk.dim(`  allowed ${tool} ✓`));
+                console.log(chalk.dim(`  ${tool} was not in the session allow list`));
             }
             return true;
         }
+        case "/context": {
+            const tokens = estimateMessagesTokens(state.messages);
+            console.log(chalk.dim(`  ${state.messages.length} message(s), ~${tokens.toLocaleString()} tokens estimated`));
+            return true;
+        }
+        case "/compact": {
+            const before = state.messages.length;
+            const compacted = compactMessages(state.messages, { budgetTokens: 0 });
+            state.messages.splice(0, state.messages.length, ...compacted);
+            console.log(chalk.dim(`  compacted ${before} → ${state.messages.length} messages (~${estimateMessagesTokens(state.messages).toLocaleString()} tokens)`));
+            return true;
+        }
+        case "/scope": {
+            const sub = (args[0] ?? "show").toLowerCase();
+            const { loadScope, saveScope, clearScope, isScopeActive, getScopePath, resetScopeCache, } = await import("./store/scope.js");
+            if (sub === "show" || sub === "ls" || sub === "list") {
+                resetScopeCache();
+                const scope = await loadScope();
+                if (!scope) {
+                    console.log(chalk.dim("  no engagement scope configured"));
+                    console.log(chalk.dim(`  expected at: ${getScopePath()}`));
+                    console.log(chalk.dim("  create one with: /scope new domain1,domain2 [--name <eng>] or `clai scope new --targets ...`"));
+                    return true;
+                }
+                const status = isScopeActive(scope)
+                    ? chalk.green("active")
+                    : chalk.yellow("expired or empty");
+                console.log(chalk.dim(`  scope: ${scope.name ?? "(unnamed)"} [${status}]`));
+                console.log(chalk.dim(`  authorized: ${scope.authorizedTargets.join(", ")}`));
+                if (scope.excludedTargets && scope.excludedTargets.length > 0) {
+                    console.log(chalk.dim(`  excluded:   ${scope.excludedTargets.join(", ")}`));
+                }
+                if (scope.expiresAt) {
+                    console.log(chalk.dim(`  expires:    ${scope.expiresAt}`));
+                }
+                return true;
+            }
+            if (sub === "clear" || sub === "reset" || sub === "off") {
+                await clearScope();
+                console.log(chalk.dim("  engagement scope cleared"));
+                return true;
+            }
+            if (sub === "new" || sub === "set" || sub === "add") {
+                const rest = args.slice(1).join(" ").trim();
+                if (!rest) {
+                    console.log(chalk.dim("  usage: /scope new <target1,target2,...> [name=<engagement>] [expires=<iso>]"));
+                    return true;
+                }
+                // Parse: first whitespace-delimited token is the targets list,
+                // remaining `key=value` pairs configure name/expires/note.
+                const tokens = rest.split(/\s+/);
+                const targetsRaw = tokens[0] ?? "";
+                const targets = targetsRaw
+                    .split(",")
+                    .map((t) => t.trim())
+                    .filter(Boolean);
+                if (targets.length === 0) {
+                    console.log(chalk.dim("  no targets parsed"));
+                    return true;
+                }
+                let name;
+                let expires;
+                let note;
+                let exclude;
+                for (const token of tokens.slice(1)) {
+                    const eq = token.indexOf("=");
+                    if (eq < 0)
+                        continue;
+                    const key = token.slice(0, eq).toLowerCase();
+                    const value = token.slice(eq + 1);
+                    if (key === "name")
+                        name = value;
+                    else if (key === "expires")
+                        expires = value;
+                    else if (key === "note")
+                        note = value;
+                    else if (key === "exclude")
+                        exclude = value
+                            .split(",")
+                            .map((t) => t.trim())
+                            .filter(Boolean);
+                }
+                const scope = {
+                    name,
+                    authorizedTargets: targets,
+                    excludedTargets: exclude,
+                    authorizationNote: note,
+                    createdAt: new Date().toISOString(),
+                    expiresAt: expires,
+                };
+                await saveScope(scope);
+                console.log(chalk.dim(`  saved scope${name ? ` "${name}"` : ""} with ${targets.length} target(s)`));
+                return true;
+            }
+            console.log(chalk.dim("  usage: /scope [show|clear|new <targets> [key=value]...]"));
+            return true;
+        }
+        case "/privacy": {
+            const sub = (args[0] ?? "status").toLowerCase();
+            if (sub === "on" || sub === "enable") {
+                updateConfig({ privateMode: true });
+                console.log(chalk.dim("  privateMode: " +
+                    chalk.green("on") +
+                    "  (history not written; in-memory only)"));
+                return true;
+            }
+            if (sub === "off" || sub === "disable") {
+                updateConfig({ privateMode: false });
+                console.log(chalk.dim("  privateMode: " + chalk.dim("off")));
+                return true;
+            }
+            if (sub === "status" || sub === "show") {
+                const cfg = getConfig();
+                console.log(chalk.dim(`  privateMode: ${cfg.privateMode ? chalk.green("on") : chalk.dim("off")}  retention: ${cfg.historyRetentionLimit || "unlimited"}`));
+                return true;
+            }
+            const { clearAllHistory } = await import("./store/history.js");
+            const { clearAuditLogs, clearArtifacts } = await import("./store/logs.js");
+            if (sub === "clear-history") {
+                const r = await clearAllHistory();
+                console.log(chalk.dim(`  history cleared (${r.detail || "ok"})`));
+                return true;
+            }
+            if (sub === "clear-logs") {
+                const r = await clearAuditLogs();
+                console.log(chalk.dim(`  audit logs cleared (${r.removed} files)`));
+                return true;
+            }
+            if (sub === "clear-artifacts") {
+                const r = await clearArtifacts();
+                console.log(chalk.dim(`  artifacts cleared (${r.removed} files)`));
+                return true;
+            }
+            if (sub === "clear-all") {
+                const a = await clearAllHistory();
+                const b = await clearAuditLogs();
+                const c = await clearArtifacts();
+                console.log(chalk.dim(`  history (${a.detail || "ok"}); logs (${b.removed}); artifacts (${c.removed})`));
+                return true;
+            }
+            console.log(chalk.dim("  usage: /privacy [status|on|off|clear-history|clear-logs|clear-artifacts|clear-all]"));
+            return true;
+        }
+        case "/freeonly": {
+            const arg = (args[0] ?? "").toLowerCase().trim();
+            if (!arg) {
+                const value = getConfig().freeOnly;
+                console.log(chalk.dim(`  freeOnly: ${value ? chalk.green("on") : chalk.dim("off")}  (paid providers ${value ? "skipped" : "in fallback"})`));
+                return true;
+            }
+            if (arg === "on" || arg === "true" || arg === "enable") {
+                updateConfig({ freeOnly: true });
+                console.log(chalk.dim("  freeOnly: " + chalk.green("on")));
+                return true;
+            }
+            if (arg === "off" || arg === "false" || arg === "disable") {
+                updateConfig({ freeOnly: false });
+                console.log(chalk.dim("  freeOnly: " + chalk.dim("off")));
+                return true;
+            }
+            console.log(chalk.dim("  usage: /freeonly [on|off]"));
+            return true;
+        }
+        case "/output": {
+            const target = args[0] ?? "last";
+            if (target === "list" || target === "ls") {
+                const all = listViewports();
+                if (all.length === 0) {
+                    console.log(chalk.dim("  no tool outputs recorded yet"));
+                }
+                else {
+                    for (const v of all) {
+                        console.log(chalk.dim(`  ${v.id} — ${v.toolName} ${v.argsDisplay}${v.artifactPath ? ` (${v.artifactPath})` : ""}`));
+                    }
+                }
+                return true;
+            }
+            const viewport = target === "last" ? getLastViewport() : getViewport(target);
+            if (!viewport) {
+                console.log(chalk.dim(`  no viewport: ${target}`));
+                return true;
+            }
+            await toggleViewport(viewport.id);
+            return true;
+        }
         case "/think":
         case "/thinking": {
             const thinking = getLastThinking();
@@ -801,12 +1046,15 @@ async function handleSlash(line, state) {
 }
 export async function startRepl(options = {}) {
     const config = getConfig();
-    const provider = options.provider ? assertProvider(options.provider) : config.defaultProvider;
+    const provider = options.provider
+        ? assertProvider(options.provider)
+        : config.defaultProvider;
     const state = {
         mode: options.mode ?? config.defaultMode,
         provider,
         model: options.model ?? getProviderModel(provider),
         messages: [],
+        session: createSessionPolicy(),
     };
     const promptHistory = [];
     let isReadingPrompt = false;
@@ -839,7 +1087,17 @@ export async function startRepl(options = {}) {
     const handleKeypress = (_sequence, key) => {
         if (key.ctrl && key.name === "t" && !isReadingPrompt)
             handleThinkingShortcut();
-        if ((key.name === "escape" || (key.ctrl && key.name === "c")) && currentAbortController) {
+        if (key.ctrl && key.name === "o" && !isReadingPrompt) {
+            const v = getLastViewport();
+            if (v) {
+                void toggleViewport(v.id);
+            }
+            else {
+                process.stdout.write(chalk.dim("\n  (no tool output to expand yet)\n"));
+            }
+        }
+        if ((key.name === "escape" || (key.ctrl && key.name === "c")) &&
+            currentAbortController) {
             currentAbortController.abort();
         }
     };
@@ -886,7 +1144,7 @@ export async function startRepl(options = {}) {
         mode: state.mode,
     }));
     console.log(renderSuggestions());
-    console.log(chalk.dim("  ESC to abort a response  │  Ctrl+C clears input (twice to exit)  │  Ctrl+T or /think for thinking\n"));
+    console.log(chalk.dim("  ESC abort  │  Ctrl+C clears input  │  Ctrl+T or /think for thinking  │  Ctrl+O or /output last for full tool output\n"));
     // Hint thinking-capable users that the toggle exists. We default it to
     // off for speed, since on NIM many models route through a much slower
     // chat-template path when reasoning is enabled.
@@ -944,6 +1202,7 @@ export async function startRepl(options = {}) {
                         model: state.model,
                         history: state.messages,
                         signal,
+                        session: state.session,
                     }));
                 }
                 console.log();
@@ -967,7 +1226,13 @@ export async function startRepl(options = {}) {
         if (siginfoRegistered)
             process.off(siginfo, handleThinkingShortcut);
         if (state.messages.length > 0) {
-            await saveSession(state.messages, `repl-${new Date().toISOString()}`);
+            // Honor `--no-history` and the persistent privateMode setting.
+            // The session.allow set is already in-memory only; saveSession itself
+            // also bails early when privateMode is on, but checking here keeps
+            // intent obvious in the call site.
+            if (!options.noHistory && !getConfig().privateMode) {
+                await saveSession(state.messages, `repl-${new Date().toISOString()}`);
+            }
         }
         if (input.isTTY)
             input.setRawMode(false);