jinzd-ai-cli 0.4.88 → 0.4.90

package/dist/electron-server.js

@@ -36,15 +36,21 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-P6EQZKKG.js";
+} from "./chunk-BJXGZFE6.js";
 import {
   hasSemanticIndex,
   semanticSearch
-} from "./chunk-GTKJUEBS.js";
+} from "./chunk-MO7MWNWC.js";
 import {
   loadIndex
 } from "./chunk-BJAT4GNC.js";
-import "./chunk-XMA222FQ.js";
+import "./chunk-PASCDYMH.js";
+import {
+  loadChatIndex,
+  redactJson,
+  searchChatMemory
+} from "./chunk-5S3PIG5O.js";
+import "./chunk-JV5N65KN.js";
 
 // src/web/server.ts
 import express from "express";
@@ -3054,104 +3060,6 @@ var Session = class _Session {
   }
 };
 
-// src/security/redactor.ts
-var DEFAULT_PATTERNS = [
-  // password: xxx / password = xxx / password="xxx"
-  // Covers YAML / JSON / shell-ish / env-file forms.
-  { kind: "password", regex: /\b(password|passwd|pwd)\s*[:=]\s*["']?([^\s"',;{}]{4,200})["']?/gi },
-  // PGPASSWORD=xxx (explicit bash env-var form, separate rule because no quotes usually)
-  { kind: "pgpassword-env", regex: /\b(PGPASSWORD)=([^\s"']{4,200})/g },
-  // JDBC/PG/MySQL/Mongo connection strings with inline credentials
-  // postgresql://user:pass@host/db → redact pass
-  { kind: "db-uri-password", regex: /(\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp|mssql):\/\/[^:\s]+:)([^@\s]+)(@)/gi },
-  // Anthropic API keys
-  { kind: "anthropic-key", regex: /(sk-ant-[a-zA-Z0-9_-]{90,})/g },
-  // OpenAI / generic sk- keys — requires length ≥32 to avoid eating short identifiers
-  { kind: "openai-key", regex: /(sk-(?:proj-)?[a-zA-Z0-9_-]{32,})/g },
-  // GitHub personal access tokens
-  { kind: "github-pat", regex: /\b(ghp_[a-zA-Z0-9]{36})\b/g },
-  { kind: "github-oauth", regex: /\b(gho_[a-zA-Z0-9]{36})\b/g },
-  { kind: "github-install", regex: /\b(ghs_[a-zA-Z0-9]{36})\b/g },
-  // Slack tokens
-  { kind: "slack-bot", regex: /\b(xoxb-\d+-\d+-[a-zA-Z0-9]+)\b/g },
-  { kind: "slack-user", regex: /\b(xoxp-\d+-\d+-\d+-[a-zA-Z0-9]+)\b/g },
-  // AWS access key IDs (AKIA...) and secret access keys are context-dependent;
-  // we only catch the ID because secret key alone is indistinguishable from random base64.
-  { kind: "aws-access-key-id", regex: /\b(AKIA[0-9A-Z]{16})\b/g },
-  // Google API keys
-  { kind: "google-api-key", regex: /\b(AIza[0-9A-Za-z_-]{35})\b/g },
-  // Generic "api_key": "..." / "apiKey": "..." / api-key=xxx
-  { kind: "api-key", regex: /\b(api[_-]?key)\s*[:=]\s*["']?([a-zA-Z0-9_\-.]{16,200})["']?/gi },
-  // Generic token: xxx (only when value looks token-shaped; avoids eating human prose)
-  { kind: "token", regex: /\b(token|access[_-]?token|bearer[_-]?token)\s*[:=]\s*["']?([a-zA-Z0-9_\-.]{20,300})["']?/gi },
-  // Bearer <token> in Authorization headers
-  { kind: "bearer", regex: /\b(Authorization:\s*Bearer\s+)([a-zA-Z0-9_\-.=]{20,500})/g },
-  // Private key PEM blocks — catch the header+footer together
-  { kind: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g }
-];
-function render(placeholder, kind) {
-  return placeholder.replace("{kind}", kind);
-}
-function redactString(input, options) {
-  if (!options.enabled || !input) return { redacted: input, hits: [] };
-  const placeholder = options.placeholder ?? "[REDACTED:{kind}]";
-  const patterns = [
-    ...options.patterns ?? DEFAULT_PATTERNS,
-    ...(options.customRegexes ?? []).flatMap((src, i) => {
-      try {
-        const flags = src.match(/^\/.*\/([gimsuy]*)$/)?.[1] ?? "";
-        const body = src.replace(/^\/(.*)\/[gimsuy]*$/, "$1");
-        const regex = new RegExp(body, flags.includes("g") ? flags : flags + "g");
-        return [{ kind: `custom-${i}`, regex }];
-      } catch {
-        return [];
-      }
-    })
-  ];
-  let redacted = input;
-  const hits = [];
-  for (const { kind, regex } of patterns) {
-    const rx = new RegExp(regex.source, regex.flags);
-    redacted = redacted.replace(rx, (...args) => {
-      const match = args[0];
-      const probe = new RegExp(rx.source).exec(match);
-      const captureCount = probe ? probe.length - 1 : 0;
-      const g1 = captureCount >= 1 ? args[1] : void 0;
-      const g2 = captureCount >= 2 ? args[2] : void 0;
-      const offset = args[1 + captureCount];
-      if (captureCount >= 2 && typeof g2 === "string") {
-        hits.push({ kind, start: offset + (g1?.length ?? 0), length: g2.length, secret: g2 });
-        return `${g1}${render(placeholder, kind)}`;
-      }
-      hits.push({ kind, start: offset, length: match.length, secret: g1 ?? match });
-      return render(placeholder, kind);
-    });
-  }
-  return { redacted, hits };
-}
-function redactJson(value, options) {
-  if (!options.enabled) return { value, hits: [] };
-  const allHits = [];
-  function walk(v) {
-    if (typeof v === "string") {
-      const r = redactString(v, options);
-      allHits.push(...r.hits);
-      return r.redacted;
-    }
-    if (Array.isArray(v)) return v.map(walk);
-    if (v && typeof v === "object") {
-      const out = {};
-      for (const [k, vv] of Object.entries(v)) {
-        out[k] = walk(vv);
-      }
-      return out;
-    }
-    return v;
-  }
-  const redacted = walk(value);
-  return { value: redacted, hits: allHits };
-}
-
 // src/session/session-manager.ts
 function safeDate(value) {
   const d = new Date(value);
@@ -7856,6 +7764,74 @@ ${lines.join("\n")}`;
   }
 };
 
+// src/tools/builtin/recall-memory.ts
+function formatHit(h, i) {
+  const ts = h.chunk.timestamp.slice(0, 16).replace("T", " ");
+  const title = h.chunk.sessionTitle ? ` \xB7 ${h.chunk.sessionTitle}` : "";
+  const sid = h.chunk.sessionId.slice(0, 8);
+  const score = h.score.toFixed(3);
+  const body = h.chunk.text.length > 600 ? h.chunk.text.slice(0, 600) + "\u2026" : h.chunk.text;
+  return `\u2500\u2500\u2500 Hit ${i + 1} (score ${score}, session ${sid}${title}, ${ts}) \u2500\u2500\u2500
+` + body;
+}
+var recallMemoryTool = {
+  definition: {
+    name: "recall_memory",
+    description: 'Semantic search over past chat sessions. Call this whenever the user references something that may have been discussed before ("last time", "remember", "\u4E4B\u524D", "\u4E0A\u6B21"), when context is ambiguous and continuity matters, or when you want to check what decisions or preferences have been established across prior conversations. Returns up to `topK` relevant snippets with session id, timestamp, and cosine similarity score. Prefer this over asking the user "can you remind me".',
+    parameters: {
+      query: {
+        type: "string",
+        description: "Natural-language description of what to recall. Chinese or English both work.",
+        required: true
+      },
+      topK: {
+        type: "number",
+        description: "Max number of snippets to return (default 5, max 20).",
+        required: false
+      },
+      excludeCurrentSession: {
+        type: "boolean",
+        description: "If true, exclude the current session from results (avoid echoing what you just said). Default false.",
+        required: false
+      },
+      currentSessionId: {
+        type: "string",
+        description: "Session ID to exclude when excludeCurrentSession=true. Usually the active session.",
+        required: false
+      },
+      minScore: {
+        type: "number",
+        description: "Drop hits below this cosine score. Default 0.25. Raise to 0.35+ for stricter matches.",
+        required: false
+      }
+    },
+    dangerous: false
+  },
+  async execute(args) {
+    const query = String(args["query"] ?? "").trim();
+    if (!query) throw new ToolError("recall_memory", "query is required");
+    const topK = Math.max(1, Math.min(20, Number(args["topK"] ?? 5)));
+    const excludeCurrent = Boolean(args["excludeCurrentSession"]);
+    const currentId = args["currentSessionId"] ? String(args["currentSessionId"]) : void 0;
+    const minScore = args["minScore"] !== void 0 ? Number(args["minScore"]) : 0.25;
+    const status = loadChatIndex();
+    if (!status) {
+      return "No chat memory index found. The index is built on REPL startup, or run `/memory rebuild` manually. If you have no past sessions yet, this is expected.";
+    }
+    const hits = await searchChatMemory(query, {
+      topK,
+      minScore,
+      excludeSessionId: excludeCurrent ? currentId : void 0
+    });
+    if (hits.length === 0) {
+      return `No memories matched "${query}" above score ${minScore}. Index has ${status.idx.chunks.length} chunks across ${Object.keys(status.idx.sessionMtimes).length} sessions. Consider lowering minScore to 0.15 or rephrasing the query.`;
+    }
+    const header = `Found ${hits.length} memory hit(s) for "${query}" (min-score ${minScore}):
+`;
+    return header + "\n" + hits.map(formatHit).join("\n\n");
+  }
+};
+
 // src/core/token-estimator.ts
 var CJK_REGEX = /[\u2E80-\u9FFF\uA000-\uA4FF\uAC00-\uD7FF\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFFEF]/g;
 function estimateTokens(text) {
@@ -7915,6 +7891,7 @@ var ToolRegistry = class {
     this.register(getOutlineTool);
     this.register(findReferencesTool);
     this.register(searchCodeTool);
+    this.register(recallMemoryTool);
   }
   register(tool) {
     this.tools.set(tool.definition.name, tool);
@@ -9637,6 +9614,12 @@ var SessionHandler = class _SessionHandler {
         }
         return;
       }
+      case "memory_search":
+        return this.handleMemorySearch(msg.query, msg.topK, msg.minScore, msg.excludeCurrentSession);
+      case "memory_status_request":
+        return this.handleMemoryStatus();
+      case "memory_rebuild":
+        return this.handleMemoryRebuild(Boolean(msg.full));
       case "auto_pause_response": {
         const resolve6 = this.pendingAutoPause.get(msg.requestId);
         if (resolve6) {
@@ -11010,7 +10993,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
         const root = process.cwd();
         const { loadIndex: loadIndex2, clearIndex } = await import("./store-247B3TAU.js");
         const { indexProject: indexProject2 } = await import("./indexer-O5FCGFBJ.js");
-        const { loadVectorStore, clearVectorStore } = await import("./vector-store-UR7IARXB.js");
+        const { loadVectorStore, clearVectorStore } = await import("./vector-store-NDUFLNGN.js");
         if (sub === "status") {
           const idx = loadIndex2(root);
           const vec = loadVectorStore(root);
@@ -11059,7 +11042,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
             message: `Building semantic index for ${idx.symbolCount} symbols\u2026 (first run downloads ~117 MB model)`
           });
           try {
-            const { rebuildSemanticIndex } = await import("./semantic-MYAXLDCZ.js");
+            const { rebuildSemanticIndex } = await import("./semantic-3KJPAUW6.js");
             const stats = await rebuildSemanticIndex(root);
             const first = stats.modelFirstLoadMs ? ` (model load+first batch ${stats.modelFirstLoadMs}ms)` : "";
             this.send({
@@ -11246,7 +11229,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-JVWIGY7P.js");
+          const { executeTests } = await import("./run-tests-37FEBJTR.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -11760,6 +11743,106 @@ Add .md files to create commands.` });
       this.send({ type: "error", message: `Failed to clear memory: ${err.message}` });
     }
   }
+  // ── B4 chat memory recall (v0.4.90+) ──────────────────────────────
+  // Lazy-imported so the 117 MB embedder stays out of the load path for
+  // clients that never open the Memory panel.
+  async handleMemorySearch(query, topK, minScore, excludeCurrent) {
+    const q = (query ?? "").trim();
+    if (!q) {
+      this.send({ type: "error", message: "Memory search: query is empty." });
+      return;
+    }
+    try {
+      const { searchChatMemory: searchChatMemory2, loadChatIndex: loadChatIndex2 } = await import("./chat-index-QKFH7ZP6.js");
+      const loaded = loadChatIndex2();
+      if (!loaded || loaded.idx.chunks.length === 0) {
+        this.send({ type: "memory_hits", query: q, hits: [], indexMissing: true });
+        return;
+      }
+      const hits = await searchChatMemory2(q, {
+        topK: topK ?? 8,
+        minScore: minScore ?? 0.2,
+        excludeSessionId: excludeCurrent ? this.sessions.current?.id : void 0
+      });
+      this.send({
+        type: "memory_hits",
+        query: q,
+        hits: hits.map((h) => ({
+          id: h.chunk.id,
+          sessionId: h.chunk.sessionId,
+          sessionTitle: h.chunk.sessionTitle,
+          provider: h.chunk.provider,
+          model: h.chunk.model,
+          timestamp: h.chunk.timestamp,
+          score: h.score,
+          text: h.chunk.text,
+          startMessageIdx: h.chunk.startMessageIdx,
+          endMessageIdx: h.chunk.endMessageIdx
+        }))
+      });
+    } catch (err) {
+      this.send({
+        type: "error",
+        message: `Memory search failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async handleMemoryStatus() {
+    try {
+      const { getChatIndexStatus } = await import("./chat-index-QKFH7ZP6.js");
+      const s = getChatIndexStatus();
+      this.send({
+        type: "memory_status",
+        exists: s.exists,
+        chunks: s.chunks,
+        sessions: s.sessions,
+        built: s.built,
+        model: s.model,
+        vecFileSizeBytes: s.vecFileSizeBytes,
+        chunksFileSizeBytes: s.chunksFileSizeBytes
+      });
+    } catch (err) {
+      this.send({
+        type: "error",
+        message: `Memory status failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  async handleMemoryRebuild(full) {
+    try {
+      this.send({
+        type: "info",
+        message: full ? "\u{1F9E0} Rebuilding chat memory index (this may take a while on first run \u2014 ~117 MB embedder)." : "\u{1F9E0} Refreshing chat memory index (incremental)\u2026"
+      });
+      const { buildChatIndex } = await import("./chat-index-QKFH7ZP6.js");
+      const stats = await buildChatIndex({
+        full,
+        onProgress: (p) => {
+          this.send({
+            type: "memory_rebuild_progress",
+            stage: p.stage,
+            processed: p.processed,
+            total: p.total
+          });
+        }
+      });
+      this.send({
+        type: "memory_rebuild_done",
+        chunksTotal: stats.chunksTotal,
+        chunksAdded: stats.chunksAdded,
+        chunksRemoved: stats.chunksRemoved,
+        sessionsIndexed: stats.sessionsIndexed,
+        sessionsSkipped: stats.sessionsSkipped,
+        durationMs: stats.durationMs
+      });
+      await this.handleMemoryStatus();
+    } catch (err) {
+      this.send({
+        type: "error",
+        message: `Memory rebuild failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
   sendSessionMessages() {
     const session = this.sessions.current;
     if (!session) return;

package/dist/{hub-IR4INXSU.js → hub-B7NJSCWF.js}

@@ -385,7 +385,7 @@ ${content}`);
   }
 }
 async function runTaskMode(config, providers, configManager, topic) {
-  const { TaskOrchestrator } = await import("./task-orchestrator-6MI6LD7T.js");
+  const { TaskOrchestrator } = await import("./task-orchestrator-K6HDX4YE.js");
   const orchestrator = new TaskOrchestrator(config, providers, configManager);
   let interrupted = false;
   const onSigint = () => {

package/dist/index.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import {
-  DEFAULT_PATTERNS,
   HALLUCINATION_CORRECTION_MESSAGE,
   McpManager,
   ProviderRegistry,
@@ -29,13 +28,12 @@ import {
   persistToolRound,
   rebuildExtraMessages,
   saveDevState,
-  scanString,
   sessionHasMeaningfulContent,
   setupProxy
-} from "./chunk-L3MBIO36.js";
+} from "./chunk-DJGP7AR6.js";
 import {
   ConfigManager
-} from "./chunk-QT2KNL3V.js";
+} from "./chunk-AB2LA33A.js";
 import {
   ToolExecutor,
   ToolRegistry,
@@ -51,16 +49,25 @@ import {
   spawnAgentContext,
   theme,
   undoStack
-} from "./chunk-YDHIU24C.js";
+} from "./chunk-G65IDWVP.js";
 import "./chunk-2ZD3YTVM.js";
 import {
   fileCheckpoints
 } from "./chunk-4BKXL7SM.js";
+import {
+  DEFAULT_PATTERNS,
+  buildChatIndex,
+  clearChatIndex,
+  getChatIndexStatus,
+  scanString,
+  searchChatMemory
+} from "./chunk-ANYYM4CF.js";
 import "./chunk-NHNWUBXB.js";
-import "./chunk-CQQQFNND.js";
+import "./chunk-KJLJPUY2.js";
 import "./chunk-6VRJGH25.js";
-import "./chunk-PFYAAX2S.js";
-import "./chunk-V3NMERIB.js";
+import "./chunk-2DXY7UGF.js";
+import "./chunk-KHYD3WXE.js";
+import "./chunk-EEEAFWNK.js";
 import {
   AGENTIC_BEHAVIOR_GUIDELINE,
   AUTHOR,
@@ -82,7 +89,7 @@ import {
   SKILLS_DIR_NAME,
   VERSION,
   buildUserIdentityPrompt
-} from "./chunk-VGXNE37B.js";
+} from "./chunk-WPQ4D6T3.js";
 
 // src/index.ts
 import { program } from "commander";
@@ -2470,7 +2477,7 @@ ${hint}` : "")
         const root = process.cwd();
         const { loadIndex, clearIndex } = await import("./store-S24SPPDZ.js");
         const { indexProject } = await import("./indexer-C7QYYHSZ.js");
-        const { loadVectorStore, clearVectorStore } = await import("./vector-store-YTVHACBV.js");
+        const { loadVectorStore, clearVectorStore } = await import("./vector-store-QARQ2P6D.js");
         if (sub === "status") {
           const idx = loadIndex(root);
           const vec = loadVectorStore(root);
@@ -2529,7 +2536,7 @@ ${hint}` : "")
           }
           console.log(theme.dim(`  Building semantic index for ${idx.symbolCount} symbols\u2026`));
           console.log(theme.dim("  (First run downloads ~117 MB embedding model to ~/.aicli/models/)"));
-          const { rebuildSemanticIndex } = await import("./semantic-ICJ536BG.js");
+          const { rebuildSemanticIndex } = await import("./semantic-YDRPPVWK.js");
           try {
             const stats = await rebuildSemanticIndex(root, {
               onProgress: (done, total) => {
@@ -2595,7 +2602,7 @@ ${hint}` : "")
       usage: "/test [command|filter]",
       async execute(args, ctx) {
         try {
-          const { executeTests } = await import("./run-tests-FQHDUYOG.js");
+          const { executeTests } = await import("./run-tests-2DYVHTIH.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -2750,11 +2757,92 @@ ${hint}` : "")
     // ── /memory ────────────────────────────────────────────────────────────────
     {
       name: "memory",
-      description: "View, add to, or clear persistent memory (memory.md)",
-      usage: "/memory [show|add <text>|clear|path]",
-      execute(args, ctx) {
+      description: "Persistent memory (memory.md) + chat memory recall index (v0.4.89+)",
+      usage: "/memory [show|add <text>|clear|path|rebuild|refresh|status|recall <query>|index-clear]",
+      async execute(args, ctx) {
         const memoryFile = join2(ctx.config.getConfigDir(), MEMORY_FILE_NAME);
         const sub = args[0] ?? "show";
+        if (sub === "rebuild" || sub === "refresh") {
+          const full = sub === "rebuild";
+          ctx.renderer.printInfo(
+            full ? "\u{1F9E0} Rebuilding chat memory index from scratch (this may take a while on first run \u2014 embedding model ~117 MB)\u2026" : "\u{1F9E0} Refreshing chat memory index (incremental)\u2026"
+          );
+          try {
+            let lastStage = "";
+            const stats = await buildChatIndex({
+              full,
+              onProgress: (p) => {
+                if (p.stage !== lastStage) {
+                  lastStage = p.stage;
+                  if (p.stage === "embedding" && p.total) {
+                    process.stdout.write(theme.dim(`    embedding ${p.total} chunk(s)\u2026
+`));
+                  } else if (p.stage !== "done") {
+                    process.stdout.write(theme.dim(`    ${p.stage}\u2026
+`));
+                  }
+                }
+              }
+            });
+            ctx.renderer.printSuccess(
+              `\u2713 Chat index: ${stats.chunksTotal} chunks (${stats.chunksAdded} new, ${stats.chunksRemoved} removed) across ${stats.sessionsIndexed + stats.sessionsSkipped} sessions (${stats.sessionsIndexed} re-indexed, ${stats.sessionsSkipped} cached) in ${stats.durationMs}ms`
+            );
+          } catch (err) {
+            ctx.renderer.renderError(`Rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          return;
+        }
+        if (sub === "status") {
+          const s = getChatIndexStatus();
+          console.log(theme.heading("\n\u{1F9E0} Chat Memory Index"));
+          if (!s.exists) {
+            console.log(theme.dim("    not built yet \u2014 run /memory rebuild\n"));
+            return;
+          }
+          const mb = (n) => `${(n / 1024 / 1024).toFixed(2)} MB`;
+          console.log(`    chunks       : ${s.chunks}`);
+          console.log(`    sessions     : ${s.sessions}`);
+          console.log(`    built        : ${s.built?.replace("T", " ").slice(0, 19) ?? "-"}`);
+          console.log(`    model        : ${s.model ?? "-"}`);
+          console.log(`    vec file     : ${mb(s.vecFileSizeBytes)}`);
+          console.log(`    chunks file  : ${mb(s.chunksFileSizeBytes)}`);
+          console.log();
+          return;
+        }
+        if (sub === "recall") {
+          const query = args.slice(1).join(" ").trim();
+          if (!query) {
+            ctx.renderer.printInfo("Usage: /memory recall <query>");
+            return;
+          }
+          try {
+            const hits = await searchChatMemory(query, { topK: 5, minScore: 0.2 });
+            if (hits.length === 0) {
+              console.log(theme.warning(`  No memories matched "${query}" above score 0.20.`));
+              console.log();
+              return;
+            }
+            console.log(theme.heading(`
+\u{1F9E0} Memory recall for "${query}" \u2014 ${hits.length} hit(s):
+`));
+            for (const [i, h] of hits.entries()) {
+              const ts = h.chunk.timestamp.slice(0, 16).replace("T", " ");
+              const title = h.chunk.sessionTitle ?? h.chunk.sessionId.slice(0, 8);
+              console.log(theme.accent(`  [${i + 1}] ${ts} \xB7 ${title} \xB7 score ${h.score.toFixed(3)}`));
+              const body = h.chunk.text.length > 400 ? h.chunk.text.slice(0, 400) + "\u2026" : h.chunk.text;
+              console.log(theme.dim("      ") + body.replace(/\n/g, "\n      "));
+              console.log();
+            }
+          } catch (err) {
+            ctx.renderer.renderError(`Recall failed: ${err instanceof Error ? err.message : String(err)}`);
+          }
+          return;
+        }
+        if (sub === "index-clear") {
+          clearChatIndex();
+          ctx.renderer.printSuccess("Chat memory index cleared (memory.md untouched).");
+          return;
+        }
         if (sub === "show" || sub === "view") {
           if (!existsSync2(memoryFile)) {
             ctx.renderer.printInfo("Memory is empty (memory.md not found)");
@@ -4123,6 +4211,12 @@ var Repl = class {
   toolExecutor;
   /** 运行时有效的 system prompt（合并了项目上下文 + 用户配置） */
   activeSystemPrompt;
+  /** v0.4.89: cached chat memory index status, refreshed at startup and after /memory rebuild. */
+  chatMemoryStatus = {
+    exists: false,
+    chunks: 0,
+    sessions: 0
+  };
   /** 当前加载的层级上下文（全局/项目/子目录） */
   contextLayers = [];
   /** 本次会话累计 token 用量 */
@@ -4580,6 +4674,23 @@ You have a maximum of ${effectiveMaxRounds} tool call rounds per conversation tu
     if (memory) stableParts.push(`# Persistent Memory
 
 ${memory.content}`);
+    if (this.chatMemoryStatus.exists && this.chatMemoryStatus.chunks > 0) {
+      stableParts.push(
+        `# Long-term Memory Recall
+
+You have a semantic index over ${this.chatMemoryStatus.chunks} chunks from ${this.chatMemoryStatus.sessions} past sessions. Call \`recall_memory({ query: "\u2026" })\` whenever:
+  - The user references something that may have been discussed before ("\u4E0A\u6B21", "\u4E4B\u524D", "last time", "remember")
+  - A pronoun/demonstrative is ambiguous ("\u90A3\u4E2A", "it", "that project") and current context doesn't resolve it
+  - The user asks about preferences, decisions, or conventions that might have been established earlier
+  - Continuity across sessions would clearly help (e.g. user returns after days to the same project)
+
+Do NOT call it for:
+  - Queries fully answerable from the current conversation
+  - Obviously-new topics with no continuity signal
+
+Prefer recall over asking the user "can you remind me". When a hit is relevant, cite it briefly ("we established last session that\u2026") so the user sees you remembered.`
+      );
+    }
     const devState = loadDevState();
     if (devState) {
       stableParts.push(
@@ -4913,6 +5024,34 @@ Session '${this.resumeSessionId}' not found.
       } catch {
       }
     })();
+    void (async () => {
+      try {
+        const { getChatIndexStatus: getChatIndexStatus2, buildChatIndex: buildChatIndex2 } = await import("./chat-index-W2UZ34ZI.js");
+        const initial = getChatIndexStatus2();
+        this.chatMemoryStatus = {
+          exists: initial.exists,
+          chunks: initial.chunks,
+          sessions: initial.sessions
+        };
+        if (!initial.exists) return;
+        const stats = await buildChatIndex2({ full: false });
+        const after = getChatIndexStatus2();
+        this.chatMemoryStatus = {
+          exists: after.exists,
+          chunks: after.chunks,
+          sessions: after.sessions
+        };
+        if (stats.sessionsIndexed > 0 || stats.chunksRemoved > 0) {
+          process.stdout.write(
+            theme.dim(
+              `  \u{1F9E0} Chat memory refreshed: ${stats.chunksAdded} new \xB7 ${stats.chunksRemoved} removed \xB7 ${stats.chunksTotal} total
+`
+            )
+          );
+        }
+      } catch {
+      }
+    })();
     const globalMcpServers = this.config.get("mcpServers") ?? {};
     const projectMcpResult = this.loadProjectMcpConfig();
     const projectMcpServers = projectMcpResult?.servers ?? {};
@@ -6576,7 +6715,7 @@ program.command("web").description("Start Web UI server with browser-based chat
     console.error("Error: Invalid port number. Must be between 1 and 65535.");
     process.exit(1);
   }
-  const { startWebServer } = await import("./server-UWKRV5DK.js");
+  const { startWebServer } = await import("./server-FCTPLKGO.js");
   await startWebServer({ port, host: options.host });
 });
 program.command("user [action] [username]").description("Manage Web UI users (list | create <name> | delete <name> | reset-password <name> | migrate <name>)").action(async (action, username) => {
@@ -6699,7 +6838,7 @@ program.command("sessions").description("List recent conversation sessions").act
 });
 program.command("batch <action> [arg] [arg2]").description("Anthropic Message Batches: submit | list | status <id> | results <id> [out] | cancel <id>").option("--dry-run", "Parse and validate input without submitting (submit only)").action(async (action, arg, arg2, options) => {
   try {
-    const batch = await import("./batch-7XCYSPJU.js");
+    const batch = await import("./batch-3MJ56YAA.js");
     switch (action) {
       case "submit":
         if (!arg) {
@@ -6742,7 +6881,7 @@ program.command("batch <action> [arg] [arg2]").description("Anthropic Message Ba
   }
 });
 program.command("mcp-serve").description("Start an MCP server over STDIO, exposing aicli's built-in tools to Claude Desktop / Cursor / other MCP clients").option("--allow-destructive", "Allow bash / run_interactive / task_create (always destructive in MCP mode)").option("--allow-outside-cwd", "Allow tool path arguments to escape the sandbox root \u2014 disabled by default").option("--tools <list>", "Comma-separated whitelist of tools to expose (default: all eligible tools)").option("--cwd <path>", "Working directory AND sandbox root (default: current directory)").action(async (options) => {
-  const { startMcpServer } = await import("./server-HTVVWKFN.js");
+  const { startMcpServer } = await import("./server-S6JYNMMF.js");
   await startMcpServer({
     allowDestructive: !!options.allowDestructive,
     allowOutsideCwd: !!options.allowOutsideCwd,
@@ -6869,7 +7008,7 @@ program.command("hub [topic]").description("Start multi-agent hub (discuss / bra
     }),
     config.get("customProviders")
   );
-  const { startHub } = await import("./hub-IR4INXSU.js");
+  const { startHub } = await import("./hub-B7NJSCWF.js");
   await startHub(
     {
       topic: topic ?? "",

package/dist/{run-tests-FQHDUYOG.js → run-tests-2DYVHTIH.js}

@@ -2,8 +2,8 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-V3NMERIB.js";
-import "./chunk-VGXNE37B.js";
+} from "./chunk-EEEAFWNK.js";
+import "./chunk-WPQ4D6T3.js";
 export {
   executeTests,
   runTestsTool

package/dist/{run-tests-JVWIGY7P.js → run-tests-37FEBJTR.js}

@@ -1,7 +1,7 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-P6EQZKKG.js";
+} from "./chunk-BJXGZFE6.js";
 export {
   executeTests,
   runTestsTool