jinzd-ai-cli 0.4.241 → 0.4.242

package/README.md

@@ -34,7 +34,7 @@
 - **MCP Server Mode** *(v0.4.84+)* — `aicli mcp-serve` reverses ai-cli into an MCP server (JSON-RPC 2.0 over stdio), exposing its 30 built-in tools (incl. `find_symbol` / `search_code` / `run_tests`) to Claude Desktop / Cursor / any MCP client. Opt-in destructive-tool allow, `--tools` whitelist, `--cwd` override
 - **Session Sensitive-Data Redaction** *(v0.4.88+)* — unified redactor scrubs `password=` / `api_key` / bearer tokens / OpenAI-style keys from every message **before it hits disk**. Query text is redacted too, so secrets never reach embeddings or logs. `/security status` + `/security scan` to audit
 - **Human-like Long-Term Memory** *(v0.4.89+, B4)* — semantic index over every past chat session + `recall_memory` AI tool + `/memory rebuild|refresh|status|recall` commands. AI is prompted to auto-recall when it sees "last time" / "之前" / ambiguous references. Reuses the same MiniLM embedder as semantic code search
-- **Governed Persistent Memory** *(v0.4.217+)* — `save_memory` and `/memory add` write auditable `memory.jsonl` entries with id/scope/source/sensitivity/approval/expiry; low-risk entries auto-approve, sensitive entries stay pending until `/memory approve <id>`, and project-scoped memories only inject inside the same project
+- **Governed Persistent Memory** *(v0.4.217+)* — `save_memory` and `/memory add` write auditable `memory.jsonl` entries with id/scope/source/sensitivity/approval/expiry; AI-written entries (`save_memory`) always stay pending until `/memory approve <id>` (v0.4.242+), low-risk manual entries auto-approve, project-scoped memories only inject inside the same project, and `/memory clear` confirms + keeps a timestamped backup
 - **Package Plugin Ecosystem** *(v0.4.218+)* — install shareable .aicli-plugin/plugin.json packages with skills, hooks, commands, MCP servers, agents, and permission hints; only trusted+enabled plugins load, hooks still require hook trust, and MCP/tools remain under permission profiles/network policy
 - **Web UI Memory Panel** *(v0.4.90+, B4)* — new 🧠 Memory sidebar tab with semantic search across past chats; each hit has **➕ Inject** (quotes the snippet into the chat input as a markdown blockquote so you can review/edit before sending — no silent context injection) and **↗ Load** (jumps to source session). Bulk "Inject top 3" for recall bundles
 - **Streaming Tool Use** — Real-time streaming of AI reasoning and tool calls as they happen
@@ -173,7 +173,7 @@ AI autonomously invokes these 30 tools during conversations:
 | `run_tests` | safe | Auto-detect and run project tests (JUnit XML parsing) |
 | `spawn_agent` | safe | Delegate subtasks to named isolated agents (`agent`: explorer/worker/reviewer/security/tester) |
 | `ask_user` | safe | Pause and ask the user a question |
-| `save_memory` | safe | Persist governed memory across sessions; sensitive entries require `/memory approve <id>` |
+| `save_memory` | safe | Persist governed memory across sessions; AI-written entries stay pending until `/memory approve <id>` |
 | `write_todos` | safe | Task breakdown with live progress rendering |
 | `save_last_response` | write | Save AI response to file |
 | `task_create` | write | Start a command running in the background |

package/dist/{batch-K66BLTLJ.js → batch-D3UHL432.js}

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   ConfigManager
-} from "./chunk-IV6GCDVR.js";
+} from "./chunk-WMAXYDCB.js";
 import "./chunk-5ULLIOVC.js";
-import "./chunk-SMQHEJSH.js";
+import "./chunk-Y4CMNXZH.js";
 import {
   atomicWriteFileSync
 } from "./chunk-IW3Q7AE5.js";

package/dist/{chat-index-7HXBWQFH.js → chat-index-ALUHFJKI.js}

@@ -6,9 +6,10 @@ import {
   getChatIndexStatus,
   loadChatIndex,
   searchChatMemory
-} from "./chunk-5MYPIQ3Y.js";
+} from "./chunk-IGPFYNZA.js";
 import "./chunk-KHYD3WXE.js";
-import "./chunk-KCEO2XJ4.js";
+import "./chunk-PJ3ONBWZ.js";
+import "./chunk-B5TYJO7V.js";
 import "./chunk-IW3Q7AE5.js";
 export {
   buildChatIndex,

package/dist/{chat-index-WYXYD7YP.js → chat-index-ML5FF5L6.js}

@@ -5,7 +5,8 @@ import {
   getChatIndexStatus,
   loadChatIndex,
   searchChatMemory
-} from "./chunk-UO3XWZFE.js";
+} from "./chunk-NV63EYFL.js";
+import "./chunk-YVTASHS5.js";
 import "./chunk-JV5N65KN.js";
 import "./chunk-6BUTA5VW.js";
 export {

package/dist/{chunk-NAQPP3GZ.js → chunk-6ZWNXHNH.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TEST_TIMEOUT
-} from "./chunk-SMQHEJSH.js";
+} from "./chunk-Y4CMNXZH.js";
 
 // src/tools/builtin/run-tests.ts
 import { execSync, spawnSync } from "child_process";

package/dist/chunk-B5TYJO7V.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+// 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 },
+  // L6 (v0.4.108): Zhipu / GLM API keys — `<24+ hex/base64-ish>.<32+>`
+  // Two segments separated by a dot, each safely identifiable by length
+  // and char class. Conservative on the lower bound so we don't eat
+  // version strings like `1.0.0` or filenames.
+  { kind: "zhipu-key", regex: /\b([a-zA-Z0-9]{24,}\.[a-zA-Z0-9]{32,})\b/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
+  // P2-PERF-02: PEM bodies use strict Base64 + =\n — narrowed char class avoids backtracking
+  { kind: "private-key", regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[ \t\n\r]*[A-Za-z0-9+/=\n\r-]*[ \t\n\r]*-----END [A-Z ]*PRIVATE KEY-----/g }
+];
+var MAX_CUSTOM = 32;
+var MAX_PATTERN_LEN = 500;
+var SUSPICIOUS_REDOS = /\([^)]*[+*][^)]*\)\s*[+*{]/;
+var MAX_REDACT_INPUT = 512e3;
+function render(placeholder, kind) {
+  return placeholder.replace("{kind}", kind);
+}
+function redactString(input, options) {
+  if (!options.enabled || !input) return { redacted: input, hits: [] };
+  if (input.length > MAX_REDACT_INPUT) return { redacted: input, hits: [] };
+  const placeholder = options.placeholder ?? "[REDACTED:{kind}]";
+  const customSrcs = (options.customRegexes ?? []).slice(0, MAX_CUSTOM);
+  const patterns = [
+    ...options.patterns ?? DEFAULT_PATTERNS,
+    ...customSrcs.flatMap((src, i) => {
+      if (typeof src !== "string" || src.length === 0 || src.length > MAX_PATTERN_LEN) return [];
+      try {
+        const flags = src.match(/^\/.*\/([gimsuy]*)$/)?.[1] ?? "";
+        const body = src.replace(/^\/(.*)\/[gimsuy]*$/, "$1");
+        if (SUSPICIOUS_REDOS.test(body)) return [];
+        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);
+    const captureCount = new RegExp(rx.source + "|").exec("").length - 1;
+    redacted = redacted.replace(rx, (...args) => {
+      const match = args[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 };
+}
+function scanString(input, options) {
+  const { hits } = redactString(input, { ...options, enabled: true });
+  return hits;
+}
+
+export {
+  DEFAULT_PATTERNS,
+  redactString,
+  redactJson,
+  scanString
+};

package/dist/chunk-D27TMEOV.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+import {
+  getGitRoot
+} from "./chunk-HOSJZMQS.js";
+import {
+  MEMORY_FILE_NAME,
+  MEMORY_MAX_CHARS,
+  MEMORY_STORE_FILE_NAME
+} from "./chunk-Y4CMNXZH.js";
+import {
+  DEFAULT_PATTERNS,
+  redactString
+} from "./chunk-B5TYJO7V.js";
+import {
+  atomicWriteFileSync
+} from "./chunk-IW3Q7AE5.js";
+
+// src/memory/persistent-memory.ts
+import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync } from "fs";
+import { randomUUID, createHash } from "crypto";
+import { dirname, join, resolve } from "path";
+function parseWritableScope(value) {
+  return value === "personal" || value === "project" ? value : void 0;
+}
+function memoryStorePath(configDir) {
+  return join(configDir, MEMORY_STORE_FILE_NAME);
+}
+function memoryMarkdownPath(configDir) {
+  return join(configDir, MEMORY_FILE_NAME);
+}
+function getProjectKey(cwd = process.cwd()) {
+  return resolve(getGitRoot(cwd) ?? cwd);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isValidScope(value) {
+  return value === "personal" || value === "project" || value === "session" || value === "team";
+}
+function isValidSensitivity(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function isValidSource(value) {
+  return value === "tool" || value === "manual";
+}
+function normalizeEntry(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const content = typeof raw.content === "string" ? raw.content.trim() : "";
+  if (!content) return null;
+  const createdAt = typeof raw.createdAt === "string" ? raw.createdAt : nowIso();
+  return {
+    id: typeof raw.id === "string" && raw.id ? raw.id : randomUUID(),
+    content,
+    scope: isValidScope(raw.scope) ? raw.scope : "personal",
+    source: isValidSource(raw.source) ? raw.source : void 0,
+    sourceSession: typeof raw.sourceSession === "string" && raw.sourceSession ? raw.sourceSession : void 0,
+    sourceProject: typeof raw.sourceProject === "string" && raw.sourceProject ? raw.sourceProject : void 0,
+    createdAt,
+    updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : createdAt,
+    expiresAt: typeof raw.expiresAt === "string" && raw.expiresAt ? raw.expiresAt : void 0,
+    sensitivity: isValidSensitivity(raw.sensitivity) ? raw.sensitivity : "low",
+    approved: raw.approved === true,
+    redactedKinds: Array.isArray(raw.redactedKinds) ? raw.redactedKinds.filter((x) => typeof x === "string") : void 0
+  };
+}
+function legacyEntriesFromMarkdown(configDir) {
+  const file = memoryMarkdownPath(configDir);
+  if (!existsSync(file)) return [];
+  const content = readFileSync(file, "utf-8").trim();
+  if (!content) return [];
+  const parts = content.split(/\n(?=##\s+\d{4}-\d{2}-\d{2})/g);
+  const chunks = parts.length > 1 ? parts : [content];
+  return chunks.map((chunk, index) => {
+    const match = chunk.match(/^##\s+([^\n]+)\n([\s\S]*)$/);
+    const body = (match ? match[2] : chunk).trim();
+    const parsed = match ? Date.parse(match[1].replace(" ", "T")) : NaN;
+    const createdAt = Number.isFinite(parsed) ? new Date(parsed).toISOString() : nowIso();
+    const id = "legacy-" + createHash("sha1").update(`${index}
+${chunk}`).digest("hex").slice(0, 12);
+    return normalizeEntry({ id, content: body, scope: "personal", createdAt, updatedAt: createdAt, sensitivity: "low", approved: true });
+  }).filter((entry) => Boolean(entry));
+}
+function loadMemoryEntries(configDir) {
+  const file = memoryStorePath(configDir);
+  if (!existsSync(file)) return legacyEntriesFromMarkdown(configDir);
+  const text = readFileSync(file, "utf-8").trim();
+  if (!text) return [];
+  const entries = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = normalizeEntry(JSON.parse(trimmed));
+      if (entry) entries.push(entry);
+    } catch {
+    }
+  }
+  return entries;
+}
+function saveMemoryEntries(configDir, entries) {
+  mkdirSync(configDir, { recursive: true });
+  const jsonl = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  atomicWriteFileSync(memoryStorePath(configDir), jsonl ? jsonl + "\n" : "");
+}
+function isMemoryExpired(entry, at = /* @__PURE__ */ new Date()) {
+  return Boolean(entry.expiresAt && Date.parse(entry.expiresAt) <= at.getTime());
+}
+function isMemoryVisibleInProject(entry, cwd = process.cwd()) {
+  if (entry.scope !== "project") return true;
+  return entry.sourceProject === getProjectKey(cwd);
+}
+function listMemoryEntries(configDir, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return loadMemoryEntries(configDir).filter((entry) => options.includeRejected || entry.approved).filter((entry) => options.includeExpired || !isMemoryExpired(entry)).filter((entry) => isMemoryVisibleInProject(entry, cwd));
+}
+function addMemoryEntry(configDir, content, options = {}) {
+  const original = content.trim();
+  if (!original) throw new Error("memory content is required");
+  const redact = options.redact ?? true;
+  const redacted = redact ? redactString(original, { enabled: true, patterns: options.patterns ?? DEFAULT_PATTERNS, customRegexes: options.customPatterns }) : { redacted: original, hits: [] };
+  const sensitivity = options.sensitivity ?? (redacted.hits.length > 0 ? "high" : "low");
+  const approved = options.approved ?? (sensitivity === "low" && redacted.hits.length === 0 && options.source !== "tool");
+  const scope = options.scope ?? "personal";
+  const timestamp = nowIso();
+  const entry = {
+    id: randomUUID(),
+    content: redacted.redacted.trim(),
+    scope,
+    source: options.source,
+    sourceSession: options.sourceSession,
+    sourceProject: scope === "project" ? getProjectKey(options.cwd) : void 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    expiresAt: options.expiresAt,
+    sensitivity,
+    approved,
+    redactedKinds: [...new Set(redacted.hits.map((hit) => hit.kind))]
+  };
+  const entries = loadMemoryEntries(configDir);
+  entries.push(entry);
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function updateMemoryEntry(configDir, idPrefix, newContent, options = {}) {
+  const content = newContent.trim();
+  if (!content) throw new Error("memory content is required");
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  const redact = options.redact ?? true;
+  const redacted = redact ? redactString(content, { enabled: true, patterns: options.patterns ?? DEFAULT_PATTERNS, customRegexes: options.customPatterns }) : { redacted: content, hits: [] };
+  entry.content = redacted.redacted.trim();
+  entry.updatedAt = nowIso();
+  entry.redactedKinds = [...new Set(redacted.hits.map((hit) => hit.kind))];
+  if (redacted.hits.length > 0) {
+    entry.sensitivity = "high";
+    entry.approved = false;
+  } else if (options.source === "tool") {
+    entry.approved = false;
+  }
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function updateMemoryApproval(configDir, idPrefix, approved) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  entry.approved = approved;
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function deleteMemoryEntry(configDir, idPrefix) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  saveMemoryEntries(configDir, entries.filter((candidate) => candidate.id !== entry.id));
+  return entry;
+}
+function expireMemoryEntry(configDir, idPrefix, expiresAt = nowIso()) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  entry.expiresAt = expiresAt;
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function countPendingMemories(configDir) {
+  return loadMemoryEntries(configDir).filter((entry) => !entry.approved && !isMemoryExpired(entry)).length;
+}
+function clearMemoryEntries(configDir) {
+  const entries = loadMemoryEntries(configDir);
+  const storePath = memoryStorePath(configDir);
+  let backupPath = null;
+  if (entries.length > 0) {
+    const sourceFile = existsSync(storePath) ? storePath : memoryMarkdownPath(configDir);
+    if (existsSync(sourceFile)) {
+      backupPath = `${sourceFile}.bak.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+      copyFileSync(sourceFile, backupPath);
+    }
+  }
+  mkdirSync(configDir, { recursive: true });
+  atomicWriteFileSync(storePath, "");
+  atomicWriteFileSync(memoryMarkdownPath(configDir), "");
+  return { backupPath, cleared: entries.length };
+}
+function exportMemoryEntries(configDir, cwd = process.cwd(), format = "json") {
+  if (format === "md") {
+    const active = listMemoryEntries(configDir, { cwd }).filter((entry) => entry.approved && !isMemoryExpired(entry));
+    return renderMemoryMarkdown(active);
+  }
+  return JSON.stringify(listMemoryEntries(configDir, { cwd, includeExpired: true, includeRejected: true }), null, 2);
+}
+function findUnique(entries, idPrefix) {
+  const matches = entries.filter((entry) => entry.id.startsWith(idPrefix));
+  if (matches.length === 0) throw new Error(`memory id not found: ${idPrefix}`);
+  if (matches.length > 1) throw new Error(`memory id is ambiguous: ${idPrefix}`);
+  return matches[0];
+}
+function renderMemoryMarkdown(entries) {
+  return entries.map((entry) => {
+    const date = entry.createdAt.replace("T", " ").slice(0, 19);
+    const source = [
+      `id:${entry.id.slice(0, 8)}`,
+      `scope:${entry.scope}`,
+      entry.source ? `source:${entry.source}` : "",
+      entry.sourceSession ? `session:${entry.sourceSession.slice(0, 8)}` : "",
+      entry.sourceProject ? `project:${entry.sourceProject}` : "",
+      `sensitivity:${entry.sensitivity}`
+    ].filter(Boolean).join(" \xB7 ");
+    return `## ${date}
+<!-- ${source} -->
+${entry.content}
+`;
+  }).join("\n");
+}
+function syncLegacyMarkdown(configDir, entries = loadMemoryEntries(configDir)) {
+  mkdirSync(dirname(memoryMarkdownPath(configDir)), { recursive: true });
+  const active = entries.filter((entry) => entry.approved && !isMemoryExpired(entry));
+  atomicWriteFileSync(memoryMarkdownPath(configDir), renderMemoryMarkdown(active));
+}
+function formatMemoryForPrompt(configDir, cwd = process.cwd(), maxChars = MEMORY_MAX_CHARS) {
+  const entries = listMemoryEntries(configDir, { cwd }).filter((entry) => entry.approved && !isMemoryExpired(entry));
+  if (entries.length === 0) return null;
+  let content = entries.map((entry) => {
+    const meta = [
+      `id ${entry.id.slice(0, 8)}`,
+      entry.scope,
+      entry.source ?? "unknown",
+      entry.createdAt.slice(0, 10)
+    ].join(" \xB7 ");
+    return `## ${meta}
+${entry.content}`;
+  }).join("\n\n");
+  let entryCount = entries.length;
+  let truncated = false;
+  if (content.length > maxChars) {
+    truncated = true;
+    content = content.slice(-maxChars);
+    const firstEntry = content.indexOf("\n## ");
+    if (firstEntry !== -1) content = content.slice(firstEntry + 1);
+    entryCount = Math.max(1, (content.match(/^## /gm) ?? []).length);
+    content = `(Note: persistent memory exceeded the ${maxChars}-char budget \u2014 showing the newest ${entryCount} of ${entries.length} entries; older entries were dropped. The user can prune with /memory show and /memory delete <id>.)
+
+` + content;
+  }
+  return { content, entryCount, totalCount: entries.length, truncated };
+}
+function findSimilarMemory(entries, content) {
+  const normalize = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+  const target = normalize(content);
+  if (target.length < 8) return null;
+  for (const entry of entries) {
+    const existing = normalize(entry.content);
+    if (existing === target || existing.includes(target) || target.includes(existing)) return entry;
+  }
+  return null;
+}
+function listOrphanedProjectMemories(configDir) {
+  return loadMemoryEntries(configDir).filter((entry) => entry.scope === "project" && entry.sourceProject !== void 0 && !existsSync(entry.sourceProject));
+}
+function rebindMemoryProject(configDir, idPrefix, newProjectPath) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  if (entry.scope !== "project") throw new Error(`memory ${entry.id.slice(0, 8)} is not project-scoped (scope: ${entry.scope})`);
+  entry.sourceProject = getProjectKey(resolve(newProjectPath));
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function detectStaleLegacyMarkdownEdit(configDir) {
+  const jsonlPath = memoryStorePath(configDir);
+  const mdPath = memoryMarkdownPath(configDir);
+  if (!existsSync(jsonlPath) || !existsSync(mdPath)) return false;
+  try {
+    if (!readFileSync(mdPath, "utf-8").trim()) return false;
+    const jsonlMtime = statSync(jsonlPath).mtimeMs;
+    const mdMtime = statSync(mdPath).mtimeMs;
+    return mdMtime > jsonlMtime + 2e3;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  parseWritableScope,
+  memoryStorePath,
+  memoryMarkdownPath,
+  getProjectKey,
+  loadMemoryEntries,
+  isMemoryExpired,
+  isMemoryVisibleInProject,
+  listMemoryEntries,
+  addMemoryEntry,
+  updateMemoryEntry,
+  updateMemoryApproval,
+  deleteMemoryEntry,
+  expireMemoryEntry,
+  countPendingMemories,
+  clearMemoryEntries,
+  exportMemoryEntries,
+  renderMemoryMarkdown,
+  syncLegacyMarkdown,
+  formatMemoryForPrompt,
+  findSimilarMemory,
+  listOrphanedProjectMemories,
+  rebindMemoryProject,
+  detectStaleLegacyMarkdownEdit
+};

package/dist/{chunk-2QQKS56X.js → chunk-DT77O33T.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   SessionManager
-} from "./chunk-JMP3LJC2.js";
+} from "./chunk-KWQKQVPH.js";
 
 // src/hub/persist.ts
 import { join } from "path";