@jpssff/vanor 0.1.0 → 0.1.1

package/README-cn.md

@@ -135,7 +135,7 @@ Vanor 使用三层记忆：
 | 层级 | 说明 |
 |------|------|
 | 短期 | 当前会话消息，存于 `sessions/`；压缩后内存只保留摘要与最近消息，但磁盘保留完整历史 |
-| 长期 | `memory/MEMORY.md` 与 `memory/USER.md`，记录环境事实和用户偏好 |
+| 长期 | `memory/MEMORY.md` 与 `memory/USER.md`，记录环境事实和用户偏好；每个主文件限制 10KB，过多时用索引指向 `MEMORY-xxx.md` / `USER-xxx.md` |
 | 工作 | `memory/working/`，保存任务中的计划和中间状态 |
 
 会话恢复优先读取 `state.json` 中当前工作区的最近 session id，避免 session 文件过多时启动扫描变慢。若索引失效，再回退扫描 `sessions/`。

package/README.md

@@ -106,7 +106,7 @@ Vanor asks before potentially risky tool actions by default. `/auto-run` only ch
 ~/.vanor/config.json   provider, model, security, logging config
 ~/.vanor/state.json    latest session index per workspace
 ~/.vanor/sessions/     JSONL session history
-~/.vanor/memory/       long-term and working memory
+~/.vanor/memory/       long-term and working memory; MEMORY.md / USER.md are 10KB index files
 ~/.vanor/skills/       user skills
 ~/.vanor/logs/         JSONL logs
 ```

package/base/config.js

@@ -15,13 +15,13 @@ export const DEFAULT_CONFIG = {
     fallback: [],
   },
   agent: {
-    maxIterations: 25,
+    maxIterations: 200,
     thinking: "off",
     contextWindow: 256000,
   },
   memory: {
-    memoryMaxChars: 2200,
-    userMaxChars: 1375,
+    memoryMaxChars: 10240,
+    userMaxChars: 10240,
     compactThreshold: 0.75,
   },
   security: {

package/base/core/harness.js

@@ -14,6 +14,7 @@ import { buildSystemPrompt } from "./prompt.js";
 import { latestSession, saveLatestSessionId, Session } from "./session.js";
 import { runLoop } from "./loop.js";
 import { compact } from "./compaction.js";
+import { createVanorTool } from "./vanor_tool.js";
 
 export function createHarness({ config, paths, logger, channel = "cli", sessionId, restoreLatest = false }) {
   let configState = config;
@@ -50,9 +51,25 @@ export function createHarness({ config, paths, logger, channel = "cli", sessionI
     registry = defaultRegistry(i18n);
     registry.register(memory.tool);
     registry.register(createSkillsTool(paths, logger, { getSkills: () => skills, reloadSkills, getI18n: () => i18n }));
+    registry.register(createVanorTool(vanorRuntime(), i18n));
     reloadSkills();
   }
 
+  function vanorRuntime() {
+    return {
+      getModel: () => model,
+      setModel,
+      getConfig: () => configState,
+      getSession: () => session,
+      getSecurity: () => security,
+      getI18n: () => i18n,
+      getSkills: () => skills,
+      reloadSkills,
+      reloadConfig,
+      setLanguage,
+    };
+  }
+
   rebuildRuntime(configState);
 
   let model = configState.llm.defaultModel;
@@ -155,6 +172,7 @@ export function createHarness({ config, paths, logger, channel = "cli", sessionI
         toolCtx,
         config: configState,
         model,
+        getModel: () => model,
         tools: registry.schemas(),
         buildSystem,
         logger,

package/base/core/loop.js

@@ -15,11 +15,12 @@ import { shouldCompact, compact } from "./compaction.js";
  * @returns {Promise<{assistant?, aborted?, error?, maxIterations?}>}
  */
 export async function runLoop(session, deps, handlers = {}, signal) {
-  const { llm, registry, toolCtx, config, model, tools, buildSystem, logger } = deps;
+  const { llm, registry, toolCtx, config, tools, buildSystem, logger } = deps;
   const maxIter = config.agent?.maxIterations ?? 25;
-  logger.info(EVENTS.agent.turnStart, { model, sessionId: session.id });
+  logger.info(EVENTS.agent.turnStart, { model: deps.getModel?.() || deps.model, sessionId: session.id });
 
   for (let i = 0; i < maxIter; i++) {
+    const model = deps.getModel?.() || deps.model;
     if (signal?.aborted) {
       logger.info(EVENTS.agent.turnAborted, { iteration: i });
       return { aborted: true };
@@ -64,7 +65,12 @@ export async function runLoop(session, deps, handlers = {}, signal) {
     const results = await runToolCalls(toolCalls, registry, toolCtx, handlers.onToolResult);
     for (const r of results) session.addMessage(r);
 
-    if (shouldCompact(session, config)) await compact(session, deps);
+    if (signal?.aborted) {
+      logger.info(EVENTS.agent.turnAborted, { iteration: i, phase: "tools" });
+      return { aborted: true };
+    }
+
+    if (shouldCompact(session, config)) await compact(session, { ...deps, model: deps.getModel?.() || deps.model });
   }
 
   logger.warn(EVENTS.agent.turnMaxIterations, { maxIter });

package/base/core/prompt.js

@@ -2,7 +2,6 @@
 
 import os from "node:os";
 import { createI18n } from "../i18n/index.js";
-import { nowIso } from "../utils.js";
 import { renderSkills } from "../skills/loader.js";
 import { systemMessage } from "../transport/message.js";
 
@@ -34,7 +33,7 @@ function runtimeEnv(workspaceRoot, t) {
     t("prompt.node", { version: process.version }),
     t("prompt.shell", { shell }),
     t("prompt.workspace", { workspace: workspaceRoot }),
-    t("prompt.time", { time: nowIso(), timezone: tz, offset: tzOffset() }),
+    t("prompt.timezone", { timezone: tz, offset: tzOffset() }),
   ].join("\n");
 }
 
@@ -90,6 +89,7 @@ export function buildSystemPrompt({ memory, skills, summary, workspaceRoot, chan
   const parts = [t("prompt.persona"), t("prompt.language")];
   parts.push(runtimeEnv(workspaceRoot, t));
   if (instance) parts.push(vanorContext(instance, t));
+  parts.push(t("prompt.memoryPolicy"));
   const guide = channel === "cli" ? t("prompt.channelCli") : t("prompt.channelDefault");
   parts.push(t("prompt.communication", { guide }));
 

package/base/core/vanor_tool.js

@@ -0,0 +1,178 @@
+import { createI18n } from "../i18n/index.js";
+import { summarizeSkills } from "../skills/loader.js";
+import { listUserMessages } from "./session.js";
+
+const defaultI18n = createI18n("en");
+
+function ok(content) {
+  return { content: String(content) };
+}
+
+function fail(content) {
+  return { content: String(content), isError: true };
+}
+
+function parseCommand(input) {
+  const raw = String(input || "").trim();
+  if (!raw) return { raw, cmd: "", arg: "" };
+  const slash = raw.startsWith("/") ? raw : `/${raw}`;
+  const [cmd, ...rest] = slash.slice(1).split(/\s+/);
+  return { raw: slash, cmd, arg: rest.join(" ").trim() };
+}
+
+function availableModels(config, currentModel = "") {
+  const out = [];
+  const seen = new Set();
+  const add = (model) => {
+    const value = String(model || "").trim();
+    if (!value || seen.has(value)) return;
+    seen.add(value);
+    out.push(value);
+  };
+
+  add(currentModel);
+  add(config.llm?.defaultModel);
+  for (const model of config.llm?.fallback || []) add(model);
+
+  for (const [providerName, provider] of Object.entries(config.llm?.providers || {})) {
+    for (const model of provider.models || []) {
+      const id = typeof model === "string" ? model : model?.id || model?.name || "";
+      if (!id) continue;
+      add(id.startsWith(`${providerName}/`) ? id : `${providerName}/${id}`);
+    }
+  }
+  return out;
+}
+
+function searchModels(models, query) {
+  const q = String(query || "").trim().toLowerCase();
+  if (!q) return models;
+  return models.filter((model) => model.toLowerCase().includes(q));
+}
+
+function formatUserMessage(message) {
+  const content = String(message.content || "").replace(/\s+/g, " ").trim();
+  return `${String(message.time || "").slice(0, 19)}  ${content}`;
+}
+
+export function createVanorTool(runtime, i18n = defaultI18n) {
+  const currentI18n = () => runtime.getI18n?.() || i18n;
+  const t = (key, vars) => currentI18n().t(key, vars);
+
+  return {
+    name: "vanor",
+    description: t("vanor.toolDescription"),
+    danger(args = {}) {
+      const { cmd, arg } = parseCommand(args.command);
+      if (cmd === "auto-run" && arg !== "off") return "confirm";
+      return "safe";
+    },
+    parameters: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: t("vanor.paramCommand") },
+      },
+      required: ["command"],
+    },
+    async handler(args) {
+      const { raw, cmd, arg } = parseCommand(args.command);
+      if (!cmd) return fail(t("vanor.emptyCommand"));
+
+      switch (cmd) {
+        case "help":
+          return ok(t("vanor.help"));
+        case "model":
+          return runModel(arg);
+        case "language":
+          return runLanguage(arg);
+        case "reload":
+          return runReload();
+        case "auto-run":
+          return runAutoRun(arg);
+        case "usage":
+          return runUsage();
+        case "messages":
+          return runMessages();
+        case "skills":
+          return runSkills();
+        case "exit":
+        case "quit":
+        case "retry":
+        case "new":
+        case "reset":
+        case "compact":
+          return fail(t("vanor.unsupportedCommand", { command: raw }));
+        default:
+          return fail(t("vanor.unknownCommand", { command: raw }));
+      }
+    },
+  };
+
+  function runModel(arg) {
+    if (!arg) return ok(t("vanor.currentModel", { model: runtime.getModel() }));
+    const models = availableModels(runtime.getConfig(), runtime.getModel());
+    const matches = searchModels(models, arg);
+    const exact = matches.find((model) => model.toLowerCase() === arg.toLowerCase());
+    const target = exact || (matches.length === 1 ? matches[0] : "");
+    if (!target && matches.length > 1) {
+      return ok(t("vanor.modelMatches", { count: matches.length, models: matches.map((m, i) => `${i + 1}. ${m}`).join("\n") }));
+    }
+    try {
+      const next = runtime.setModel(target || arg);
+      return ok(t("vanor.modelChanged", { model: next }));
+    } catch (e) {
+      const suffix = models.length ? `\n${t("vanor.availableModels", { models: models.map((m) => `- ${m}`).join("\n") })}` : "";
+      return fail(t("vanor.modelSwitchFailed", { message: e.message }) + suffix);
+    }
+  }
+
+  function runLanguage(arg) {
+    const lang = currentI18n();
+    if (!arg) return ok(t("vanor.languageCurrent", { language: lang.language, configured: lang.configured || "auto", source: lang.source || "" }));
+    try {
+      const next = runtime.setLanguage(arg);
+      return ok(next.t("vanor.languageChanged", { language: next.language, configured: next.configured || "auto", source: next.source || "" }));
+    } catch (e) {
+      return fail(e.message);
+    }
+  }
+
+  function runReload() {
+    const r = runtime.reloadConfig({ force: true });
+    if (r.error) return fail(t("vanor.reloadFailed", { error: r.error }));
+    if (r.reloaded) return ok(t("vanor.reloadDone", { model: runtime.getModel() }));
+    return ok(t("vanor.reloadUnchanged"));
+  }
+
+  function runAutoRun(arg) {
+    if (arg === "off") {
+      runtime.getSecurity().setApproval(runtime.getSecurity().initialApproval);
+      return ok(t("vanor.approvalRestored", { approval: runtime.getSecurity().approval }));
+    }
+    if (arg && arg !== "on") return fail(t("vanor.autoRunUsage"));
+    runtime.getSecurity().setApproval("auto");
+    return ok(t("vanor.autoRunEnabled"));
+  }
+
+  function runUsage() {
+    const usage = runtime.getSession().usage;
+    return ok(t("vanor.usage", { prompt: usage.promptTokens, completion: usage.completionTokens, total: usage.totalTokens }));
+  }
+
+  function runMessages() {
+    const session = runtime.getSession();
+    const messages = listUserMessages(session.paths, session.id);
+    if (!messages.length) return ok(t("vanor.messagesNone"));
+    return ok([t("vanor.messagesHeader"), ...messages.map(formatUserMessage)].join("\n"));
+  }
+
+  function runSkills() {
+    runtime.reloadSkills();
+    const skills = runtime.getSkills();
+    const summary = summarizeSkills(skills);
+    const lines = skills.map((s) => `- ${s.name}: ${s.description}`);
+    lines.push("", t("vanor.skillsTotal", { count: summary.total }));
+    for (const item of summary.byDir) lines.push(`- ${item.dir}: ${item.count}`);
+    return ok(lines.join("\n"));
+  }
+}

package/base/i18n/locales/en.js

@@ -176,11 +176,13 @@ export default {
     describeWriteFile: "Write file: {path}",
     describeEditFile: "Edit file: {path}",
     describeSkills: "Manage skills: {action}{name}",
+    describeVanor: "Run Vanor command: {command}",
     describeGeneric: "Call tool {name}",
     unknownTool: "Unknown tool: {name}",
     invalidArgs: "Invalid arguments: {errors}",
     denied: "The operation was denied by the user or policy",
     exception: "Tool exception: {message}",
+    aborted: "Tool execution was interrupted",
   },
   builtin: {
     readFileDescription: "Read text content from a workspace file, optionally by line offset/limit.",
@@ -209,6 +211,34 @@ export default {
     noOutput: "(no output)",
     exitCode: "[exit code {code}]",
   },
+  vanor: {
+    toolDescription:
+      "Run Vanor slash commands without leaving the conversation. Supports runtime commands such as /model, /language, /reload, /auto-run, /usage, /messages, /skills, and /help.",
+    paramCommand: 'Slash command to run, for example "/model deepseek", "/language zh-CN", "/reload", or "/auto-run off".',
+    emptyCommand: "command is required",
+    help:
+      "Supported Vanor commands: /model [query], /language [auto|en|zh-CN], /reload, /auto-run [on|off], /usage, /messages, /skills, /help.\n" +
+      "Process or session control commands such as /exit, /quit, /retry, /new, /reset, and /compact must be run directly in the CLI.",
+    unsupportedCommand: "{command} is not supported through the vanor tool. Run it directly in the CLI.",
+    unknownCommand: "Unknown Vanor command: {command}",
+    currentModel: "Current model: {model}",
+    modelChanged: "Switched model: {model}",
+    modelMatches: "Found {count} matching models. Please choose one explicitly:\n{models}",
+    availableModels: "Available models:\n{models}",
+    modelSwitchFailed: "Switch failed: {message}",
+    languageCurrent: "Language: {language} (configured: {configured}, source: {source})",
+    languageChanged: "Language changed to {language} (configured: {configured}, source: {source})",
+    reloadFailed: "Config reload failed: {error}",
+    reloadDone: "Config reloaded. Current model: {model}",
+    reloadUnchanged: "Config unchanged.",
+    approvalRestored: "Restored approval mode: {approval}",
+    autoRunEnabled: "Auto-run enabled for this session. Denylisted dangerous commands are still blocked.",
+    autoRunUsage: "Usage: /auto-run [on|off]",
+    usage: "prompt {prompt} / completion {completion} / total {total}",
+    messagesNone: "(no user messages)",
+    messagesHeader: "Time                 User message",
+    skillsTotal: "Total: {count} skills",
+  },
   prompt: {
     persona:
       "You are Vanor, a general-purpose agent by Wanyou Intelligence.\n" +
@@ -223,7 +253,7 @@ export default {
     node: "- Runtime: Node.js {version}; Vanor Agent is built on Node.js and can call node / npm via exec",
     shell: "- Default shell: {shell}",
     workspace: "- Workspace: {workspace}",
-    time: "- Current time: {time} ({timezone}, {offset})",
+    timezone: "- Time zone: {timezone} ({offset})",
     contextTitle: "Vanor instance context:",
     currentModel: "- Current model: {model}",
     provider: "- Current provider: {provider}",
@@ -241,6 +271,13 @@ export default {
     skillsCount: "- Loaded skills: {count}",
     answerContext: "- If the user asks about model, config file, session, directories, language, or approval mode, answer directly from this context.",
     noSecrets: "- Do not reveal API keys, Authorization headers, cookies, tokens, private keys, or other secrets. Only say whether a secret is configured or redacted.",
+    memoryPolicy:
+      "Long-term memory policy:\n" +
+      "- Treat ~/.vanor/memory/MEMORY.md and ~/.vanor/memory/USER.md as the most important memory files; their current snapshots are included in every interaction when present.\n" +
+      "- At the end of each task, decide whether new stable facts, project conventions, user preferences, or reusable lessons should be saved to MEMORY.md or USER.md.\n" +
+      "- Each primary file is limited to 10KB. Keep entries concise and maintain them as durable indexed summaries.\n" +
+      "- If more memory is needed, keep an index entry in MEMORY.md or USER.md and store details in secondary files such as ~/.vanor/memory/MEMORY-xxx.md or ~/.vanor/memory/USER-xxx.md.\n" +
+      "- Use a two-level lookup: first check the primary index, then read the referenced secondary file only when the current task needs that detail.",
     terminal:
       "Terminal capabilities: TERM={term}, viewport about {cols} columns x {rows} rows, {color}. " +
       "Fit output to the terminal: keep lines under {cols} columns when practical; avoid code blocks / tables wider than the viewport; {ansi}split long content into sections and avoid flooding the screen.",

package/base/i18n/locales/zh-CN.js

@@ -174,11 +174,13 @@ export default {
     describeWriteFile: "写入文件：{path}",
     describeEditFile: "编辑文件：{path}",
     describeSkills: "管理技能：{action}{name}",
+    describeVanor: "执行 Vanor 命令：{command}",
     describeGeneric: "调用工具 {name}",
     unknownTool: "未知工具：{name}",
     invalidArgs: "参数错误：{errors}",
     denied: "用户或策略拒绝了该操作",
     exception: "工具异常：{message}",
+    aborted: "工具执行已中断",
   },
   builtin: {
     readFileDescription: "读取工作区内文件的文本内容，可选按行 offset/limit 截取。",
@@ -207,6 +209,34 @@ export default {
     noOutput: "(无输出)",
     exitCode: "[退出码 {code}]",
   },
+  vanor: {
+    toolDescription:
+      "在对话中执行 Vanor slash 命令，无需离开当前对话。支持 /model、/language、/reload、/auto-run、/usage、/messages、/skills、/help 等运行时命令。",
+    paramCommand: '要执行的 slash 命令，例如 "/model deepseek"、"/language zh-CN"、"/reload" 或 "/auto-run off"。',
+    emptyCommand: "command 不能为空",
+    help:
+      "支持的 Vanor 命令：/model [query]、/language [auto|en|zh-CN]、/reload、/auto-run [on|off]、/usage、/messages、/skills、/help。\n" +
+      "进程或会话控制命令（如 /exit、/quit、/retry、/new、/reset、/compact）需在 CLI 中直接执行。",
+    unsupportedCommand: "{command} 不支持通过 vanor 工具执行，请在 CLI 中直接运行。",
+    unknownCommand: "未知 Vanor 命令：{command}",
+    currentModel: "当前模型：{model}",
+    modelChanged: "已切换模型：{model}",
+    modelMatches: "匹配到 {count} 个模型，请明确选择其中一个：\n{models}",
+    availableModels: "可用模型：\n{models}",
+    modelSwitchFailed: "切换失败：{message}",
+    languageCurrent: "语言：{language}（配置：{configured}，来源：{source}）",
+    languageChanged: "语言已切换为 {language}（配置：{configured}，来源：{source}）",
+    reloadFailed: "配置重载失败：{error}",
+    reloadDone: "配置已重载。当前模型：{model}",
+    reloadUnchanged: "配置未变化。",
+    approvalRestored: "已恢复审批模式：{approval}",
+    autoRunEnabled: "已开启自动执行：本次对话不再逐次确认操作（denylist 危险命令仍会拦截）。",
+    autoRunUsage: "用法：/auto-run [on|off]",
+    usage: "prompt {prompt} / completion {completion} / total {total}",
+    messagesNone: "（暂无用户消息）",
+    messagesHeader: "时间                 用户内容",
+    skillsTotal: "总计：{count} 个技能",
+  },
   prompt: {
     persona:
       "你是 Vanor（万佑），万佑智算的通用智能体。\n" +
@@ -221,7 +251,7 @@ export default {
     node: "- 运行时：Node.js {version}；Vanor Agent 基于 Node.js 构建，可通过 exec 调用 node / npm 等工具",
     shell: "- 默认 Shell：{shell}",
     workspace: "- 工作区：{workspace}",
-    time: "- 当前时间：{time}（{timezone}，{offset}）",
+    timezone: "- 时区：{timezone}（{offset}）",
     contextTitle: "Vanor 实例上下文：",
     currentModel: "- 当前模型：{model}",
     provider: "- 当前 provider：{provider}",
@@ -239,6 +269,13 @@ export default {
     skillsCount: "- 已加载技能数：{count}",
     answerContext: "- 如果用户询问模型、配置文件、会话、目录、语言或审批模式，可直接依据本上下文回答。",
     noSecrets: "- 不要输出 API Key、Authorization、Cookie、token、私钥等敏感配置；涉及密钥时只说明是否已配置或已脱敏。",
+    memoryPolicy:
+      "长期记忆策略：\n" +
+      "- 将 ~/.vanor/memory/MEMORY.md 与 ~/.vanor/memory/USER.md 视为最重要的记忆文件；只要存在内容，每次交互都会携带其当前快照。\n" +
+      "- 每次任务完成后，判断是否需要把新的稳定事实、项目约定、用户偏好或可复用经验写入 MEMORY.md 或 USER.md。\n" +
+      "- 每个主文件大小限制为 10KB。条目应简洁、稳定，并优先维护为可持久使用的索引摘要。\n" +
+      "- 当记忆信息过多时，在 MEMORY.md 或 USER.md 中保留索引条目，把详细内容保存到 ~/.vanor/memory/MEMORY-xxx.md 或 ~/.vanor/memory/USER-xxx.md。\n" +
+      "- 采用二级查找：先查看主文件索引，只有当前任务需要相关细节时，再读取索引指向的二级文件。",
     terminal:
       "终端能力：TERM={term}，可视区约 {cols} 列 × {rows} 行，{color}。" +
       "输出请适应终端：单行尽量不超过 {cols} 列，代码块 / 表格不要超出宽度；{ansi}较长内容分段，避免一次性刷屏。",

package/base/memory/index.js

@@ -12,8 +12,8 @@ export function createMemory(paths, config, logger) {
   const memFile = path.join(paths.memory, "MEMORY.md");
   const userFile = path.join(paths.memory, "USER.md");
   const limits = {
-    memory: config.memory?.memoryMaxChars ?? 2200,
-    user: config.memory?.userMaxChars ?? 1375,
+    memory: config.memory?.memoryMaxChars ?? 10240,
+    user: config.memory?.userMaxChars ?? 10240,
   };
 
   function fileOf(target) {
@@ -42,14 +42,15 @@ export function createMemory(paths, config, logger) {
     const text = entries.join(SEP);
     const used = text.length;
     const pct = Math.round((used / limits[target]) * 100);
-    return `${LINE}\n${label} [${pct}% — ${used}/${limits[target]} chars]\n${LINE}\n${text}`;
+    const fileName = path.basename(fileOf(target));
+    return `${LINE}\n${fileName}（${label}） [${pct}% — ${used}/${limits[target]} chars]\n${LINE}\n${text}`;
   }
 
   /** 渲染注入系统 prompt 的记忆快照（空记忆返回空串）。 */
   function snapshot() {
     const blocks = [
-      renderBlock("MEMORY（环境与经验）", "memory"),
-      renderBlock("USER PROFILE（用户偏好）", "user"),
+      renderBlock("环境与经验", "memory"),
+      renderBlock("用户偏好", "user"),
     ].filter(Boolean);
     return blocks.join("\n\n");
   }

package/base/test/core.test.js

@@ -27,7 +27,13 @@ test("系统提示词在 CLI 渠道下提示终端格式", () => {
   assert.match(sys, /运行环境/);
   assert.match(sys, /Node\.js/);
   assert.match(sys, /操作系统/);
+  assert.match(sys, /时区/);
   assert.match(sys, /UTC[+-]\d{2}:\d{2}/);
+  assert.doesNotMatch(sys, /当前时间/);
+  assert.match(sys, /MEMORY\.md/);
+  assert.match(sys, /USER\.md/);
+  assert.match(sys, /10KB/);
+  assert.match(sys, /MEMORY-xxx\.md/);
 });
 
 test("系统提示词注入 Vanor 实例上下文", () => {
@@ -77,7 +83,7 @@ test("系统提示词在 Intl 缺失时仍可构造时区信息", () => {
       channel: "cli",
     i18n: createI18n("zh-CN"),
     });
-    assert.match(sys, /当前时间/);
+    assert.match(sys, /时区/);
     assert.match(sys, /UTC[+-]\d{2}:\d{2}/);
   } finally {
     if (desc) Object.defineProperty(globalThis, "Intl", desc);
@@ -149,6 +155,10 @@ test("系统提示词支持英文语言", () => {
   });
   assert.match(sys, /Runtime environment/);
   assert.match(sys, /Default response language: English/);
+  assert.match(sys, /Time zone/);
+  assert.doesNotMatch(sys, /Current time/);
+  assert.match(sys, /Long-term memory policy/);
+  assert.match(sys, /USER-xxx\.md/);
   assert.match(sys, /Terminal capabilities/);
   assert.doesNotMatch(sys, /运行环境/);
 });

package/base/test/loop.test.js

@@ -6,7 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createSecurity } from "../security/index.js";
-import { defaultRegistry, createToolContext } from "../tools/index.js";
+import { defaultRegistry, createToolContext, ToolRegistry } from "../tools/index.js";
 import { Session } from "../core/session.js";
 import { runLoop } from "../core/loop.js";
 import { NullLogger } from "../logger.js";
@@ -95,3 +95,92 @@ test("达到最大迭代次数会停止", async () => {
   const result = await runLoop(session, deps, {});
   assert.equal(result.maxIterations, true);
 });
+
+test("工具执行阶段中断后 loop 返回 aborted 且不继续下一轮", async () => {
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), "vanor-loop-abort-"));
+  const ac = new AbortController();
+  const security = createSecurity({ security: { approval: "auto", workspaceRoot: ws } });
+  const registry = new ToolRegistry().register({
+    name: "abort_tool",
+    description: "abort",
+    danger: "safe",
+    parameters: { type: "object", properties: {} },
+    handler() {
+      ac.abort();
+      return { content: "aborted" };
+    },
+  });
+  const toolCtx = createToolContext({ security, logger: new NullLogger(), signal: ac.signal, confirm: async () => true });
+  const session = new Session({ sessions: path.join(ws, "s") }, new NullLogger(), {});
+  session.start();
+  session.addMessage({ id: "u1", role: "user", content: "abort", meta: {} });
+  let calls = 0;
+  const llm = {
+    async *stream() {
+      calls++;
+      yield { type: "tool_call", call: { id: "c", name: "abort_tool", arguments: {} } };
+    },
+  };
+  const deps = {
+    llm,
+    registry,
+    toolCtx,
+    config: { agent: { maxIterations: 5 }, memory: {} },
+    model: "mock/m",
+    tools: registry.schemas(),
+    buildSystem: () => "system",
+    logger: new NullLogger(),
+  };
+
+  const result = await runLoop(session, deps, {}, ac.signal);
+  assert.equal(result.aborted, true);
+  assert.equal(calls, 1);
+});
+
+test("工具切换模型后 loop 后续迭代使用最新模型", async () => {
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), "vanor-loop-model-"));
+  const security = createSecurity({ security: { approval: "auto", workspaceRoot: ws } });
+  let currentModel = "mock/old";
+  const registry = new ToolRegistry().register({
+    name: "switch_model",
+    description: "switch model",
+    danger: "safe",
+    parameters: { type: "object", properties: {} },
+    handler() {
+      currentModel = "mock/new";
+      return { content: "switched" };
+    },
+  });
+  const toolCtx = createToolContext({ security, logger: new NullLogger(), confirm: async () => true });
+  const session = new Session({ sessions: path.join(ws, "s") }, new NullLogger(), {});
+  session.start();
+  session.addMessage({ id: "u1", role: "user", content: "switch", meta: {} });
+  const requestedModels = [];
+  let calls = 0;
+  const llm = {
+    async *stream(req) {
+      requestedModels.push(req.model);
+      calls++;
+      if (calls === 1) {
+        yield { type: "tool_call", call: { id: "c", name: "switch_model", arguments: {} } };
+      } else {
+        yield { type: "text", delta: "ok" };
+      }
+    },
+  };
+  const deps = {
+    llm,
+    registry,
+    toolCtx,
+    config: { agent: { maxIterations: 5 }, memory: {} },
+    model: currentModel,
+    getModel: () => currentModel,
+    tools: registry.schemas(),
+    buildSystem: () => "system",
+    logger: new NullLogger(),
+  };
+
+  const result = await runLoop(session, deps, {});
+  assert.equal(result.assistant.content, "ok");
+  assert.deepEqual(requestedModels, ["mock/old", "mock/new"]);
+});

package/base/test/memory.test.js

@@ -11,7 +11,7 @@ function tempPaths() {
   return { memory: path.join(root, "memory"), working: path.join(root, "memory", "working") };
 }
 
-const config = { memory: { memoryMaxChars: 2200, userMaxChars: 1375 } };
+const config = { memory: { memoryMaxChars: 10240, userMaxChars: 10240 } };
 
 test("add 后 snapshot 含条目", () => {
   const mem = createMemory(tempPaths(), config, new NullLogger());
@@ -19,6 +19,15 @@ test("add 后 snapshot 含条目", () => {
   assert.match(mem.snapshot(), /macOS/);
 });
 
+test("snapshot 标题包含长期记忆文件名", () => {
+  const mem = createMemory(tempPaths(), config, new NullLogger());
+  mem.apply({ action: "add", target: "memory", content: "项目经验" });
+  mem.apply({ action: "add", target: "user", content: "用户偏好" });
+  const snapshot = mem.snapshot();
+  assert.match(snapshot, /MEMORY\.md（环境与经验）/);
+  assert.match(snapshot, /USER\.md（用户偏好）/);
+});
+
 test("replace 唯一匹配", () => {
   const mem = createMemory(tempPaths(), config, new NullLogger());
   mem.apply({ action: "add", target: "user", content: "偏好深色模式" });

package/base/test/session.test.js

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { readSessionState, saveLatestSessionId, Session, latestSession, listSessions, listUserMessages } from "../core/session.js";
 import { createHarness } from "../core/harness.js";
+import { createToolContext, runToolCall } from "../tools/index.js";
 import { NullLogger } from "../logger.js";
 
 function tempPaths() {
@@ -256,6 +257,49 @@ test("createHarness 支持切换语言并写回配置", () => {
   assert.equal(raw.llm.providers.p.apiKey, "env:VANOR_TEST_KEY");
 });
 
+test("createHarness 注册 vanor 工具并支持通过 slash 命令切换模型", async () => {
+  const paths = tempPaths();
+  const config = {
+    llm: {
+      defaultModel: "p/deepseek/deepseek-v4-pro",
+      providers: {
+        p: {
+          type: "openai",
+          baseURL: "http://example",
+          apiKey: "k",
+          models: ["deepseek/deepseek-v4-pro", "deepseek/deepseek-v4-flash"],
+        },
+      },
+    },
+    logging: {},
+    memory: {},
+    agent: {},
+    security: { approval: "ask", workspaceRoot: paths.root },
+  };
+  const harness = createHarness({ paths, logger: new NullLogger(), config });
+  assert.ok(harness.registry.schemas().some((tool) => tool.name === "vanor"));
+
+  const ctx = createToolContext({ security: harness.security, logger: new NullLogger(), i18n: harness.i18n, confirm: async () => true });
+  const switched = await runToolCall({ id: "v1", name: "vanor", arguments: { command: "/model flash" } }, harness.registry, ctx);
+  assert.ok(!switched.meta.isError);
+  assert.equal(harness.model, "p/deepseek/deepseek-v4-flash");
+
+  let confirmCalls = 0;
+  const denyCtx = createToolContext({
+    security: harness.security,
+    logger: new NullLogger(),
+    i18n: harness.i18n,
+    confirm: async () => {
+      confirmCalls++;
+      return false;
+    },
+  });
+  const denied = await runToolCall({ id: "v2", name: "vanor", arguments: { command: "/auto-run" } }, harness.registry, denyCtx);
+  assert.ok(denied.meta.isError);
+  assert.equal(confirmCalls, 1);
+  assert.equal(harness.security.approval, "ask");
+});
+
 test("热重载遇到无效配置时保留旧配置", () => {
   const paths = tempPaths();
   paths.config = path.join(paths.root, "config.json");

package/base/test/tools.test.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createSecurity } from "../security/index.js";
-import { defaultRegistry, createToolContext, runToolCall } from "../tools/index.js";
+import { defaultRegistry, createToolContext, runToolCall, runToolCalls, ToolRegistry } from "../tools/index.js";
 import { NullLogger } from "../logger.js";
 
 function tempWorkspace() {
@@ -125,3 +125,63 @@ test("denylist 命中 exec 被拒", async () => {
   );
   assert.ok(r.meta.isError);
 });
+
+test("AbortSignal 会中断正在执行的 exec 命令及其子进程", async () => {
+  const ws = tempWorkspace();
+  const reg = defaultRegistry();
+  const ac = new AbortController();
+  const security = createSecurity({ security: { approval: "auto", workspaceRoot: ws } });
+  const ctx = createToolContext({ security, logger: new NullLogger(), signal: ac.signal, confirm: async () => true });
+  const script = "setTimeout(()=>require('fs').writeFileSync('done.txt','x'),500)";
+  const command = `${JSON.stringify(process.execPath)} -e ${JSON.stringify(script)}`;
+
+  const pending = runToolCall({ id: "1", name: "exec", arguments: { command, timeout: 5000 } }, reg, ctx);
+  setTimeout(() => ac.abort(), 50);
+  const r = await pending;
+
+  assert.ok(r.meta.isError);
+  assert.match(r.content, /aborted|中断/i);
+  await new Promise((resolve) => setTimeout(resolve, 700));
+  assert.ok(!fs.existsSync(path.join(ws, "done.txt")));
+});
+
+test("AbortSignal 触发后不继续执行后续工具", async () => {
+  const ws = tempWorkspace();
+  const ac = new AbortController();
+  const security = createSecurity({ security: { approval: "auto", workspaceRoot: ws } });
+  const ctx = createToolContext({ security, logger: new NullLogger(), signal: ac.signal, confirm: async () => true });
+  let secondRan = false;
+  const reg = new ToolRegistry()
+    .register({
+      name: "first",
+      description: "first",
+      danger: "safe",
+      parameters: { type: "object", properties: {} },
+      handler() {
+        ac.abort();
+        return { content: "aborted" };
+      },
+    })
+    .register({
+      name: "second",
+      description: "second",
+      danger: "safe",
+      parameters: { type: "object", properties: {} },
+      handler() {
+        secondRan = true;
+        return { content: "second" };
+      },
+    });
+
+  const results = await runToolCalls(
+    [
+      { id: "1", name: "first", arguments: {} },
+      { id: "2", name: "second", arguments: {} },
+    ],
+    reg,
+    ctx,
+  );
+
+  assert.equal(results.length, 1);
+  assert.equal(secondRan, false);
+});

package/base/test/tui.test.js

@@ -240,3 +240,72 @@ test("TerminalUI confirm 中 Ctrl-C 取消当前确认而不触发全局中断",
   assert.equal(interrupted, false);
   assert.equal(tui.buffer, "draft");
 });
+
+test("TerminalUI 支持 Bash 风格编辑快捷键", () => {
+  const input = new FakeInput();
+  const output = new FakeOutput();
+  const tui = new TerminalUI({ input, output, statusBar: fakeStatusBar(), prompt: "› " });
+  tui.enable();
+
+  input.emit("data", "abcdef");
+  input.emit("data", "\x02"); // Ctrl-B
+  input.emit("data", "\x02");
+  input.emit("data", "\x02");
+  input.emit("data", "\x0b"); // Ctrl-K 删除光标后内容
+  assert.equal(tui.buffer, "abc");
+
+  input.emit("data", " def ghi");
+  input.emit("data", "\x17"); // Ctrl-W 删除光标前单词
+  assert.equal(tui.buffer, "abc def ");
+
+  input.emit("data", "\x01"); // Ctrl-A
+  input.emit("data", "\x04"); // Ctrl-D 删除光标处字符
+  assert.equal(tui.buffer, "bc def ");
+
+  input.emit("data", "\x05"); // Ctrl-E
+  input.emit("data", "\x06"); // Ctrl-F 位于末尾时保持不变
+  assert.equal(tui.cursor, Array.from(tui.buffer).length);
+
+  input.emit("data", "\x02");
+  input.emit("data", "\x15"); // Ctrl-U 删除光标前内容
+  assert.equal(tui.buffer, " ");
+  assert.equal(tui.cursor, 0);
+});
+
+test("TerminalUI 支持 Ctrl-P/Ctrl-N 导航历史", async () => {
+  const input = new FakeInput();
+  const output = new FakeOutput();
+  const tui = new TerminalUI({ input, output, statusBar: fakeStatusBar(), prompt: "› " });
+  tui.enable();
+
+  input.emit("data", "first");
+  input.emit("data", "\r");
+  input.emit("data", "second");
+  input.emit("data", "\r");
+  assert.equal(await tui.readLine(), "first");
+  assert.equal(await tui.readLine(), "second");
+
+  input.emit("data", "\x10"); // Ctrl-P
+  assert.equal(tui.buffer, "second");
+  input.emit("data", "\x10");
+  assert.equal(tui.buffer, "first");
+  input.emit("data", "\x0e"); // Ctrl-N
+  assert.equal(tui.buffer, "second");
+});
+
+test("TerminalUI Ctrl-L 清空消息区并保留输入草稿", () => {
+  const input = new FakeInput();
+  const output = new FakeOutput();
+  const tui = new TerminalUI({ input, output, statusBar: fakeStatusBar(), prompt: "› " });
+  tui.enable();
+  tui.write("agent output\n");
+  input.emit("data", "draft");
+
+  input.emit("data", "\x0c"); // Ctrl-L
+
+  assert.equal(tui.buffer, "draft");
+  assert.equal(tui.cursor, 5);
+  assert.match(output.text(), /\x1b\[1;1H\x1b\[2K/);
+  assert.match(output.text(), /\x1b\[22;1H\x1b\[2K/);
+  assert.match(output.text(), /› draft/);
+});

package/base/tools/builtin.js

@@ -150,6 +150,7 @@ const exec = {
     required: ["command"],
   },
   handler(args, ctx) {
+    if (ctx.signal?.aborted) return fail(ctx.t("builtin.commandAborted"));
     let cwd = ctx.security.workspaceRoot;
     if (args.cwd) {
       const r = ctx.security.checkPath(args.cwd, { mustExist: true, dir: true });
@@ -158,11 +159,42 @@ const exec = {
     }
     return new Promise((resolve) => {
       let child;
+      let settled = false;
+      let aborted = false;
+      let abortKillTimer = null;
+      const detached = process.platform !== "win32";
+      const finish = (result) => {
+        if (settled) return;
+        settled = true;
+        if (abortKillTimer) clearTimeout(abortKillTimer);
+        ctx.signal?.removeEventListener?.("abort", onAbort);
+        resolve(result);
+      };
+      const killChild = (signalName) => {
+        if (!child?.pid) return;
+        try {
+          if (detached) process.kill(-child.pid, signalName);
+          else child.kill(signalName);
+        } catch {
+          try {
+            child.kill(signalName);
+          } catch {
+            // Process may have already exited.
+          }
+        }
+      };
+      const onAbort = () => {
+        aborted = true;
+        killChild("SIGTERM");
+        abortKillTimer = setTimeout(() => killChild("SIGKILL"), 1000);
+      };
       try {
-        child = spawn(args.command, { shell: true, cwd, signal: ctx.signal });
+        child = spawn(args.command, { shell: true, cwd, signal: ctx.signal, detached });
       } catch (e) {
-        return resolve(fail(ctx.t("builtin.spawnFailed", { message: e.message })));
+        return finish(fail(ctx.t("builtin.spawnFailed", { message: e.message })));
       }
+      if (ctx.signal?.aborted) onAbort();
+      else ctx.signal?.addEventListener?.("abort", onAbort, { once: true });
       let out = "";
       let truncated = false;
       const onData = (d) => {
@@ -171,16 +203,17 @@ const exec = {
       };
       child.stdout?.on("data", onData);
       child.stderr?.on("data", onData);
-      const timer = setTimeout(() => child.kill("SIGKILL"), args.timeout || 60000);
+      const timer = setTimeout(() => killChild("SIGKILL"), args.timeout || 60000);
       child.on("error", (e) => {
         clearTimeout(timer);
-        if (e.name === "AbortError") resolve(fail(ctx.t("builtin.commandAborted")));
-        else resolve(fail(ctx.t("builtin.execFailed", { message: e.message })));
+        if (e.name === "AbortError" || aborted) finish(fail(ctx.t("builtin.commandAborted")));
+        else finish(fail(ctx.t("builtin.execFailed", { message: e.message })));
       });
       child.on("close", (code) => {
         clearTimeout(timer);
+        if (aborted) return finish(fail(ctx.t("builtin.commandAborted")));
         const note = truncated ? `\n${ctx.t("builtin.outputTruncated")}` : "";
-        resolve({
+        finish({
           content: `${out || ctx.t("builtin.noOutput")}${note}\n${ctx.t("builtin.exitCode", { code })}`,
           isError: code !== 0,
         });

package/base/tools/index.js

@@ -70,6 +70,8 @@ function describe(call, t) {
       return t("tools.describeEditFile", { path: a.path });
     case "skills":
       return t("tools.describeSkills", { action: a.action, name: a.name ? ` ${a.name}` : "" });
+    case "vanor":
+      return t("tools.describeVanor", { command: a.command });
     default:
       return t("tools.describeGeneric", { name: call.name });
   }
@@ -100,6 +102,15 @@ export async function runToolCall(call, registry, ctx) {
     });
   }
 
+  if (ctx.signal?.aborted) {
+    return toolMessage({
+      toolCallId: call.id,
+      name: call.name,
+      content: ctx.t("tools.aborted"),
+      isError: true,
+    });
+  }
+
   const errs = validateSchema(tool.parameters, call.arguments || {}, "", ctx.t);
   if (errs.length) {
     return toolMessage({
@@ -149,9 +160,11 @@ export async function runToolCall(call, registry, ctx) {
 export async function runToolCalls(toolCalls, registry, ctx, onResult) {
   const out = [];
   for (const call of toolCalls) {
+    if (ctx.signal?.aborted) break;
     const msg = await runToolCall(call, registry, ctx);
     if (onResult) onResult(call, msg);
     out.push(msg);
+    if (ctx.signal?.aborted) break;
   }
   return out;
 }

package/base/transport/cli.js

@@ -373,7 +373,7 @@ export async function startCli(harness, { config }) {
       break; // rl 关闭
     }
     if (!input) continue;
-    tui?.echoInput(input);
+    tui?.echoInput(c.bold(c.cyan(input)));
 
     if (input.startsWith("/")) {
       const consumed = await handleSlash(input);

package/base/transport/tui.js

@@ -173,6 +173,19 @@ export class TerminalUI {
     this.write(`${this.prompt}${line}\n`);
   }
 
+  clearOutput() {
+    if (!this.enabled) return;
+    const bottom = this._scrollBottom();
+    let seq = "\x1b7";
+    for (let row = 1; row <= bottom; row++) seq += `\x1b[${row};1H\x1b[2K`;
+    seq += "\x1b8";
+    this.output.write(seq);
+    this.outRow = 1;
+    this.outCol = 1;
+    this.statusBar?.render?.(true);
+    this.renderInput(true);
+  }
+
   readLine() {
     const queued = this.queue.shift();
     if (queued !== undefined) return Promise.resolve(queued);
@@ -271,13 +284,22 @@ export class TerminalUI {
     this._setBuffer(next, { fromHistory: true });
   }
 
+  _resetHistoryDraft() {
+    this.historyIndex = null;
+    this._draftBeforeHistory = "";
+  }
+
+  _moveCursor(delta) {
+    this.cursor = Math.max(0, Math.min(chars(this.buffer).length, this.cursor + delta));
+    this.renderInput(true);
+  }
+
   _insert(s, { multiline = false } = {}) {
     const all = chars(this.buffer);
     const text = multiline ? String(s).replace(/\r\n/g, "\n").replace(/\r/g, "\n") : String(s);
     const ins = chars(text).filter((ch) => (multiline && ch === "\n") || printable(ch));
     if (!ins.length) return;
-    this.historyIndex = null;
-    this._draftBeforeHistory = "";
+    this._resetHistoryDraft();
     all.splice(this.cursor, 0, ...ins);
     this.buffer = all.join("");
     this.cursor += ins.length;
@@ -286,8 +308,7 @@ export class TerminalUI {
 
   _backspace() {
     if (this.cursor <= 0) return;
-    this.historyIndex = null;
-    this._draftBeforeHistory = "";
+    this._resetHistoryDraft();
     const all = chars(this.buffer);
     all.splice(this.cursor - 1, 1);
     this.buffer = all.join("");
@@ -298,13 +319,44 @@ export class TerminalUI {
   _delete() {
     const all = chars(this.buffer);
     if (this.cursor >= all.length) return;
-    this.historyIndex = null;
-    this._draftBeforeHistory = "";
+    this._resetHistoryDraft();
     all.splice(this.cursor, 1);
     this.buffer = all.join("");
     this.renderInput(true);
   }
 
+  _killBeforeCursor() {
+    if (this.cursor <= 0) return;
+    this._resetHistoryDraft();
+    const all = chars(this.buffer);
+    all.splice(0, this.cursor);
+    this.buffer = all.join("");
+    this.cursor = 0;
+    this.renderInput(true);
+  }
+
+  _killAfterCursor() {
+    const all = chars(this.buffer);
+    if (this.cursor >= all.length) return;
+    this._resetHistoryDraft();
+    all.splice(this.cursor);
+    this.buffer = all.join("");
+    this.renderInput(true);
+  }
+
+  _killWordBeforeCursor() {
+    if (this.cursor <= 0) return;
+    this._resetHistoryDraft();
+    const all = chars(this.buffer);
+    let start = this.cursor;
+    while (start > 0 && /\s/.test(all[start - 1])) start--;
+    while (start > 0 && !/\s/.test(all[start - 1])) start--;
+    all.splice(start, this.cursor - start);
+    this.buffer = all.join("");
+    this.cursor = start;
+    this.renderInput(true);
+  }
+
   _handleEscape(s) {
     if (s === "\x1b[A") {
       this._navigateHistory(-1);
@@ -315,12 +367,20 @@ export class TerminalUI {
       return true;
     }
     if (s === "\x1b[D") {
-      this.cursor = Math.max(0, this.cursor - 1);
-      this.renderInput(true);
+      this._moveCursor(-1);
       return true;
     }
     if (s === "\x1b[C") {
-      this.cursor = Math.min(chars(this.buffer).length, this.cursor + 1);
+      this._moveCursor(1);
+      return true;
+    }
+    if (s === "\x1b[H" || s === "\x1b[1~") {
+      this.cursor = 0;
+      this.renderInput(true);
+      return true;
+    }
+    if (s === "\x1b[F" || s === "\x1b[4~") {
+      this.cursor = chars(this.buffer).length;
       this.renderInput(true);
       return true;
     }
@@ -383,15 +443,19 @@ export class TerminalUI {
       this.cursor = 0;
       return this.renderInput(true);
     }
+    if (s === "\x02") return this._moveCursor(-1);
+    if (s === "\x04") return this._delete();
     if (s === "\x05") {
       this.cursor = chars(this.buffer).length;
       return this.renderInput(true);
     }
-    if (s === "\x15") {
-      this.buffer = "";
-      this.cursor = 0;
-      return this.renderInput(true);
-    }
+    if (s === "\x06") return this._moveCursor(1);
+    if (s === "\x0b") return this._killAfterCursor();
+    if (s === "\x0c") return this.clearOutput();
+    if (s === "\x0e") return this._navigateHistory(1);
+    if (s === "\x10") return this._navigateHistory(-1);
+    if (s === "\x15") return this._killBeforeCursor();
+    if (s === "\x17") return this._killWordBeforeCursor();
     return this._insert(s);
   }
 }

package/docs/TECH_DESIGN.md

@@ -279,11 +279,14 @@ interface ToolResult { content: string; isError?: boolean; }
 
 | 文件 | 用途 | 上限 |
 |------|------|------|
-| `MEMORY.md` | 环境事实、约定、经验 | ~2200 字符 |
-| `USER.md` | 用户偏好、沟通风格 | ~1375 字符 |
+| `MEMORY.md` | 环境事实、约定、经验；过多时作为索引指向 `MEMORY-xxx.md` | 10KB |
+| `USER.md` | 用户偏好、沟通风格；过多时作为索引指向 `USER-xxx.md` | 10KB |
 
 - 条目以 `§` 分隔；超限时模型自行整合/替换。
 - **冻结快照**：会话开始时注入系统 prompt，会话中途变更立即落盘但下一会话才进 prompt（保 prefix cache）。
+- **每轮注入**：`MEMORY.md` 与 `USER.md` 是最高优先级长期记忆；只要存在内容，每次构造 system prompt 都会携带其当前快照。
+- **任务结束更新判断**：system prompt 明确要求 Agent 在每次任务完成后判断是否需要写入稳定事实、项目约定、用户偏好或可复用经验。
+- **二级索引**：两个主文件各限制 10KB；当信息过多时，主文件只保留索引摘要，详细内容写入 `MEMORY-xxx.md` / `USER-xxx.md`，需要时再二级读取。
 - `memory` 工具：`add` / `replace` / `remove`（子串唯一匹配），无 `read`（已在 prompt 中）。
 - **检索**：MVP 用关键词倒排（Node 实现）补充召回；`[v2]` 可选向量（sqlite-vec / 本地 embedding）。
 
@@ -329,7 +332,7 @@ type SessionEntry =
     "fallback": ["wanyou/deepseek/deepseek-v4-flash"]   // 主模型失败后依次尝试
   },
   "agent":  { "maxIterations": 25, "thinking": "off", "contextWindow": 256000 },
-  "memory": { "memoryMaxChars": 2200, "userMaxChars": 1375, "compactThreshold": 0.75 },
+  "memory": { "memoryMaxChars": 10240, "userMaxChars": 10240, "compactThreshold": 0.75 },
   "security": {
     "approval": "ask",                 // ask | auto | deny
     "allowlist": ["git *", "ls *", "cat *"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpssff/vanor",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A zero-dependency LLM-powered CLI agent for developers by Wanyou Intelligence",
   "type": "module",
   "bin": {