min-agent 0.4.1 → 0.5.1

package/README.md

@@ -67,6 +67,8 @@ Type `/` to open a command menu. Use **↑ / ↓** to recall previous messages.
 | `/model` | Switch model |
 | `/provider` | Switch provider |
 | `/plan` | Toggle plan mode (look, don't touch) |
+| `/think` | Choose thinking intensity |
+| `/memory` | Turn memory on/off, or save a note |
 | `/undo` | Undo the last turn |
 | `/diff` | Show file changes made so far |
 | `/sessions` | List or switch sessions |
@@ -74,10 +76,11 @@ Type `/` to open a command menu. Use **↑ / ↓** to recall previous messages.
 | `/mcp` | Show connected MCP servers |
 | `/skills` | Manage skills |
 | `/tokens` | Usage and estimated cost |
+| `/ctx` | Choose local-model context window |
 | `/help` | Show all commands |
 | `/exit` | Exit |
 
-Shortcuts: **Ctrl+C** clears the input (press twice to exit) · **Ctrl+B** selects text to copy · mouse drag-select also copies on release.
+Shortcuts: **Ctrl+C** clears the input (press twice to exit) · **Ctrl+V** pastes an image · a multi-line paste becomes a snippet · **Ctrl+B** selects text to copy · mouse drag-select also copies on release · click a tool or thinking block to expand or collapse it.
 
 ## Staying in Control
 
@@ -98,10 +101,29 @@ min-agent sandbox off        # No restriction (default)
 min-agent sandbox workspace  # Only allow changes inside the current folder
 ```
 
+## Memory
+
+Remembered notes are off by default. Turn them on when you want facts to persist across sessions:
+
+```bash
+min-agent memory                 # Show the switch and stored notes
+min-agent memory on              # Turn memory on (writes config)
+min-agent --memory on            # Same; with a message, this session only
+min-agent memory add "prefer bun"
+```
+
+In chat, `/memory on` or `/memory off` toggles it; `/memory` lists notes; `/memory some text` saves one.
+
 ## Configuration
 
 Run `min-agent setup` for a guided setup — this is the easiest way to add or switch AI providers.
 
+```bash
+min-agent setup --type ollama
+min-agent setup --type openai-compatible --url https://api.example.com/v1 --api-key "$KEY" --name groq --default-model llama-3.1-70b
+min-agent setup --switch ollama
+```
+
 Settings live in `~/.min-agent/config.json` (global). A project can have its own `.min-agent/config.json` that only applies there.
 
 ## Extending It
@@ -170,6 +192,8 @@ min-agent --provider anthropic "你的消息"
 | `/model` | 切换模型 |
 | `/provider` | 切换服务商 |
 | `/plan` | 切换"计划模式"（只看不改） |
+| `/think` | 选择思考强度 |
+| `/memory` | 开关记忆，或保存一条 |
 | `/undo` | 撤销上一轮操作 |
 | `/diff` | 查看当前已产生的文件改动 |
 | `/sessions` | 查看或切换会话 |
@@ -177,10 +201,11 @@ min-agent --provider anthropic "你的消息"
 | `/mcp` | 查看已连接的 MCP 服务 |
 | `/skills` | 管理技能 |
 | `/tokens` | 查看用量与预估费用 |
+| `/ctx` | 选择本地模型上下文窗口 |
 | `/help` | 查看全部命令 |
 | `/exit` | 退出 |
 
-快捷键：**Ctrl+C** 清空输入框（连按两次退出）· **Ctrl+B** 选中文本以复制 · 也支持鼠标拖拽选中并自动复制。
+快捷键：**Ctrl+C** 清空输入框（连按两次退出）· **Ctrl+V** 粘贴图片 · 多行粘贴会收成片段 · **Ctrl+B** 选中文本以复制 · 也支持鼠标拖拽选中并自动复制 · 点击工具或思考块可展开或收起。
 
 ## 掌控风险
 
@@ -201,10 +226,29 @@ min-agent sandbox off        # 不限制（默认）
 min-agent sandbox workspace  # 仅允许修改当前项目文件夹内的内容
 ```
 
+## 记忆
+
+跨会话记忆默认关闭。需要记住偏好或项目约定时再打开：
+
+```bash
+min-agent memory                 # 查看开关与已保存内容
+min-agent memory on              # 开启记忆（写入配置）
+min-agent --memory on            # 同上；若同时带消息则只对本轮生效
+min-agent memory add "prefer bun"
+```
+
+对话里用 `/memory on` 或 `/memory off` 开关；`/memory` 查看；`/memory 一段话` 保存一条。
+
 ## 配置
 
 运行 `min-agent setup` 即可通过引导式流程完成配置，这是添加或切换 AI 服务商最简单的方式。
 
+```bash
+min-agent setup --type ollama
+min-agent setup --type openai-compatible --url https://api.example.com/v1 --api-key "$KEY" --name groq --default-model llama-3.1-70b
+min-agent setup --switch ollama
+```
+
 配置保存在 `~/.min-agent/config.json`（全局生效）。也可以在某个项目下单独创建 `.min-agent/config.json`，仅对该项目生效。
 
 ## 扩展能力

package/dist/agent.js

@@ -10,7 +10,8 @@ import { scanProject, buildCodeSystemPrompt } from "./code-mode.js";
 import { initMcp, shutdownMcp, getMcpTools, getMcpCatalogTools, getMcpReadOnlyToolIds } from "./mcp.js";
 import { discoverSkills, attachSkills, collectLoadedSkillNames } from "./skills.js";
 import { loadInstructions } from "./instructions.js";
-import { getMemorySystemPrompt, getMemoryTools } from "./memory.js";
+import { resolveThinkingRequest, thinkingRequestStore } from "./thinking.js";
+import { getMemorySystemPrompt, getMemoryTools, isMemoryEnabled } from "./memory.js";
 import { needsCompaction, compactMessages, estimateTokens, estimateStringTokens, estimateOverheadTokens, TokenTracker, COMPACTION_RATIO, PRUNE_PRESSURE_RATIO, PRUNE_TARGET_RATIO, applyToolPrune, pruneToolOutputs, } from "./compaction.js";
 import { loadPluginTools, getPluginReadOnlyIds } from "./plugins.js";
 import { MarkdownRenderer } from "./markdown.js";
@@ -20,6 +21,7 @@ import { XmlSearchSplitter } from "./xml-search.js";
 import { printHeader, printDivider, printToolCall, printToolResult, printDone } from "./output.js";
 import { createTodoTool, captureGoal, copyTaskState, emptyTaskState, formatTaskStatePrompt, } from "./tools/todo.js";
 import { getContextWindowInfo } from "./context-window.js";
+import { formatTokenCount } from "./token-display.js";
 import { log, logToolCall, logToolResult, startRunLog, nextRunPass, endRunLog } from "./logger.js";
 import { markSyntheticMessage, isSyntheticMessage } from "./synthetic.js";
 import { runWithInstructionTracker, resetActiveInstructionTracker } from "./instructions.js";
@@ -90,14 +92,6 @@ function printInitReady() {
     const { dim, reset } = DIM_STYLE;
     console.log(`${dim}✓ 就绪${reset}`);
 }
-/** Stream thinking to stderr (dim). Set MIN_AGENT_SHOW_THINKING=0 to hide. */
-function writeThinkingDelta(text) {
-    if (!text)
-        return;
-    if (process.env.MIN_AGENT_SHOW_THINKING === "0" || process.env.MIN_AGENT_SHOW_THINKING === "false")
-        return;
-    process.stderr.write(`${DIM_STYLE.dim}${text}${DIM_STYLE.reset}`);
-}
 export function loadImageParts(imagePaths, notify) {
     const parts = [];
     for (const imgPath of imagePaths) {
@@ -222,12 +216,12 @@ export function pushTurn(messages, assistantText, toolCalls, toolResults) {
  * once per run avoids re-reading plugin manifests and re-wrapping MCP tools on
  * every continue.
  */
-async function buildRunTools(modelId, abortSignal, planMode, tracker, taskState, subAgent) {
+async function buildRunTools(modelId, abortSignal, planMode, tracker, taskState, subAgent, memory) {
     const builtinTools = createTools();
     builtinTools.todo = createTodoTool({ store: taskState });
     const mcpTools = getMcpTools();
     const catalogTools = getMcpCatalogTools();
-    const memoryTools = getMemoryTools();
+    const memoryTools = isMemoryEnabled(memory) ? getMemoryTools() : {};
     const pluginTools = await loadPluginTools();
     const allTools = {
         ...builtinTools,
@@ -262,28 +256,48 @@ async function buildRunTools(modelId, abortSignal, planMode, tracker, taskState,
     }
     return allTools;
 }
-function buildIterationPrompts(allTools, messages, taskState, loopGuard) {
+function buildIterationPrompts(allTools, messages, taskState, loopGuard, memory) {
     const skillsPrompt = attachSkills(allTools, collectLoadedSkillNames(messages));
     return {
         stable: [skillsPrompt].filter((s) => s.length > 0),
-        volatile: [getMemorySystemPrompt(), formatTaskStatePrompt(taskState), loopGuard.promptHint()].filter((s) => s.length > 0),
+        volatile: [getMemorySystemPrompt(memory), formatTaskStatePrompt(taskState), loopGuard.promptHint()].filter((s) => s.length > 0),
     };
 }
 /** Ephemeral per-request message carrying the volatile prompt sections. */
-export const SESSION_STATE_HEADER = "## Session state (current, not part of the conversation)";
+export const SESSION_STATE_HEADER = "## Session state (reference only — not a to-do list, not part of the conversation)";
 function sessionStateMessage(volatile) {
     if (volatile.length === 0)
         return null;
     return { role: "system", content: [SESSION_STATE_HEADER, ...volatile].join("\n\n") };
 }
+export function parseContextOverflow(msg) {
+    if (!isContextOverflowError(msg))
+        return null;
+    const prompt = msg.match(/n_prompt_tokens["\s:=]+(\d+)/i)?.[1] ?? msg.match(/request\s*\((\d+)\s*tokens?\)/i)?.[1];
+    const ctx = msg.match(/n_ctx["\s:=]+(\d+)/i)?.[1] ?? msg.match(/context size\s*\((\d+)\s*tokens?\)/i)?.[1];
+    return {
+        ...(prompt ? { promptTokens: Number(prompt) } : {}),
+        ...(ctx ? { ctxTokens: Number(ctx) } : {}),
+    };
+}
+function formatContextOverflowMessage(msg) {
+    const info = parseContextOverflow(msg);
+    const prompt = info?.promptTokens != null ? formatTokenCount(info.promptTokens) : null;
+    const ctx = info?.ctxTokens != null ? formatTokenCount(info.ctxTokens) : null;
+    if (prompt && ctx)
+        return `请求内容约 ${prompt} token，超过当前上下文窗口 ${ctx}。请把窗口调大后再试。`;
+    return "请求内容超过当前上下文窗口。请把窗口调大后再试。";
+}
 function formatErrorMessage(msg) {
+    if (isContextOverflowError(msg))
+        return formatContextOverflowMessage(msg);
     if (msg.includes("API key") || msg.includes("Unauthorized") || msg.includes("Forbidden")) {
         return "Authentication error: Check your API key.";
     }
     if (msg.includes("429") || msg.includes("rate limit") || msg.includes("Rate limit")) {
         return "Rate limited after retries. Please wait and try again.";
     }
-    if (msg.includes("timeout") || msg.includes("ETIMEDOUT") || msg.includes("ECONNRESET")) {
+    if (msg.includes("timeout") || msg.includes("ETIMEDOUT")) {
         return `Network error (retries exhausted): ${msg}`;
     }
     return msg;
@@ -299,7 +313,7 @@ function safeText(value) {
     }
 }
 function isContextOverflowError(msg) {
-    return /context[\s_-]*(length|window|size)|context_length_exceeded|maximum context|too many tokens|prompt (is )?too long|reduce the (prompt )?length|token limit exceeded/i.test(msg);
+    return /exceed_context_size_error|context[\s_-]*(length|window|size)|context_length_exceeded|maximum context|too many tokens|prompt (is )?too long|reduce the (prompt )?length|token limit exceeded/i.test(msg);
 }
 function invokeCallback(fn, ...args) {
     if (!fn)
@@ -518,7 +532,7 @@ async function runOnceCoreLoop(messages, systemPrompt, modelId, abortSignal, cal
     const allTools = await buildRunTools(modelId, abortSignal, options?.planMode ?? false, tracker, taskState, {
         loopGuard,
         shouldStop: () => checkBudget() || overTurnBudget(totalSteps),
-    });
+    }, options?.memory);
     const finish = async (opts) => {
         log("info", `run end steps=${totalSteps} continues=${continues} tokens_in=${lastUsage?.inputTokens ?? 0} tokens_out=${lastUsage?.outputTokens ?? 0}`);
         endRunLog();
@@ -592,6 +606,12 @@ async function runOnceCoreLoop(messages, systemPrompt, modelId, abortSignal, cal
                 temperature,
                 maxTokens,
                 topP,
+                thinking: options?.thinking,
+                memory: options?.memory,
+                providerType: (options?.providerName
+                    ? cfg.providers?.find((p) => p.name === options.providerName)
+                    : getActiveProvider(cfg))?.type,
+                modelId,
                 checkBudget,
                 overTurnBudget: (stepsInPass) => overTurnBudget(totalSteps + stepsInPass),
                 pruneBudget,
@@ -607,7 +627,7 @@ async function runOnceCoreLoop(messages, systemPrompt, modelId, abortSignal, cal
             log("error", msg);
             hasError = true;
             if (cbs.onStreamError)
-                invokeCallback(cbs.onStreamError, msg);
+                invokeCallback(cbs.onStreamError, formatErrorMessage(msg));
             else
                 console.error(`\x1b[31m${formatErrorMessage(msg)}\x1b[0m`);
             return finish({ aborted: Boolean(abortSignal?.aborted), maxStepsReached: false });
@@ -631,6 +651,25 @@ async function runOnceCoreLoop(messages, systemPrompt, modelId, abortSignal, cal
             applyToolPrune(messages, pruneBudget());
             continue;
         }
+        // Prompt (system + tools + messages) does not fit the loaded window.
+        // Retrying the same request cannot help; compaction only helps if history is long.
+        if (inner.contextPressure && inner.stepCount === 0 && !inner.lastStepHadTools) {
+            const compacted = await applyCompaction(messages, model, tracker, cbs, callbacks, { ...compactCfg, force: true }, pruneBudget());
+            if (compacted) {
+                continues++;
+                if (continues > maxContinues) {
+                    return finish({ aborted: false, maxStepsReached: true, incomplete: true });
+                }
+                continue;
+            }
+            hasError = true;
+            const display = formatErrorMessage(inner.overflowError ?? "");
+            if (cbs.onStreamError)
+                invokeCallback(cbs.onStreamError, display);
+            else
+                console.error(`\x1b[31m${display}\x1b[0m`);
+            return finish({ aborted: false, maxStepsReached: false });
+        }
         // The provider produced nothing at all (no text, no reasoning-backed reply,
         // no tool call): a transport / gateway hiccup rather than model intent.
         // Re-send the same request with backoff instead of nudging the model.
@@ -795,6 +834,8 @@ class StreamRenderer {
     thinkingSplit = new ThinkingBodySplitter();
     xmlSplit = new XmlSearchSplitter();
     rawText = "";
+    hadThinking = false;
+    thinkingOpen = false;
     constructor(cbs, interactive) {
         this.cbs = cbs;
         this.interactive = interactive;
@@ -802,10 +843,18 @@ class StreamRenderer {
     emitThinking(t) {
         if (!t)
             return;
-        if (this.cbs.onThinkingDelta)
+        this.hadThinking = true;
+        if (this.cbs.onThinkingDelta) {
             invokeCallback(this.cbs.onThinkingDelta, t);
-        else
-            writeThinkingDelta(t);
+            return;
+        }
+        if (process.env.MIN_AGENT_SHOW_THINKING === "0" || process.env.MIN_AGENT_SHOW_THINKING === "false")
+            return;
+        if (!this.thinkingOpen) {
+            this.thinkingOpen = true;
+            process.stderr.write(`\n${DIM_STYLE.dim}💭 思考${DIM_STYLE.reset}\n`);
+        }
+        process.stderr.write(`${DIM_STYLE.dim}${t}${DIM_STYLE.reset}`);
     }
     emitDisplay(delta) {
         try {
@@ -919,6 +968,7 @@ class InnerStreamMachine {
     stepFinishSeen = false;
     stepUsage;
     totalUsage;
+    overflowError;
     constructor(params) {
         this.params = params;
         this.assembler = new TurnAssembler(params.messages, (info) => {
@@ -1132,8 +1182,9 @@ class InnerStreamMachine {
                     this.totalUsage = event.totalUsage;
                 return false;
             case "reasoning-delta": {
-                if (event.text)
-                    this.renderer.feedReasoning(event.text);
+                const text = typeof event.text === "string" ? event.text : "";
+                if (text)
+                    this.renderer.feedReasoning(text);
                 return false;
             }
             case "text-delta": {
@@ -1192,6 +1243,7 @@ class InnerStreamMachine {
                 }
                 if (isContextOverflowError(errorMsg)) {
                     this.stop.context = true;
+                    this.overflowError = errorMsg;
                     log("warn", `context overflow: ${errorMsg}`);
                     await this.flushOutputAndStep();
                     this.innerController.abort();
@@ -1200,7 +1252,7 @@ class InnerStreamMachine {
                 this.hasError = true;
                 log("error", `stream error: ${errorMsg}`);
                 if (cbs.onStreamError)
-                    invokeCallback(cbs.onStreamError, errorMsg);
+                    invokeCallback(cbs.onStreamError, formatErrorMessage(errorMsg));
                 else
                     console.error(`\x1b[31m${formatErrorMessage(errorMsg)}\x1b[0m`);
                 return false;
@@ -1222,7 +1274,8 @@ class InnerStreamMachine {
             wrapUp: this.stop.wrapUp,
             lastStepHadTools: this.assembler.lastStepHadTools,
             xmlToolFollowUp: this.xmlSearchRecovered && !this.answerAfterXml && !this.stop.doom,
-            emptyCompletion: !this.assembler.hadAssistantText && !this.assembler.hadTools && !this.xmlSearchRecovered,
+            emptyCompletion: !this.stop.context && !this.assembler.hadAssistantText && !this.assembler.hadTools && !this.xmlSearchRecovered,
+            overflowError: this.overflowError,
             providerStall: this.stop.stall,
             stepCount: this.assembler.innerSteps,
             usage,
@@ -1247,7 +1300,7 @@ class InnerStreamMachine {
             // The provider went quiet and we cut the request. Nothing was produced →
             // let the empty-reply retry path re-send it; otherwise keep the partial
             // turn and continue like any other tool-only step.
-            const produced = this.assembler.hadAssistantText || this.assembler.hadTools;
+            const produced = this.assembler.hadAssistantText || this.assembler.hadTools || this.renderer.hadThinking;
             log("warn", `provider stall: ${describeError(err)}`);
             this.stop.stall = true;
             return this.snapshot(usage, { hasError: false, userAborted: false, emptyCompletion: !produced });
@@ -1259,12 +1312,13 @@ class InnerStreamMachine {
         log("error", msg);
         if (isContextOverflowError(msg)) {
             this.stop.context = true;
+            this.overflowError = msg;
             return this.snapshot(usage, { hasError: false, contextPressure: true, userAborted: false });
         }
         this.hasError = true;
         const display = formatErrorMessage(msg);
         if (this.params.cbs.onStreamError)
-            invokeCallback(this.params.cbs.onStreamError, msg);
+            invokeCallback(this.params.cbs.onStreamError, display);
         else if (display !== msg)
             console.error(`\x1b[31m${display}\x1b[0m`);
         else
@@ -1277,7 +1331,7 @@ async function runInnerStream(params) {
     let result;
     try {
         machine.attachAbort();
-        const prompts = buildIterationPrompts(params.allTools, params.messages, params.taskState, params.loopGuard);
+        const prompts = buildIterationPrompts(params.allTools, params.messages, params.taskState, params.loopGuard, params.memory);
         const system = [params.systemPrompt, ...prompts.stable].join("\n\n");
         applyToolPrune(params.messages, params.pruneBudget());
         // Volatile state rides along as a trailing message so the cached prefix
@@ -1287,7 +1341,12 @@ async function runInnerStream(params) {
         params.overhead.tokens =
             estimateOverheadTokens(system, params.allTools) +
                 (stateMessage ? estimateOverheadTokens(String(stateMessage.content)) : 0);
-        result = streamText({
+        const thinking = resolveThinkingRequest({
+            runOverride: params.thinking,
+            providerType: params.providerType,
+            modelId: params.modelId,
+        });
+        const startStream = () => streamText({
             model: params.model,
             system,
             messages: requestMessages,
@@ -1305,6 +1364,7 @@ async function runInnerStream(params) {
                 machine.onStepError(error);
             },
         });
+        result = thinkingRequestStore.run(thinking, startStream);
         for await (const event of result.fullStream) {
             if (await machine.handleEvent(event))
                 break;

package/dist/cli/commands/chat.js

@@ -1,5 +1,8 @@
 import { startTuiSession } from "./shared.js";
+import { applySessionOverrides, applySessionRuntimeOverrides } from "../program.js";
 export async function runChat(promptTokens, opts) {
+    applySessionOverrides(opts);
+    await applySessionRuntimeOverrides(opts);
     await startTuiSession({
         model: opts.model,
         provider: opts.provider,

package/dist/cli/commands/ctx.js

@@ -0,0 +1,7 @@
+import { runCtxCli } from "../../ctx-cli.js";
+export async function runCtxCommand(args) {
+    const result = runCtxCli({ positionals: args });
+    console.log(result.lines.join("\n"));
+    if (!result.ok)
+        process.exitCode = 1;
+}

package/dist/cli/commands/exec.js

@@ -2,10 +2,13 @@ import { runAgent } from "../../agent.js";
 import { isConfigured } from "../../config.js";
 import { resolveExecPrompt } from "../exec-prompt.js";
 import { CliError } from "../errors.js";
+import { applySessionOverrides, applySessionRuntimeOverrides } from "../program.js";
 export async function runExec(messageTokens, opts) {
     if (!isConfigured()) {
         throw new CliError("Not configured.", { hint: "Run: min-agent setup" });
     }
+    applySessionOverrides(opts);
+    await applySessionRuntimeOverrides(opts);
     const stdinIsTty = Boolean(process.stdin.isTTY);
     const joined = messageTokens.join(" ");
     const shouldReadStdin = joined === "-" || !stdinIsTty;

package/dist/cli/commands/index.js

@@ -1,22 +1,24 @@
 import { Option } from "commander";
 import { resolveScope, parsePositiveIntArg } from "../option-helpers.js";
-import { runSetupCommand } from "./setup.js";
+import { registerSetupCommand } from "./setup.js";
 import { runModelsCommand } from "./models.js";
 import { runChat } from "./chat.js";
 import { runExec } from "./exec.js";
 import { runServeCommand } from "./serve.js";
 import { runSandboxCommand } from "./sandbox.js";
 import { runPermissionCommand } from "./permission.js";
+import { runThinkCommand } from "./think.js";
+import { runCtxCommand } from "./ctx.js";
 import { runInitCommand } from "./init.js";
 import { runRulesShow, runRulesEdit } from "./rules.js";
 import { runUpdateCommand } from "./update.js";
 import { runHistoryList, runHistoryDelete, runHistoryRename, runHistoryExport } from "./history.js";
-import { runMemoryList, runMemoryAdd, runMemorySearch, runMemoryDelete } from "./memory.js";
+import { runMemoryList, runMemoryAdd, runMemorySearch, runMemoryDelete, runMemoryMode } from "./memory.js";
 import { runMcpAdd, runMcpRemove, runMcpList, runMcpInfo, runMcpCheck, runMcpToggle, } from "./mcp.js";
 import { runSkillsList, runSkillsInfo, runSkillsToggle, runSkillsNew } from "./skills.js";
 /**
  * All `--project`/`--global`/`--model`/`--provider`/`--resume`/`--image`/`--sandbox`/
- * `--network`/`--permission` flags live on the root `program` (see addSessionOptions),
+ * `--network`/`--permission`/`--think`/`--memory` flags live on the root `program` (see addSessionOptions),
  * so they can appear before or after a subcommand name. Subcommands read them via
  * `program.opts<SessionOptions>()` instead of re-declaring the same options — commander
  * resolves options against the first command in the chain that declares them, so a
@@ -44,7 +46,7 @@ export function registerCommands(program) {
         await runExec(message, rootOpts());
     });
     // --- Setup & config ----------------------------------------------------
-    program.command("setup").description("Configure providers (interactively)").action(runSetupCommand);
+    registerSetupCommand(program, rootOpts);
     program.command("init").description("Initialize .min-agent/ in current directory").action(runInitCommand);
     program
         .command("models")
@@ -55,10 +57,18 @@ export function registerCommands(program) {
     const rules = program.command("rules").description("Show or edit instruction rules");
     rules.action(runRulesShow);
     rules.command("edit").description("Edit the global rules file").action(runRulesEdit);
-    const memory = program.command("memory").description("Manage saved memories (uses --project/--global)");
-    memory.action(async () => {
+    const memory = program.command("memory").description("Show or set memory, and manage saved memories");
+    memory.argument("[state]", "on or off");
+    memory.action(async (state) => {
         const opts = rootOpts();
-        await runMemoryList(opts.project ? "project" : opts.global ? "global" : undefined);
+        const scope = opts.project ? "project" : opts.global ? "global" : undefined;
+        if (await runMemoryMode(state, scope, opts.memory))
+            return;
+        if (state && state !== "list") {
+            const { CliError } = await import("../errors.js");
+            throw new CliError("Usage: min-agent memory [on|off|list|add|search|delete] [--project|--global]");
+        }
+        await runMemoryList(scope);
     });
     memory
         .command("add")
@@ -108,6 +118,21 @@ export function registerCommands(program) {
         const opts = rootOpts();
         await runPermissionCommand(mode ? [mode] : [], opts, opts);
     });
+    program
+        .command("think")
+        .description("Show or set thinking intensity (uses --project/--global)")
+        .argument("[level]", "off, low, medium, high, or max")
+        .action(async (level) => {
+        const opts = rootOpts();
+        await runThinkCommand(level ? [level] : [], opts, opts);
+    });
+    program
+        .command("ctx")
+        .description("Show or set the Ollama context window level")
+        .argument("[level]", "2k, 4k, 8k, 12k, 16k, 32k, 64k, 128k, 256k, or auto")
+        .action(async (level) => {
+        await runCtxCommand(level ? [level] : []);
+    });
     // --- Integrations --------------------------------------------------------
     const mcp = program.command("mcp").description("Manage MCP servers");
     mcp

package/dist/cli/commands/memory.js

@@ -1,4 +1,5 @@
-import { loadMemories, addMemory, deleteMemory, searchMemories, defaultMemoryScope, } from "../../memory.js";
+import { loadMemories, addMemory, deleteMemory, searchMemories, defaultMemoryScope, formatMemoryLine, parseMemoryMode, resolveMemoryMode, memoryModeLabel, memorySourceLabel, isMemoryEnabled, } from "../../memory.js";
+import { runMemoryCli } from "../../memory-cli.js";
 import { CliError } from "../errors.js";
 function printList(which) {
     const memories = loadMemories(which);
@@ -8,23 +9,42 @@ function printList(which) {
         return;
     }
     console.log(`${label} (${memories.length}):`);
-    for (let i = 0; i < memories.length; i++) {
-        const m = memories[i];
-        const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
-        const date = m.created.split("T")[0];
-        console.log(`  #${i + 1}: ${m.content}${tags} (${date})`);
+    for (const line of memories.map((m, i) => formatMemoryLine(m, i, { date: true }))) {
+        console.log(line);
     }
 }
+export async function runMemoryMode(state, scope, flagMode) {
+    if (!state && flagMode === undefined)
+        return false;
+    if (state && state !== "list" && !parseMemoryMode(state))
+        return false;
+    if (state === "list")
+        return false;
+    const result = runMemoryCli({
+        positionals: state ? [state] : [],
+        flagMode,
+        scope,
+    });
+    console.log(result.lines.join("\n"));
+    if (!result.ok)
+        process.exitCode = 1;
+    return true;
+}
 export async function runMemoryList(scope) {
+    const { memory, source } = resolveMemoryMode();
+    console.log(`Current memory: ${memoryModeLabel(memory)} (${memorySourceLabel(source)})`);
     if (!scope && loadMemories("project").length === 0 && loadMemories("global").length === 0) {
         console.log("No memories stored.");
-        console.log("The agent will automatically save memories during conversations.");
+        if (!isMemoryEnabled())
+            console.log("Turn on with: min-agent memory on");
         console.log('Or add manually: min-agent memory add "prefer TypeScript over JavaScript"');
         return;
     }
     const scopes = scope ? [scope] : ["project", "global"];
     for (const s of scopes)
         printList(s);
+    if (!isMemoryEnabled())
+        console.log("Memories are stored but not used in chat until you run: min-agent memory on");
 }
 export async function runMemoryAdd(textTokens, scope) {
     const text = textTokens.join(" ");
@@ -32,20 +52,18 @@ export async function runMemoryAdd(textTokens, scope) {
         throw new CliError("Usage: min-agent memory add <text> [--project|--global]");
     const resolved = scope ?? defaultMemoryScope();
     addMemory(text, [], resolved);
-    console.log(`✓ ${resolved === "project" ? "Project" : "Global"} memory saved: "${text}"`);
+    const hint = isMemoryEnabled() ? "" : " (memory is off — turn on with: min-agent memory on)";
+    console.log(`✓ ${resolved === "project" ? "Project" : "Global"} memory saved: "${text}"${hint}`);
 }
 export async function runMemorySearch(queryTokens, scope) {
     const query = queryTokens.join(" ");
     if (!query)
         throw new CliError("Usage: min-agent memory search <query> [--project|--global]");
     const scopes = scope ? [scope] : ["project", "global"];
-    const lines = [];
-    for (const s of scopes) {
-        for (const m of searchMemories(query, s)) {
-            const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
-            lines.push(`  [${s}] #${m.index + 1}: ${m.content}${tags}`);
-        }
-    }
+    const lines = scopes.flatMap((s) => searchMemories(query, s).map((m) => {
+        const tags = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+        return `  [${s}] #${m.index + 1}: ${m.content}${tags}`;
+    }));
     if (lines.length === 0) {
         console.log(`No memories matching "${query}"`);
     }

package/dist/cli/commands/setup.js

@@ -1,4 +1,56 @@
-import { runSetup } from "../../config.js";
-export async function runSetupCommand() {
-    await runSetup();
+import path from "path";
+import { Option } from "commander";
+import { fetchModelsLive, getConfigDir, loadConfig, saveConfig } from "../../config.js";
+import { parsePositiveIntArg } from "../option-helpers.js";
+import { parseProviderType } from "../setup/flags.js";
+import { runSetup } from "../setup/flow.js";
+export function registerSetupCommand(program, rootOpts) {
+    program
+        .command("setup")
+        .description("Configure providers (interactively, or with flags)")
+        .addOption(new Option("--type <type>", "openai-compatible, openai, or ollama").argParser(parseProviderType))
+        .option("--url <url>", "API base URL")
+        .option("--api-key <key>", "API key")
+        .option("--name <name>", "Provider name")
+        .option("--default-model <id>", "Default model to save")
+        .addOption(new Option("--context-window <n>", "Context window in tokens").argParser(parsePositiveIntArg("--context-window")))
+        .option("--switch <name>", "Set the active provider")
+        .option("--remove <name>", "Remove a provider")
+        .option("-y, --yes", "Skip overwrite and delete confirmation")
+        .action(async (opts) => {
+        await runSetupCommand(opts, { yes: Boolean(opts.yes || rootOpts().yes) });
+    });
+}
+function createSetupDeps() {
+    return {
+        isTty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        load: loadConfig,
+        save: saveConfig,
+        fetchLive: fetchModelsLive,
+        log: (message) => {
+            console.log(message);
+        },
+        configPath: () => path.join(getConfigDir(), "config.json"),
+        runWizard: async (wizardMode) => {
+            const { renderSetupWizard } = await import("../setup/ui.js");
+            return renderSetupWizard(wizardMode);
+        },
+    };
+}
+export async function offerInteractiveSetup(mode) {
+    await runSetup({}, { ...createSetupDeps(), isTty: true }, mode);
+}
+export async function runSetupCommand(opts, session) {
+    const flags = {
+        type: opts.type,
+        url: opts.url,
+        apiKey: opts.apiKey,
+        name: opts.name,
+        defaultModel: opts.defaultModel,
+        contextWindow: opts.contextWindow,
+        switch: opts.switch,
+        remove: opts.remove,
+        yes: Boolean(session.yes || opts.yes),
+    };
+    await runSetup(flags, createSetupDeps());
 }