jinzd-ai-cli 0.4.89 → 0.4.91

package/dist/{chunk-XMA222FQ.js → chunk-PASCDYMH.js}

@@ -1,70 +1,27 @@
-// src/symbols/vector-store.ts
-import fs2 from "fs";
-import path2 from "path";
-import os2 from "os";
-import crypto from "crypto";
+import {
+  EMBEDDING_DIM
+} from "./chunk-JV5N65KN.js";
 
-// src/symbols/embedder.ts
+// src/symbols/vector-store.ts
+import fs from "fs";
 import path from "path";
 import os from "os";
-import fs from "fs";
-var EMBEDDING_MODEL_ID = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
-var EMBEDDING_DIM = 384;
-var pipelinePromise = null;
-function cacheDir() {
-  return path.join(os.homedir(), ".aicli", "models");
-}
-async function getEmbedder() {
-  if (pipelinePromise) return pipelinePromise;
-  pipelinePromise = (async () => {
-    const mod = await import("@huggingface/transformers");
-    const dir = cacheDir();
-    fs.mkdirSync(dir, { recursive: true });
-    mod.env.cacheDir = dir;
-    mod.env.allowRemoteModels = true;
-    mod.env.allowLocalModels = true;
-    const pipe = await mod.pipeline("feature-extraction", EMBEDDING_MODEL_ID, {
-      // Keep the ONNX session in float32; int8 quantization exists but the
-      // quality drop on short code identifiers is noticeable.
-      dtype: "fp32"
-    });
-    return pipe;
-  })();
-  return pipelinePromise;
-}
-async function embed(texts) {
-  if (texts.length === 0) return [];
-  const pipe = await getEmbedder();
-  const out = await pipe(texts, { pooling: "mean", normalize: true });
-  const batch = texts.length;
-  const dim = EMBEDDING_DIM;
-  const rows = new Array(batch);
-  for (let i = 0; i < batch; i++) {
-    rows[i] = new Float32Array(out.data.buffer, out.data.byteOffset + i * dim * 4, dim).slice();
-  }
-  return rows;
-}
-async function embedOne(text) {
-  const [vec] = await embed([text]);
-  return vec;
-}
-
-// src/symbols/vector-store.ts
+import crypto from "crypto";
 var MAGIC = 1094927190;
 var VERSION = 1;
 var HEADER_BYTES = 16;
 function indexDir() {
-  return path2.join(os2.homedir(), ".aicli", "index");
+  return path.join(os.homedir(), ".aicli", "index");
 }
 function projectHash(root) {
-  return crypto.createHash("sha1").update(path2.resolve(root).toLowerCase()).digest("hex").slice(0, 16);
+  return crypto.createHash("sha1").update(path.resolve(root).toLowerCase()).digest("hex").slice(0, 16);
 }
 function vecPath(root) {
-  return path2.join(indexDir(), `${projectHash(root)}.vec`);
+  return path.join(indexDir(), `${projectHash(root)}.vec`);
 }
 function emptyVectorStore(root) {
   return {
-    root: path2.resolve(root),
+    root: path.resolve(root),
     count: 0,
     dim: EMBEDDING_DIM,
     vectors: new Float32Array(0),
@@ -79,7 +36,7 @@ function saveVectorStore(root, indices, vectors) {
   }
   const count = indices.length;
   const dir = indexDir();
-  fs2.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(dir, { recursive: true });
   const totalBytes = HEADER_BYTES + count * 4 + count * EMBEDDING_DIM * 4;
   const buf = Buffer.alloc(totalBytes);
   buf.writeUInt32LE(MAGIC, 0);
@@ -90,15 +47,15 @@ function saveVectorStore(root, indices, vectors) {
   Buffer.from(vectors.buffer, vectors.byteOffset, vectors.byteLength).copy(buf, HEADER_BYTES + count * 4);
   const target = vecPath(root);
   const tmp = `${target}.tmp`;
-  fs2.writeFileSync(tmp, buf);
-  fs2.renameSync(tmp, target);
+  fs.writeFileSync(tmp, buf);
+  fs.renameSync(tmp, target);
 }
 function loadVectorStore(root) {
   const p = vecPath(root);
-  if (!fs2.existsSync(p)) return null;
+  if (!fs.existsSync(p)) return null;
   let buf;
   try {
-    buf = fs2.readFileSync(p);
+    buf = fs.readFileSync(p);
   } catch {
     return null;
   }
@@ -119,12 +76,12 @@ function loadVectorStore(root) {
       buf.byteOffset + HEADER_BYTES + count * 4 + count * dim * 4
     )
   );
-  return { root: path2.resolve(root), count, dim, vectors, symbolIdx };
+  return { root: path.resolve(root), count, dim, vectors, symbolIdx };
 }
 function clearVectorStore(root) {
   const p = vecPath(root);
   try {
-    if (fs2.existsSync(p)) fs2.unlinkSync(p);
+    if (fs.existsSync(p)) fs.unlinkSync(p);
   } catch {
   }
 }
@@ -156,9 +113,6 @@ function searchVectorStore(store, queryVec, k) {
 }
 
 export {
-  EMBEDDING_DIM,
-  embed,
-  embedOne,
   emptyVectorStore,
   saveVectorStore,
   loadVectorStore,

package/dist/{chunk-3O3U3L5W.js → chunk-US6MQO6W.js}

@@ -8,7 +8,7 @@ import {
   CONFIG_FILE_NAME,
   HISTORY_DIR_NAME,
   PLUGINS_DIR_NAME
-} from "./chunk-E7YC4GWV.js";
+} from "./chunk-AKCXRW2Q.js";
 
 // src/config/config-manager.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";

package/dist/{chunk-4WVXTADR.js → chunk-XQHCCV3A.js}

@@ -6,7 +6,7 @@ import { platform } from "os";
 import chalk from "chalk";
 
 // src/core/constants.ts
-var VERSION = "0.4.89";
+var VERSION = "0.4.91";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";

package/dist/{chunk-ABPT6XCI.js → chunk-Z2V6EYPQ.js}

@@ -23,7 +23,7 @@ import {
 } from "./chunk-6VRJGH25.js";
 import {
   runTestsTool
-} from "./chunk-TKYNTXKB.js";
+} from "./chunk-IGNYJUZU.js";
 import {
   CONFIG_DIR_NAME,
   DEFAULT_MAX_TOOL_OUTPUT_CHARS_CAP,
@@ -31,7 +31,7 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-E7YC4GWV.js";
+} from "./chunk-AKCXRW2Q.js";
 
 // src/tools/types.ts
 function isFileWriteTool(name) {

package/dist/electron-server.js

@@ -36,18 +36,21 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-4WVXTADR.js";
+} from "./chunk-XQHCCV3A.js";
 import {
   hasSemanticIndex,
   semanticSearch
-} from "./chunk-GTKJUEBS.js";
+} from "./chunk-MO7MWNWC.js";
 import {
   loadIndex
 } from "./chunk-BJAT4GNC.js";
+import "./chunk-PASCDYMH.js";
 import {
-  EMBEDDING_DIM,
-  embedOne
-} from "./chunk-XMA222FQ.js";
+  loadChatIndex,
+  redactJson,
+  searchChatMemory
+} from "./chunk-5S3PIG5O.js";
+import "./chunk-JV5N65KN.js";
 
 // src/web/server.ts
 import express from "express";
@@ -435,8 +438,8 @@ ${err}`
     return EnvLoader.getDefaultProvider() ?? this.config.defaultProvider;
   }
   /** 点分路径读取配置值，如 `ui.theme` → config.ui.theme */
-  getByPath(path4) {
-    const keys = path4.split(".");
+  getByPath(path3) {
+    const keys = path3.split(".");
     let current = this.config;
     for (const key of keys) {
       if (current == null || typeof current !== "object") return void 0;
@@ -445,8 +448,8 @@ ${err}`
     return current;
   }
   /** 点分路径写入配置值，自动类型转换（boolean/number/string）并持久化 */
-  setByPath(path4, rawValue) {
-    const keys = path4.split(".");
+  setByPath(path3, rawValue) {
+    const keys = path3.split(".");
     if (keys.length === 0) return;
     let value = rawValue;
     if (rawValue === "true") value = true;
@@ -465,7 +468,7 @@ ${err}`
     const result = ConfigSchema.safeParse(draft);
     if (!result.success) {
       const firstErr = result.error.errors[0];
-      throw new ConfigError(`Invalid config value for "${path4}": ${firstErr?.message ?? "validation failed"}`);
+      throw new ConfigError(`Invalid config value for "${path3}": ${firstErr?.message ?? "validation failed"}`);
     }
     this.config = result.data;
     this.save();
@@ -3057,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);
@@ -4358,8 +4263,8 @@ function checkPermission(toolName, args, dangerLevel, rules, defaultAction = "co
     if (rule.when) {
       if (rule.when.dangerLevel && rule.when.dangerLevel !== dangerLevel) continue;
       if (rule.when.pathPattern) {
-        const path4 = String(args["path"] ?? args["command"] ?? "");
-        if (!path4.includes(rule.when.pathPattern)) continue;
+        const path3 = String(args["path"] ?? args["command"] ?? "");
+        if (!path3.includes(rule.when.pathPattern)) continue;
       }
     }
     return rule.action;
@@ -7859,92 +7764,6 @@ ${lines.join("\n")}`;
   }
 };
 
-// src/memory/chat-index.ts
-import fs2 from "fs";
-import path3 from "path";
-import os from "os";
-import crypto from "crypto";
-var MEMORY_DIR_NAME = "memory-index";
-var CHUNKS_FILE = "chunks.json";
-var VECTORS_FILE = "vectors.vec";
-var VEC_MAGIC = 1094929750;
-var VEC_VERSION = 1;
-var VEC_HEADER_BYTES = 16;
-function memoryIndexDir() {
-  return path3.join(os.homedir(), ".aicli", MEMORY_DIR_NAME);
-}
-function chunksPath() {
-  return path3.join(memoryIndexDir(), CHUNKS_FILE);
-}
-function vectorsPath() {
-  return path3.join(memoryIndexDir(), VECTORS_FILE);
-}
-function readVectorsFile(expectedCount) {
-  const p = vectorsPath();
-  if (!fs2.existsSync(p)) return null;
-  let buf;
-  try {
-    buf = fs2.readFileSync(p);
-  } catch {
-    return null;
-  }
-  if (buf.length < VEC_HEADER_BYTES) return null;
-  const magic = buf.readUInt32LE(0);
-  const version = buf.readUInt32LE(4);
-  const count = buf.readUInt32LE(8);
-  const dim = buf.readUInt32LE(12);
-  if (magic !== VEC_MAGIC || version !== VEC_VERSION || dim !== EMBEDDING_DIM) return null;
-  if (count !== expectedCount) return null;
-  const expected = VEC_HEADER_BYTES + count * dim * 4;
-  if (buf.length !== expected) return null;
-  return new Float32Array(
-    buf.buffer.slice(buf.byteOffset + VEC_HEADER_BYTES, buf.byteOffset + expected)
-  );
-}
-function readIndexFile() {
-  const p = chunksPath();
-  if (!fs2.existsSync(p)) return null;
-  try {
-    const raw = fs2.readFileSync(p, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.version !== 1) return null;
-    return data;
-  } catch {
-    return null;
-  }
-}
-function loadChatIndex() {
-  const idx = readIndexFile();
-  if (!idx) return null;
-  const vectors = readVectorsFile(idx.chunks.length);
-  if (!vectors) return null;
-  return { idx, vectors };
-}
-async function searchChatMemory(query, options = {}) {
-  const topK = options.topK ?? 5;
-  const minScore = options.minScore ?? 0.25;
-  const loaded = loadChatIndex();
-  if (!loaded || loaded.idx.chunks.length === 0) return [];
-  const { idx, vectors } = loaded;
-  const { redacted } = redactString(query, { enabled: true });
-  const qvec = await embedOne(redacted);
-  const candidates = [];
-  for (let i = 0; i < idx.chunks.length; i++) {
-    const c = idx.chunks[i];
-    if (options.sessionId && c.sessionId !== options.sessionId) continue;
-    if (options.excludeSessionId && c.sessionId === options.excludeSessionId) continue;
-    let score = 0;
-    const base = i * EMBEDDING_DIM;
-    for (let d = 0; d < EMBEDDING_DIM; d++) {
-      score += vectors[base + d] * qvec[d];
-    }
-    if (score < minScore) continue;
-    candidates.push({ chunk: c, score });
-  }
-  candidates.sort((a, b) => b.score - a.score);
-  return candidates.slice(0, topK);
-}
-
 // src/tools/builtin/recall-memory.ts
 function formatHit(h, i) {
   const ts = h.chunk.timestamp.slice(0, 16).replace("T", " ");
@@ -9240,9 +9059,9 @@ function getDevStatePath() {
   return join10(homedir4(), CONFIG_DIR_NAME, DEV_STATE_FILE_NAME);
 }
 function loadDevState() {
-  const path4 = getDevStatePath();
-  if (!existsSync17(path4)) return null;
-  const content = readFileSync11(path4, "utf-8").trim();
+  const path3 = getDevStatePath();
+  if (!existsSync17(path3)) return null;
+  const content = readFileSync11(path3, "utf-8").trim();
   return content || null;
 }
 
@@ -9795,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) {
@@ -11168,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);
@@ -11217,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({
@@ -11404,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-TGGXTOFF.js");
+          const { executeTests } = await import("./run-tests-KHJ6YCPH.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -11918,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-4P2BH57W.js → hub-A66CLTFF.js}

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