@pcircle/memesh 4.9.4 → 4.10.1

package/dist/mcp/server.js

@@ -3229,8 +3229,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path7) {
-      let input = path7;
+    function removeDotSegments(path10) {
+      let input = path10;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3482,8 +3482,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path7, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
+        const [path10, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6902,12 +6902,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs9, exportName) {
+    function addFormats(ajv, list, fs12, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs9[f]);
+        ajv.addFormat(f, fs12[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -6916,8 +6916,8 @@ var require_dist = __commonJS({
 });
 
 // dist/mcp/server.js
-import fs8 from "fs";
-import path6 from "path";
+import fs11 from "fs";
+import path9 from "path";
 
 // node_modules/zod/v4/core/index.js
 var core_exports2 = {};
@@ -7442,10 +7442,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path7) {
-  if (!path7)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7854,11 +7854,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path7, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -8005,16 +8005,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path10 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -8041,17 +8041,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path7 = []) => {
+  const processError = (error52, path10 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path7, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path10, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path10, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path10, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -8083,8 +8083,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path7) {
+  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path10) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21082,13 +21082,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path7 = ref.slice(1).split("/").filter(Boolean);
-  if (path7.length === 0) {
+  const path10 = ref.slice(1).split("/").filter(Boolean);
+  if (path10.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path10[0] === defsKey) {
+    const key = path10[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24793,7 +24793,7 @@ var StdioServerTransport = class {
 };
 
 // dist/mcp/server.js
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // dist/storage/sqlite.js
 import { createRequire } from "node:module";
@@ -24819,8 +24819,8 @@ var { DatabaseSync } = loadNodeSqlite();
 var BUSY_TIMEOUT_MS = 3e4;
 var MemeshDatabase = class extends DatabaseSync {
   #depth = 0;
-  constructor(path7, options = {}) {
-    super(path7, options);
+  constructor(path10, options = {}) {
+    super(path10, options);
     this.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
   }
   pragma(statement) {
@@ -24858,6 +24858,9 @@ var MemeshDatabase = class extends DatabaseSync {
 import path2 from "path";
 import fs2 from "fs";
 
+// dist/knowledge-graph.js
+import { createHash } from "node:crypto";
+
 // dist/storage/conflicts.js
 function findConflicts(db2, entityNames) {
   if (entityNames.length < 2)
@@ -25184,16 +25187,30 @@ var KnowledgeGraph = class {
     }
     const prevObsText = isNewEntity ? void 0 : joinIndexedObservations(prevObs.map((o) => o.content));
     if (opts?.observations?.length) {
+      let observations = opts.observations;
+      if (row.type === "session-insight" && /^session-.+-(files|fixes|summary)$/.test(name)) {
+        this.updateEntityMetadata(name, (meta3) => {
+          if (!Array.isArray(meta3.forgotten_observation_hashes))
+            return meta3;
+          const hashes = new Set(meta3.forgotten_observation_hashes);
+          if ((opts.trustOverride ?? opts.metadata?.trust ?? "trusted") !== "trusted") {
+            observations = observations.filter((obs) => !hashes.has(createHash("sha256").update(obs).digest("hex")));
+            return meta3;
+          }
+          const restored = new Set(observations.map((obs) => createHash("sha256").update(obs).digest("hex")));
+          return { ...meta3, forgotten_observation_hashes: meta3.forgotten_observation_hashes.filter((hash2) => !restored.has(hash2)) };
+        });
+      }
       const insertObs = this.db.prepare("INSERT INTO observations (entity_id, content) VALUES (?, ?)");
       const effectiveType = isNewEntity ? type : row.type;
       const isLessonFamily = effectiveType === "lesson_learned" || effectiveType === "lesson" || effectiveType === "mistake";
       if (isLessonFamily) {
-        for (const obs of opts.observations) {
+        for (const obs of observations) {
           insertObs.run(entityId, obs);
         }
       } else {
         const existingObsContent = new Set(isNewEntity ? [] : this.db.prepare("SELECT content FROM observations WHERE entity_id = ?").all(entityId).map((o) => o.content));
-        for (const obs of opts.observations) {
+        for (const obs of observations) {
           if (existingObsContent.has(obs))
             continue;
           existingObsContent.add(obs);
@@ -25512,7 +25529,7 @@ var KnowledgeGraph = class {
   }
   removeObservation(entityName, observationContent) {
     return this.db.transaction(() => {
-      const row = this.db.prepare("SELECT id, title, status FROM entities WHERE name = ?").get(entityName);
+      const row = this.db.prepare("SELECT id, title, status, type, metadata FROM entities WHERE name = ?").get(entityName);
       if (!row)
         return { removed: false, remainingObservations: 0, entityFound: false };
       const prevObs = this.db.prepare("SELECT content FROM observations WHERE entity_id = ? ORDER BY id").all(row.id);
@@ -25527,6 +25544,12 @@ var KnowledgeGraph = class {
       if (deleteResult.changes === 0) {
         return { removed: false, remainingObservations: prevObs.length, entityFound: true };
       }
+      if (row.type === "session-insight" && /^session-.+-(files|fixes|summary)$/.test(entityName)) {
+        const meta3 = this.parseMetadata(row.metadata);
+        const hashes = Array.isArray(meta3.forgotten_observation_hashes) ? meta3.forgotten_observation_hashes : [];
+        const hash2 = createHash("sha256").update(observationContent).digest("hex");
+        this.db.prepare("UPDATE entities SET metadata = ? WHERE id = ?").run(JSON.stringify({ ...meta3, forgotten_observation_hashes: [.../* @__PURE__ */ new Set([...hashes, hash2])] }), row.id);
+      }
       if (row.status !== "archived") {
         this.rebuildFts(row.id, entityName, prevObsText, row.title);
       }
@@ -25598,7 +25621,7 @@ var COMPRESS_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 import fs from "fs";
 import os from "os";
 import path from "path";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { execFileSync } from "child_process";
 var AGENT_ROUTER_SOCKET_FILENAME = "agent-router-v2.sock";
 function homeDir() {
@@ -25658,7 +25681,7 @@ var PROJECT_ID_MAX_LENGTH = 200;
 var PROJECT_LABEL_MAX_LENGTH = PROJECT_ID_MAX_LENGTH - PROJECT_HASH_HEX_LENGTH - 1;
 function projectIdentity(label, locator) {
   const readable = label.normalize("NFC").slice(0, PROJECT_LABEL_MAX_LENGTH) || "project";
-  const suffix = createHash("sha256").update(locator).digest("hex").slice(0, PROJECT_HASH_HEX_LENGTH);
+  const suffix = createHash2("sha256").update(locator).digest("hex").slice(0, PROJECT_HASH_HEX_LENGTH);
   return `${readable}~${suffix}`;
 }
 function tryGit(cwd, args) {
@@ -25748,6 +25771,36 @@ function redactSecrets(input) {
     out = out.replace(pattern, "***REDACTED***");
   return out;
 }
+function redactUserPaths(text) {
+  const home = homeDir();
+  const roots = /* @__PURE__ */ new Set();
+  const add = (root) => {
+    if (!root || !path.isAbsolute(root))
+      return;
+    roots.add(root);
+    try {
+      roots.add(fs.realpathSync(root));
+    } catch {
+    }
+  };
+  add(home);
+  const isInside = (child) => {
+    const rel = path.relative(home, child);
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+  };
+  for (const dir of [memeshDir(), path.dirname(getDbPath())]) {
+    if (dir && !isInside(dir))
+      add(dir);
+  }
+  const flags = process.platform === "linux" ? "g" : "gi";
+  let out = text;
+  for (const root of [...roots].sort((a, b) => b.length - a.length)) {
+    const escaped = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const body = escaped.replace(/\\\\|\//g, "[\\\\/]{1,2}");
+    out = out.replace(new RegExp(`(?<![\\w~](?:[\\\\/]{1,2})?)${body}(?=[\\\\/]|$)`, flags), "~");
+  }
+  return out;
+}
 
 // dist/core/time-utils.js
 function parseSqliteUtcMs(sqliteTimestamp) {
@@ -26267,12 +26320,12 @@ function ensureFtsSegmentation(db2) {
 }
 
 // dist/core/lesson-slug.js
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function lessonSlug(error51) {
   const normalized = error51.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
   const words = normalized.replace(/[^a-z0-9\u4e00-\u9fff]+/g, " ").trim().split(/\s+/).filter((w) => w.length > 1).slice(0, 8);
   const readable = words.join("-") || "unspecified";
-  const digest = createHash2("sha256").update(normalized).digest("hex").slice(0, 8);
+  const digest = createHash3("sha256").update(normalized).digest("hex").slice(0, 8);
   return `${readable.slice(0, 71)}-${digest}`;
 }
 
@@ -26850,8 +26903,8 @@ function getDatabase() {
 }
 
 // dist/transports/mcp/handlers.js
-import fs7 from "node:fs";
-import { fileURLToPath } from "node:url";
+import fs10 from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/core/scoring.js
 var DEFAULT_WEIGHTS = {
@@ -26941,6 +26994,62 @@ function inferErrorPattern(error51) {
   return "other";
 }
 
+// dist/core/note-derive.js
+import { createHash as createHash4 } from "crypto";
+var NOTE_OBSERVATION_MAX_CHARS = 1e4;
+var NOTE_MAX_OBSERVATIONS = 100;
+var NOTE_MAX_CHARS = 2e4;
+var NOTE_DEFAULT_TYPE = "note";
+function sanitizeNoteText(raw) {
+  const normalized = raw.replace(/\r\n?/g, "\n");
+  const stripped = normalized.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+  return redactSecrets(stripped).trim();
+}
+function stripLineMarker(line) {
+  return line.replace(/^\s{0,3}(?:#{1,6}\s+|[-*+]\s+|\d+[.)]\s+)/, "").trim();
+}
+function splitObservations(body) {
+  const out = [];
+  for (const block of body.split(/\n\s*\n/)) {
+    const lines = block.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+      continue;
+    const isList = lines.every((l) => /^(?:[-*+]\s+|\d+[.)]\s+)/.test(l));
+    const parts = isList ? lines.map(stripLineMarker) : [lines.join(" ")];
+    for (const part of parts) {
+      const text = part.replace(/\s+/g, " ").trim();
+      if (!text)
+        continue;
+      out.push(text.length > NOTE_OBSERVATION_MAX_CHARS ? `${text.slice(0, NOTE_OBSERVATION_MAX_CHARS - 1).trimEnd()}\u2026` : text);
+    }
+  }
+  return out;
+}
+function slugify2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+}
+function deriveNote(raw) {
+  const text = sanitizeNoteText(raw);
+  if (!text)
+    return null;
+  const lines = text.split("\n");
+  const firstIndex = lines.findIndex((l) => l.trim().length > 0);
+  const firstLine = stripLineMarker(lines[firstIndex]).replace(/\s+/g, " ");
+  const rest = lines.slice(firstIndex + 1).join("\n");
+  let titleSource = firstLine;
+  if (firstLine.length > TITLE_MAX_LENGTH) {
+    const sentence = /^(.+?[.!?。！？])(?:\s|$)/.exec(firstLine);
+    if (sentence)
+      titleSource = sentence[1];
+  }
+  const title = truncateTitle(titleSource) || "note";
+  const body = splitObservations(rest);
+  const observations = title === firstLine && body.length > 0 ? body : [...splitObservations(firstLine), ...body];
+  const digest = createHash4("sha256").update(text).digest("hex").slice(0, 8);
+  const name = `${slugify2(title) || NOTE_DEFAULT_TYPE}-${digest}`;
+  return { text, title, observations, name };
+}
+
 // dist/core/types.js
 var NAMESPACES = ["personal", "team", "global"];
 
@@ -26951,6 +27060,7 @@ function buildImportedMetadata(existingMetadata, args) {
   return {
     ...existingMetadata ?? {},
     ...bundledSafe,
+    ...Array.isArray(existingMetadata?.forgotten_observation_hashes) ? { forgotten_observation_hashes: existingMetadata.forgotten_observation_hashes } : {},
     trust: "untrusted",
     provenance: {
       ...existingMetadata?.provenance ?? {},
@@ -27152,19 +27262,113 @@ function recallTagFilter(args) {
 function buildRelevanceMap(entities) {
   return new Map(entities.map((entity, index) => [entity.name, 1 - index / (entities.length + 1)]));
 }
-function remember(args) {
+function remember(input) {
   const db2 = getDatabase();
   const kg = new KnowledgeGraph(db2);
-  return db2.transaction(() => rememberInTransaction(args, db2, kg)).immediate();
+  const { args, derived, typeGiven } = resolveRememberInput(input);
+  return db2.transaction(() => rememberInTransaction(args, derived, typeGiven, db2, kg)).immediate();
+}
+var REPLACED_HISTORY_MAX = 20;
+var REPLACED_HISTORY_MAX_BYTES = 64 * 1024;
+var jsonBytes = (v) => Buffer.byteLength(JSON.stringify(v), "utf8");
+function boundReplacedHistory(history) {
+  let out = history.slice(-REPLACED_HISTORY_MAX);
+  while (out.length > 1 && jsonBytes(out) > REPLACED_HISTORY_MAX_BYTES)
+    out = out.slice(1);
+  if (out.length === 1 && jsonBytes(out) > REPLACED_HISTORY_MAX_BYTES) {
+    const only = out[0];
+    const kept = [];
+    const base = { ...only, observations: [], truncated: true };
+    for (const obs of only.observations) {
+      if (jsonBytes([{ ...base, observations: [...kept, obs] }]) > REPLACED_HISTORY_MAX_BYTES)
+        break;
+      kept.push(obs);
+    }
+    out = [{ ...base, observations: kept }];
+  }
+  return out;
 }
-function rememberInTransaction(args, db2, kg) {
-  const existing = db2.prepare("SELECT id, namespace, type FROM entities WHERE name = ?").get(args.name);
-  const entityId = kg.createEntity(args.name, args.type, {
-    observations: args.observations,
-    tags: args.tags,
+function summarizeReplacedHistory(entities) {
+  for (const e of entities) {
+    const history = e.metadata?.replaced_history;
+    if (!Array.isArray(history))
+      continue;
+    const { replaced_history: _dropped, ...rest } = e.metadata;
+    e.metadata = { ...rest, replaced_history_count: history.length };
+  }
+  return entities;
+}
+function resolveRememberInput(input) {
+  if (input.note === void 0) {
+    if (!input.name)
+      throw new Error("remember needs `name` and `type`, or `note`");
+    if (input.type === "")
+      throw new Error("remember needs `name` and `type`, or `note`");
+    if (input.type === void 0 && !input.replace)
+      throw new Error("remember needs `name` and `type`, or `note`");
+    return { args: input, typeGiven: input.type !== void 0 };
+  }
+  if (input.title !== void 0 || input.observations !== void 0) {
+    throw new Error("`note` derives title and observations; do not also pass `title` or `observations`");
+  }
+  const derived = deriveNote(input.note);
+  if (!derived)
+    throw new Error("`note` is empty after removing control characters");
+  if (input.replace && !input.name) {
+    throw new Error("`replace` with `note` needs an explicit `name` (a derived name changes with the text)");
+  }
+  return {
+    args: {
+      ...input,
+      name: input.name ?? derived.name,
+      type: input.type ?? NOTE_DEFAULT_TYPE,
+      title: derived.title,
+      observations: derived.observations
+    },
+    derived,
+    typeGiven: input.type !== void 0
+  };
+}
+function rememberInTransaction(args, derived, typeGiven, db2, kg) {
+  const existing = db2.prepare("SELECT id, namespace, type, title, status FROM entities WHERE name = ?").get(args.name);
+  if (args.replace && existing && existing.status === "archived") {
+    throw new Error(`"${args.name}" was archived with forget; \`replace\` will not overwrite it. Remember it again without \`replace\` to bring it back, then replace it.`);
+  }
+  const entityType = args.type ?? existing?.type;
+  if (entityType === void 0) {
+    throw new Error(`\`replace\` on "${args.name}": there is no memory named "${args.name}" to inherit a type from, so this call would create one with no type \u2014 pass \`type\` to create it.`);
+  }
+  let replacedVersion;
+  let retypedTo;
+  let tags = args.tags;
+  let title = args.title;
+  let observations = args.observations;
+  if (args.replace && existing) {
+    const previousTags = db2.prepare("SELECT tag FROM tags WHERE entity_id = ? ORDER BY tag").all(existing.id).map((t) => t.tag);
+    replacedVersion = {
+      replaced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      title: existing.title,
+      observations: db2.prepare("SELECT content FROM observations WHERE entity_id = ? ORDER BY id").all(existing.id).map((o) => o.content),
+      tags: previousTags
+    };
+    kg.clearEntityData(args.name);
+    if (typeGiven && entityType !== existing.type) {
+      db2.prepare("UPDATE entities SET type = ? WHERE id = ?").run(entityType, existing.id);
+      retypedTo = entityType;
+    }
+    if (tags === void 0)
+      tags = previousTags;
+  } else if (derived && existing) {
+    title = void 0;
+    const stored = new Set(db2.prepare("SELECT content FROM observations WHERE entity_id = ?").all(existing.id).map((o) => o.content));
+    observations = observations?.filter((o) => !stored.has(o));
+  }
+  const entityId = kg.createEntity(args.name, entityType, {
+    observations,
+    tags,
     namespace: args.namespace,
     trustOverride: args.trustOverride,
-    title: args.title
+    title
   });
   kg.updateEntityMetadata(args.name, (current) => buildLocalMetadata(current, {
     trust: args.trustOverride,
@@ -27173,6 +27377,13 @@ function rememberInTransaction(args, db2, kg) {
       ...args.provenanceOverride ?? {}
     }
   }));
+  if (replacedVersion) {
+    const version2 = replacedVersion;
+    kg.updateEntityMetadata(args.name, (current) => {
+      const history = Array.isArray(current.replaced_history) ? current.replaced_history : [];
+      return { ...current, replaced_history: boundReplacedHistory([...history, version2]) };
+    });
+  }
   const relationsCreated = [];
   const relationErrors = [];
   if (args.relations) {
@@ -27196,29 +27407,32 @@ function rememberInTransaction(args, db2, kg) {
       }
     }
   }
+  const storedTitle = db2.prepare("SELECT title FROM entities WHERE id = ?").get(entityId).title;
   return {
     stored: true,
     entityId,
     name: args.name,
-    ...args.title !== void 0 ? { title: args.title } : {},
-    type: existing?.type ?? args.type,
-    observations: args.observations?.length ?? 0,
-    tags: args.tags?.length ?? 0,
+    title: storedTitle,
+    type: retypedTo ?? existing?.type ?? entityType,
+    observations: observations?.length ?? 0,
+    tags: tags?.length ?? 0,
     relations: relationsCreated.length,
     ...relationsCreated.length > 0 ? { relationsCreated } : {},
     ...existing && args.namespace !== void 0 && (existing.namespace ?? "personal") !== args.namespace ? { movedFromNamespace: existing.namespace ?? "personal" } : {},
     ...superseded.length > 0 ? { superseded } : {},
-    ...relationErrors.length > 0 ? { relationErrors } : {}
+    ...relationErrors.length > 0 ? { relationErrors } : {},
+    ...args.replace ? { replaced: replacedVersion !== void 0 } : {},
+    ...derived ? { derived: { name: args.name, type: retypedTo ?? existing?.type ?? entityType, title: derived.title, observations: derived.observations } } : {}
   };
 }
 function searchAndScore(args) {
   const kg = new KnowledgeGraph(getDatabase());
-  const entities = kg.search(args.query, {
+  const entities = summarizeReplacedHistory(kg.search(args.query, {
     tag: recallTagFilter(args),
     limit: args.limit,
     includeArchived: args.include_archived,
     namespace: args.namespace
-  });
+  }));
   return {
     entities,
     relevanceMap: args.query ? buildRelevanceMap(entities) : /* @__PURE__ */ new Map()
@@ -27279,11 +27493,11 @@ function forget(args) {
 }
 
 // dist/core/dreamer.js
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 
 // dist/core/transcript-source.js
 import fs3 from "fs";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import path3 from "path";
 var MAX_TRANSCRIPT_SOURCE_BYTES = 8 * 1024 * 1024;
 var MAX_TRANSCRIPT_SCAN_BYTES = 16 * 1024 * 1024;
@@ -27326,7 +27540,7 @@ function readTranscriptSnapshotWithin(transcriptPath, expected, aggregateBytesRe
     if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || after.mtimeNs !== before.mtimeNs || after.ctimeNs !== before.ctimeNs) {
       return { snapshot: null, aggregateLimitExceeded: false };
     }
-    const contentHash = createHash3("sha256").update(bytes).digest("hex");
+    const contentHash = createHash5("sha256").update(bytes).digest("hex");
     if (expected && contentHash !== expected.contentHash)
       return { snapshot: null, aggregateLimitExceeded: false };
     return { snapshot: { bytes, contentHash, ...identity }, aggregateLimitExceeded: false };
@@ -27516,7 +27730,7 @@ function parseVisibleConversation(transcript) {
 }
 
 // dist/core/product-improvements.js
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var PRODUCT_IMPROVEMENT_KIND = "product_improvement";
 function clean(label, value, max) {
   const normalized = value.replace(/\s+/g, " ").trim();
@@ -27626,7 +27840,7 @@ function stageProductImprovement(db2, input) {
       success_criteria: successCriteria,
       priority
     };
-    const digest = createHash4("sha256").update(JSON.stringify(canonical)).digest("hex");
+    const digest = createHash6("sha256").update(JSON.stringify(canonical)).digest("hex");
     const clusterKey = `product-improvement:${digest}`;
     const existing = db2.prepare(`SELECT id, project, source_ids, proposed_digest, status, reason, created_at, reviewed_at
        FROM dream_proposals
@@ -27832,7 +28046,7 @@ function executeWorkPackage(db2, input, context = {}) {
   const execute = () => {
     const project = input.action === "prepare" ? input.project : input.ref.project;
     const kind = input.action === "prepare" ? input.kind : input.ref.kind;
-    const hash2 = (value) => createHash5("sha256").update(JSON.stringify(value)).digest("hex");
+    const hash2 = (value) => createHash7("sha256").update(JSON.stringify(value)).digest("hex");
     if (input.action !== "prepare") {
       const submitted = input.action === "submit" ? input.result : void 0;
       if (submitted && [submitted.name, ...submitted.observations, ...submitted.tags].some((s) => redactSecrets(s) !== s)) {
@@ -28220,21 +28434,34 @@ function taskStateLines(state, project, now = /* @__PURE__ */ new Date()) {
 function readState(name) {
   const row = getDatabase().prepare("SELECT metadata FROM entities WHERE name = ?").get(name);
   if (!row?.metadata)
-    return {};
+    return { state: {}, corrupted: false };
+  let parsed;
   try {
-    return parseTaskState(JSON.parse(row.metadata));
+    parsed = JSON.parse(row.metadata);
   } catch {
-    return {};
+    return { state: {}, corrupted: true };
   }
+  return { state: parseTaskState(parsed), corrupted: false };
 }
+var TaskStateUnreadableError = class extends Error {
+  project;
+  constructor(project) {
+    super(`task state for project "${project}" is not readable: the stored record is not valid JSON. Re-state it with \`memesh task --goal \u2026\` (any write replaces the broken record).`);
+    this.project = project;
+    this.name = "TaskStateUnreadableError";
+  }
+};
 function getTaskState(project) {
   const resolved = project ?? getProjectName();
-  return { project: resolved, state: readState(taskStateName(resolved)) };
+  const { state, corrupted } = readState(taskStateName(resolved));
+  if (corrupted)
+    throw new TaskStateUnreadableError(resolved);
+  return { project: resolved, state };
 }
 function setTaskState(input) {
   const project = input.project ?? getProjectName();
   const name = taskStateName(project);
-  const previous = readState(name);
+  const { state: previous } = readState(name);
   const { state, changed, observations } = mergeTaskState(previous, input.patch, (/* @__PURE__ */ new Date()).toISOString());
   if (changed.length === 0)
     return { project, state, changed };
@@ -28547,6 +28774,141 @@ function buildReferenceContext(memoryLines) {
   ].join("\n");
 }
 
+// dist/core/briefing-index.js
+var INDEX_MAX_LINES = 40;
+var INDEX_MAX_BYTES = 3072;
+var INDEX_STALE_DAYS = 180;
+var INDEX_LINE_MAX_CHARS = 120;
+var INDEX_SNIPPET_FETCH_CHARS = 4e3;
+var INDEX_CANDIDATE_CAP = 2e3;
+var INDEX_EXCLUDED_TYPES = [...EVIDENCE_LAYER_TYPES, "task-state"];
+function isIndexableType(type) {
+  return !INDEX_EXCLUDED_TYPES.includes(type || "memory");
+}
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+function sectionBytes(lines) {
+  return lines.reduce((sum, line) => sum + byteLength(line) + 1, 0);
+}
+function parseActivity(value) {
+  if (!value)
+    return Number.NaN;
+  const iso = /[zZ]|[+-]\d\d:?\d\d$/.test(value) ? value : `${value.replace(" ", "T")}Z`;
+  return Date.parse(iso);
+}
+function compareIndexCandidates(a, b) {
+  const at = parseActivity(a.lastActivity);
+  const bt = parseActivity(b.lastActivity);
+  const av = Number.isNaN(at) ? -Infinity : at;
+  const bv = Number.isNaN(bt) ? -Infinity : bt;
+  if (av !== bv)
+    return bv - av;
+  return b.id - a.id;
+}
+function candidateIsAutoInjectable(metadata) {
+  if (metadata == null)
+    return true;
+  if (typeof metadata === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(metadata);
+    } catch {
+      return false;
+    }
+    return parsed !== null && typeof parsed === "object" && isAutoInjectable(parsed);
+  }
+  return isAutoInjectable(metadata);
+}
+function redact(text) {
+  if (!text)
+    return "";
+  return redactUserPaths(redactSecrets(String(text))).replace(/\s+/g, " ").trim();
+}
+function indexLine(candidate) {
+  const title = redact(candidate.title);
+  const snippet = redact(candidate.snippet);
+  const repeats = title && snippet && snippet.toLowerCase().startsWith(title.replace(/…$/, "").toLowerCase());
+  const text = title && snippet && !repeats ? `${title} \u2014 ${snippet}` : title || snippet;
+  return topologyLine({ name: String(candidate.id), id: candidate.id, type: candidate.type || "memory", title: text || null }, INDEX_LINE_MAX_CHARS);
+}
+function indexHeading(projectName) {
+  return `Index of durable memories for "${projectName}" (newest first):`;
+}
+function indexEmptyLine(projectName) {
+  return `- No durable memories (decisions, lessons, patterns, references) for "${projectName}" yet.`;
+}
+function moreLine(n, truncated) {
+  return `- ${n}${truncated ? "+" : ""} more \u2014 memesh recall --tag "project:\u2026"`;
+}
+function olderLine(n, truncated) {
+  return `- ${n}${truncated ? "+" : ""} older memor${n === 1 ? "y" : "ies"} (no change in ${INDEX_STALE_DAYS} days) \u2014 recall to see`;
+}
+function footerLine(shown, bytes, tokens) {
+  return `(index cost: ${shown} line${shown === 1 ? "" : "s"}, ${bytes} bytes \u2248 ${tokens} tokens; cap ${INDEX_MAX_LINES} lines / ${INDEX_MAX_BYTES} bytes)`;
+}
+function closeWithFooter(lines, shown) {
+  const above = sectionBytes(lines);
+  let footer = footerLine(shown, above, Math.ceil(above / 4));
+  for (let step = 0; step < 8; step++) {
+    const bytes = above + byteLength(footer) + 1;
+    const tokens = Math.ceil(bytes / 4);
+    const next = footerLine(shown, bytes, tokens);
+    if (next === footer)
+      return { lines: [...lines, footer], bytes, tokens };
+    footer = next;
+  }
+  throw new Error("briefing index: the footer cost did not converge");
+}
+function buildBriefingIndex(candidates, projectName, now, options = {}) {
+  const truncated = options.truncated === true;
+  const cutoff = now - INDEX_STALE_DAYS * DAY_MS;
+  const eligible = candidates.filter((c) => isIndexableType(c.type) && candidateIsAutoInjectable(c.metadata)).slice().sort(compareIndexCandidates);
+  const current = [];
+  let older = 0;
+  for (const c of eligible) {
+    const at = parseActivity(c.lastActivity);
+    if (!Number.isNaN(at) && at < cutoff)
+      older++;
+    else
+      current.push(c);
+  }
+  const heading = indexHeading(projectName);
+  if (current.length === 0 && older === 0) {
+    const closed2 = closeWithFooter([heading, indexEmptyLine(projectName)], 0);
+    return { ...closed2, shown: 0, more: 0, older: 0, truncated, ids: [] };
+  }
+  const reserve = sectionBytes([
+    moreLine(current.length, truncated),
+    olderLine(older, truncated),
+    footerLine(INDEX_MAX_LINES, INDEX_MAX_BYTES, INDEX_MAX_BYTES)
+  ]);
+  const budget = INDEX_MAX_BYTES - reserve - sectionBytes([heading]);
+  const rendered = [];
+  const ids = [];
+  let used = 0;
+  for (const c of current) {
+    if (rendered.length >= INDEX_MAX_LINES)
+      break;
+    const line = indexLine(c);
+    const cost = byteLength(line) + 1;
+    if (used + cost > budget)
+      break;
+    rendered.push(line);
+    ids.push(c.id);
+    used += cost;
+  }
+  const more = current.length - rendered.length;
+  const above = [heading, ...rendered];
+  if (more > 0)
+    above.push(moreLine(more, truncated));
+  if (older > 0)
+    above.push(olderLine(older, truncated));
+  const closed = closeWithFooter(above, rendered.length);
+  return { ...closed, shown: rendered.length, more, older, truncated, ids };
+}
+
 // dist/core/briefing.js
 var PROJECT_LIMIT = 30;
 var RECENT_LIMIT = 5;
@@ -28587,16 +28949,48 @@ function toTopologyEntity(row, snippet) {
     signalScore: typeof signal === "number" ? signal : null
   };
 }
+function readBriefingIndex(db2, projectName, now = Date.now()) {
+  const hasNamespace = db2.prepare("PRAGMA table_info(entities)").all().some((column) => column.name === "namespace");
+  const nonGlobal = hasNamespace ? " AND (e.namespace IS NULL OR e.namespace <> 'global')" : "";
+  const excluded = INDEX_EXCLUDED_TYPES.map(() => "?").join(",");
+  const rows = db2.prepare(`SELECT e.id, e.type, e.title, e.metadata,
+       (SELECT substr(o.content, 1, ${INDEX_SNIPPET_FETCH_CHARS}) FROM observations o
+         WHERE o.entity_id = e.id ORDER BY o.id ASC LIMIT 1) AS snippet,
+       max(e.created_at, COALESCE((SELECT MAX(o2.created_at) FROM observations o2
+         WHERE o2.entity_id = e.id), e.created_at)) AS last_activity
+     FROM entities e
+     WHERE e.id IN (SELECT entity_id FROM tags WHERE tag = ?)
+       AND e.status = 'active'${nonGlobal}
+       AND e.type NOT IN (${excluded})
+     ORDER BY last_activity DESC, e.id DESC
+     LIMIT ?`).all(`project:${projectName}`, ...INDEX_EXCLUDED_TYPES, INDEX_CANDIDATE_CAP);
+  const candidates = rows.map((row) => ({
+    id: row.id,
+    type: row.type,
+    title: row.title,
+    snippet: row.snippet,
+    lastActivity: row.last_activity,
+    metadata: row.metadata
+  }));
+  return buildBriefingIndex(candidates, projectName, now, { truncated: rows.length >= INDEX_CANDIDATE_CAP });
+}
 function assembleBriefing(project, recipient) {
   const projectName = project ?? getProjectName();
   const db2 = getDatabase();
   const repoLines = project === void 0 || project === getProjectName() ? repoStateLines(readRepoState()) : [];
-  const { state } = getTaskState(projectName);
+  let taskLines;
+  try {
+    taskLines = taskStateLines(getTaskState(projectName).state, projectName);
+  } catch (err) {
+    if (!(err instanceof TaskStateUnreadableError))
+      throw err;
+    taskLines = [`task state for ${projectName}: ${err.message}`];
+  }
   const inboxRecipient = recipient === void 0 ? void 0 : canonicalAgentScopeId(recipient);
   const unreadCount = unreadDeliveryCount(db2, canonicalAgentScopeId(projectName), inboxRecipient);
   const everSeen = inboxRecipient !== void 0 && unreadCount === 0 ? recipientEverSeen(db2, canonicalAgentScopeId(projectName), inboxRecipient) : void 0;
   const stateLines = [
-    ...taskStateLines(state, projectName),
+    ...taskLines,
     ...unreadInboxLines(unreadCount, canonicalAgentScopeId(projectName), inboxRecipient, everSeen)
   ];
   const hasNamespace = db2.prepare("PRAGMA table_info(entities)").all().some((column) => column.name === "namespace");
@@ -28641,11 +29035,14 @@ function assembleBriefing(project, recipient) {
     { entities: toEntities(recentPool), foreign: true }
   ], projectName);
   const withRepo = lines.length > 0 && repoLines.length > 0 ? [...repoLines, "", ...lines] : lines;
+  const index = readBriefingIndex(db2, projectName);
+  const block = withRepo.length > 0 ? [...withRepo, "", ...index.lines] : index.lines;
   return {
     project: projectName,
-    text: lines.length > 0 ? buildReferenceContext(withRepo) : "",
+    text: buildReferenceContext(block),
     entityCount: lines.filter((l) => l.startsWith("- [")).length,
-    hasTaskState: stateLines.length > 0
+    hasTaskState: stateLines.length > 0,
+    index
   };
 }
 
@@ -28653,10 +29050,10 @@ function assembleBriefing(project, recipient) {
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // dist/core/agent-messaging.js
-import { createHash as createHash7, randomBytes, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash9, randomBytes, randomUUID as randomUUID2 } from "node:crypto";
 
 // dist/core/agent-message-storage.js
-import { createHash as createHash6, randomUUID } from "node:crypto";
+import { createHash as createHash8, randomUUID } from "node:crypto";
 import fs5 from "node:fs";
 var TERMINAL_WORKFLOW_STATES = /* @__PURE__ */ new Set(["completed", "cancelled", "rejected"]);
 var AgentMessageStorageError = class extends Error {
@@ -29304,7 +29701,7 @@ function parseJsonObjectOrValue(json2) {
   return parsed;
 }
 function hashCanonical(value) {
-  return createHash7("sha256").update(stableStringify(value)).digest("hex");
+  return createHash9("sha256").update(stableStringify(value)).digest("hex");
 }
 function stableStringify(value) {
   if (value === null)
@@ -29454,14 +29851,38 @@ var WorkPackageSchema = external_exports.discriminatedUnion("action", [
   }).strict()
 ]);
 var RememberSchema = external_exports.object({
-  name: nameField,
-  type: external_exports.string().min(1).max(100),
+  name: nameField.optional(),
+  type: external_exports.string().min(1).max(100).optional(),
   title: titleField,
   observations: external_exports.array(observationField).max(100).optional(),
+  note: external_exports.string().max(NOTE_MAX_CHARS).optional(),
+  replace: external_exports.boolean().optional(),
   tags: external_exports.array(external_exports.string().max(255)).max(50).optional(),
   relations: external_exports.array(external_exports.object({ to: external_exports.string().min(1).max(255), type: external_exports.string().min(1).max(100) }).strict()).max(50).optional(),
   namespace: external_exports.enum(NAMESPACES).optional()
-}).strict();
+}).strict().superRefine((data, ctx) => {
+  if (data.note === void 0) {
+    if (data.name === void 0)
+      ctx.addIssue({ code: "custom", path: ["name"], message: "name is required (or pass `note` to have it derived)" });
+    if (data.type === void 0 && !(data.replace && data.name !== void 0))
+      ctx.addIssue({ code: "custom", path: ["type"], message: 'type is required (or pass `note`, which defaults it to "note", or `replace: true` with a `name` to keep the type that memory already has)' });
+    return;
+  }
+  for (const key of ["title", "observations"]) {
+    if (data[key] !== void 0) {
+      ctx.addIssue({ code: "custom", path: [key], message: `${key} cannot be combined with note \u2014 note derives it; to correct the derived ${key}, call again with name, replace: true and a structured ${key} (pass \`type\` only to also change the memory's type)` });
+    }
+  }
+  if (data.replace && data.name === void 0) {
+    ctx.addIssue({ code: "custom", path: ["name"], message: "replace with note needs an explicit name \u2014 a derived name changes with the text, so there is nothing to replace" });
+  }
+  const derived = deriveNote(data.note);
+  if (!derived) {
+    ctx.addIssue({ code: "custom", path: ["note"], message: "note must contain some text" });
+  } else if (derived.observations.length > NOTE_MAX_OBSERVATIONS) {
+    ctx.addIssue({ code: "custom", path: ["note"], message: `note yields ${derived.observations.length} observations; at most ${NOTE_MAX_OBSERVATIONS} are stored per memory` });
+  }
+});
 var RecallSchema = external_exports.object({
   query: external_exports.string().max(1e3).optional(),
   tag: external_exports.string().max(255).optional(),
@@ -30142,6 +30563,543 @@ async function executeAgentMessageAction(db2, rawInput, context, dependencies =
   }
 }
 
+// dist/core/update-entrypoint.js
+import fs9 from "fs";
+import path8 from "path";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+// dist/core/version-check.js
+import fs7 from "fs";
+import path6 from "path";
+
+// dist/core/semver.js
+var SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var NUMERIC_IDENTIFIER = /^\d+$/;
+function parseSemVer(version2) {
+  const match = SEMVER.exec(version2);
+  if (!match)
+    return null;
+  const prerelease = match[4]?.split(".") ?? null;
+  if (prerelease?.some((identifier) => NUMERIC_IDENTIFIER.test(identifier) && identifier.length > 1 && identifier.startsWith("0")))
+    return null;
+  return {
+    core: [BigInt(match[1]), BigInt(match[2]), BigInt(match[3])],
+    prerelease
+  };
+}
+function compareIdentifiers(a, b) {
+  const aNumeric = NUMERIC_IDENTIFIER.test(a);
+  const bNumeric = NUMERIC_IDENTIFIER.test(b);
+  if (aNumeric && bNumeric)
+    return BigInt(a) < BigInt(b) ? -1 : BigInt(a) > BigInt(b) ? 1 : 0;
+  if (aNumeric !== bNumeric)
+    return aNumeric ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareSemVerPrecedence(a, b) {
+  for (let index = 0; index < a.core.length; index += 1) {
+    if (a.core[index] !== b.core[index])
+      return a.core[index] < b.core[index] ? -1 : 1;
+  }
+  if (a.prerelease === null || b.prerelease === null) {
+    if (a.prerelease !== b.prerelease)
+      return a.prerelease === null ? 1 : -1;
+    return 0;
+  }
+  const length = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const aIdentifier = a.prerelease[index];
+    const bIdentifier = b.prerelease[index];
+    if (aIdentifier === void 0 || bIdentifier === void 0) {
+      if (aIdentifier !== bIdentifier)
+        return aIdentifier === void 0 ? -1 : 1;
+      break;
+    }
+    const compared = compareIdentifiers(aIdentifier, bIdentifier);
+    if (compared !== 0)
+      return compared;
+  }
+  return 0;
+}
+
+// dist/core/version-check.js
+var STALE_AFTER_MS = 24 * 60 * 60 * 1e3;
+function isUpdateAvailable(currentVersion, latestVersion) {
+  if (latestVersion === null)
+    return false;
+  const current = parseSemVer(currentVersion);
+  const latest = parseSemVer(latestVersion);
+  if (!current || !latest)
+    return false;
+  return compareSemVerPrecedence(current, latest) < 0;
+}
+function getUpdateCheckPath(updateCheckPath, currentVersion) {
+  if (updateCheckPath)
+    return updateCheckPath;
+  if (process.env.MEMESH_UPDATE_CHECK_PATH)
+    return process.env.MEMESH_UPDATE_CHECK_PATH;
+  const versionTag = currentVersion && /^[0-9A-Za-z.+-]+$/.test(currentVersion) ? currentVersion : "unknown";
+  return path6.join(memeshDir(), `update-check.${versionTag}.json`);
+}
+function parseIsoDate(value) {
+  if (!value)
+    return null;
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? null : timestamp;
+}
+function determineFreshness(source, checkSucceeded, lastSuccessfulCheckAt, now) {
+  if (!lastSuccessfulCheckAt)
+    return "unavailable";
+  if (source === "fresh" && checkSucceeded)
+    return "fresh";
+  const successfulAt = parseIsoDate(lastSuccessfulCheckAt);
+  if (successfulAt === null)
+    return "unavailable";
+  return now.getTime() - successfulAt > STALE_AFTER_MS ? "stale" : "cached";
+}
+function buildResult(currentVersion, stored, source, now) {
+  const versionMatches = stored.currentVersion === currentVersion;
+  const deprecationMessage = versionMatches ? stored.currentVersionDeprecation : null;
+  const lastError = versionMatches ? stored.lastError : null;
+  return {
+    currentVersion,
+    latestVersion: stored.latestVersion,
+    checkedAt: stored.lastAttemptAt,
+    lastAttemptAt: stored.lastAttemptAt,
+    lastSuccessfulCheckAt: stored.lastSuccessfulCheckAt,
+    lastError,
+    updateAvailable: isUpdateAvailable(currentVersion, stored.latestVersion),
+    checkSucceeded: stored.checkSucceeded,
+    source,
+    freshness: determineFreshness(source, stored.checkSucceeded, stored.lastSuccessfulCheckAt, now),
+    currentVersionDeprecated: deprecationMessage !== null,
+    deprecationMessage
+  };
+}
+function parseStoredUpdateCheck(raw) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const candidate = raw;
+  const latestVersion = candidate.latestVersion;
+  const lastAttemptAt = "lastAttemptAt" in candidate ? candidate.lastAttemptAt : candidate.checkedAt;
+  const lastSuccessfulCheckAt = "lastSuccessfulCheckAt" in candidate ? candidate.lastSuccessfulCheckAt : candidate.checkedAt;
+  if (latestVersion !== null && latestVersion !== void 0 && typeof latestVersion !== "string")
+    return null;
+  if (lastAttemptAt !== null && lastAttemptAt !== void 0 && typeof lastAttemptAt !== "string")
+    return null;
+  if (lastSuccessfulCheckAt !== null && lastSuccessfulCheckAt !== void 0 && typeof lastSuccessfulCheckAt !== "string")
+    return null;
+  if ("lastError" in candidate && candidate.lastError !== null && typeof candidate.lastError !== "string")
+    return null;
+  if ("checkSucceeded" in candidate && typeof candidate.checkSucceeded !== "boolean")
+    return null;
+  if ("currentVersion" in candidate && candidate.currentVersion !== null && typeof candidate.currentVersion !== "string")
+    return null;
+  if ("currentVersionDeprecation" in candidate && candidate.currentVersionDeprecation !== null && typeof candidate.currentVersionDeprecation !== "string")
+    return null;
+  const normalizedLatestVersion = latestVersion ?? null;
+  const normalizedLastAttemptAt = lastAttemptAt ?? null;
+  const normalizedLastSuccessfulCheckAt = lastSuccessfulCheckAt ?? null;
+  const checkSucceeded = typeof candidate.checkSucceeded === "boolean" ? candidate.checkSucceeded : normalizedLatestVersion !== null;
+  return {
+    currentVersion: typeof candidate.currentVersion === "string" ? candidate.currentVersion : null,
+    latestVersion: normalizedLatestVersion,
+    lastAttemptAt: normalizedLastAttemptAt,
+    lastSuccessfulCheckAt: normalizedLastSuccessfulCheckAt,
+    lastError: typeof candidate.lastError === "string" ? candidate.lastError : null,
+    checkSucceeded,
+    currentVersionDeprecation: typeof candidate.currentVersionDeprecation === "string" ? candidate.currentVersionDeprecation : null
+  };
+}
+function readStoredUpdateCheck(updateCheckPath, currentVersion) {
+  try {
+    const targetPath = getUpdateCheckPath(updateCheckPath, currentVersion);
+    if (!fs7.existsSync(targetPath))
+      return null;
+    return parseStoredUpdateCheck(JSON.parse(fs7.readFileSync(targetPath, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function getLastUpdateCheck(currentVersion, options = {}) {
+  const stored = readStoredUpdateCheck(options.updateCheckPath, currentVersion);
+  if (!stored)
+    return null;
+  return buildResult(currentVersion, stored, "cache", options.now ?? /* @__PURE__ */ new Date());
+}
+
+// dist/core/update-notice.js
+import fs8 from "fs";
+import path7 from "path";
+var UP_TO_DATE_REFRESH_MS = 60 * 60 * 1e3;
+var UPGRADE_AVAILABLE_REFRESH_MS = 12 * 60 * 60 * 1e3;
+var ANSWER_VALID_MS = 24 * 60 * 60 * 1e3;
+var SNOOZE_LEVEL_MS = [24 * 60 * 60 * 1e3, 48 * 60 * 60 * 1e3, 7 * 24 * 60 * 60 * 1e3];
+var SNOOZE_FILE = "update-snooze.json";
+var JUST_UPGRADED_FILE = "just-upgraded.json";
+function isStrictlyOlder(a, b) {
+  const parse3 = (v) => {
+    const [main2, ...rest] = String(v).split(/[-+]/);
+    const nums = main2.split(".").map((s) => Number.parseInt(s, 10));
+    return { nums, tail: rest.join("-") };
+  };
+  const pa = parse3(a);
+  const pb = parse3(b);
+  const len = Math.max(pa.nums.length, pb.nums.length);
+  for (let i = 0; i < len; i++) {
+    const ai = Number.isFinite(pa.nums[i]) ? pa.nums[i] : 0;
+    const bi = Number.isFinite(pb.nums[i]) ? pb.nums[i] : 0;
+    if (ai !== bi)
+      return ai < bi;
+  }
+  if (pa.tail && !pb.tail)
+    return true;
+  if (!pa.tail && pb.tail)
+    return false;
+  return pa.tail < pb.tail;
+}
+function parseIso(value) {
+  if (typeof value !== "string")
+    return null;
+  const t = Date.parse(value);
+  return Number.isNaN(t) ? null : t;
+}
+function readJson(file2) {
+  try {
+    if (!fs8.existsSync(file2))
+      return null;
+    const parsed = JSON.parse(fs8.readFileSync(file2, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readSnooze(dir) {
+  const raw = readJson(path7.join(dir, SNOOZE_FILE));
+  if (!raw)
+    return null;
+  const { target, level, since } = raw;
+  if (typeof target !== "string" || !target)
+    return null;
+  if (typeof level !== "number" || !Number.isInteger(level) || level < 1)
+    return null;
+  if (parseIso(since) === null)
+    return null;
+  return { target, level, since };
+}
+function snoozeExpiresAt(state) {
+  const since = parseIso(state.since) ?? 0;
+  const duration3 = SNOOZE_LEVEL_MS[Math.min(state.level, SNOOZE_LEVEL_MS.length) - 1];
+  return since + duration3;
+}
+function readJustUpgradedMarker(dir) {
+  const raw = readJson(path7.join(dir, JUST_UPGRADED_FILE));
+  if (!raw)
+    return null;
+  const { from, to, at } = raw;
+  if (typeof from !== "string" || !from || typeof to !== "string" || !to)
+    return null;
+  return { from, to, at: typeof at === "string" ? at : "" };
+}
+function clearJustUpgradedMarker(dir) {
+  try {
+    fs8.unlinkSync(path7.join(dir, JUST_UPGRADED_FILE));
+  } catch {
+  }
+}
+function claimJustUpgradedMarker(dir) {
+  const file2 = path7.join(dir, JUST_UPGRADED_FILE);
+  const taken = `${file2}.claimed-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs8.renameSync(file2, taken);
+  } catch {
+    return null;
+  }
+  const raw = readJson(taken);
+  try {
+    fs8.unlinkSync(taken);
+  } catch {
+  }
+  if (!raw)
+    return null;
+  const { from, to, at } = raw;
+  if (typeof from !== "string" || !from || typeof to !== "string" || !to)
+    return null;
+  return { from, to, at: typeof at === "string" ? at : "" };
+}
+function boundedReason(raw) {
+  const oneLine = redactUserPaths(raw).replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+  return oneLine.length > 160 ? `${oneLine.slice(0, 157)}...` : oneLine;
+}
+function answerIsCurrent(currentVersion, cache, now) {
+  if (!cache || cache.currentVersion !== currentVersion)
+    return false;
+  if (typeof cache.latestVersion !== "string" || !cache.latestVersion)
+    return false;
+  const successAt = parseIso(cache.lastSuccessfulCheckAt);
+  if (successAt === null)
+    return false;
+  return now.getTime() - successAt <= ANSWER_VALID_MS;
+}
+function shouldRefreshUpdateCache(currentVersion, cache, now = /* @__PURE__ */ new Date()) {
+  if (!answerIsCurrent(currentVersion, cache, now))
+    return true;
+  const successAt = parseIso(cache.lastSuccessfulCheckAt);
+  const age = now.getTime() - successAt;
+  const upgrade = isStrictlyOlder(currentVersion, cache.latestVersion);
+  return age > (upgrade ? UPGRADE_AVAILABLE_REFRESH_MS : UP_TO_DATE_REFRESH_MS);
+}
+function resolveUpdateNotice(input) {
+  const { dir, currentVersion, cache } = input;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  if (input.updateCheckEnabled === false)
+    return { kind: "DISABLED", currentVersion };
+  const marker = readJustUpgradedMarker(dir);
+  if (marker) {
+    if (marker.to === currentVersion) {
+      return { kind: "JUST_UPGRADED", currentVersion, from: marker.from, to: marker.to };
+    }
+    clearJustUpgradedMarker(dir);
+  }
+  if (!answerIsCurrent(currentVersion, cache, now)) {
+    let reason = "no update check has completed yet";
+    let attempted = false;
+    if (cache && cache.currentVersion === currentVersion) {
+      attempted = parseIso(cache.lastSuccessfulCheckAt) !== null || typeof cache.lastError === "string" && cache.lastError.length > 0;
+      if (typeof cache.lastError === "string" && cache.lastError)
+        reason = boundedReason(cache.lastError);
+      else if (parseIso(cache.lastSuccessfulCheckAt) !== null)
+        reason = "the last successful check is more than a day old";
+    }
+    return { kind: "CHECK_FAILED", currentVersion, reason, attempted };
+  }
+  const latestVersion = cache.latestVersion;
+  if (!isStrictlyOlder(currentVersion, latestVersion)) {
+    return { kind: "UP_TO_DATE", currentVersion, latestVersion };
+  }
+  const snooze = readSnooze(dir);
+  if (snooze && snooze.target === latestVersion) {
+    const until = snoozeExpiresAt(snooze);
+    if (now.getTime() < until) {
+      return { kind: "SNOOZED", currentVersion, latestVersion, until: new Date(until).toISOString(), level: snooze.level };
+    }
+  }
+  return { kind: "UPGRADE_AVAILABLE", currentVersion, latestVersion };
+}
+
+// dist/core/update-entrypoint.js
+var RECENT_HOOK_NOTICE_MS = 10 * 60 * 1e3;
+var CLI_NOTICE_THROTTLE_MS = 24 * 60 * 60 * 1e3;
+var FRESH_CHECK_THROTTLE_MS = 5 * 60 * 1e3;
+function formatUpdateNoticeLine(notice) {
+  switch (notice.kind) {
+    case "UPGRADE_AVAILABLE":
+      return `[memesh update] ${notice.latestVersion} is available (you are on ${notice.currentVersion}). Run \`memesh update\`, or reply \u201CNot now\u201D / \u201CNever ask again\u201D in a hooked session.`;
+    case "JUST_UPGRADED":
+      return `[memesh update] Upgraded ${notice.from} \u2192 ${notice.to}. Processes started before the upgrade keep running ${notice.from} until they restart.`;
+    case "CHECK_FAILED":
+      return `[memesh update] Could not confirm whether an update exists (${notice.reason}). Status is unknown, not current \u2014 \`memesh status\` retries.`;
+    default:
+      return null;
+  }
+}
+function recentHookNoticeExists(dir, currentVersion, latestVersion, now = /* @__PURE__ */ new Date()) {
+  const claims = path8.join(dir, "update-prompt-claims");
+  let names;
+  try {
+    names = fs9.readdirSync(claims);
+  } catch {
+    return false;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    const file2 = path8.join(claims, name);
+    let fd = null;
+    try {
+      fd = fs9.openSync(file2, "r");
+      const stat = fs9.fstatSync(fd);
+      if (now.getTime() - stat.mtimeMs > RECENT_HOOK_NOTICE_MS)
+        continue;
+      const value = JSON.parse(fs9.readFileSync(fd, "utf8"));
+      if (value.currentVersion === currentVersion && (latestVersion === null || value.latestVersion === latestVersion))
+        return true;
+    } catch {
+    } finally {
+      if (fd !== null)
+        try {
+          fs9.closeSync(fd);
+        } catch {
+        }
+    }
+  }
+  return false;
+}
+function updateCheckEnabledIn(dir) {
+  try {
+    const raw = JSON.parse(fs9.readFileSync(path8.join(dir, "config.json"), "utf8"));
+    return raw.updateCheck !== false;
+  } catch {
+    return true;
+  }
+}
+function cliThrottled(dir, currentVersion, now) {
+  const tag = /^[0-9A-Za-z.+-]+$/.test(currentVersion) ? currentVersion : "unknown";
+  const marker = path8.join(dir, `last-cli-update-notice.${tag}.lock`);
+  let fd = null;
+  try {
+    try {
+      fd = fs9.openSync(marker, "r+");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        return true;
+      }
+      fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+      try {
+        fd = fs9.openSync(marker, "wx", 384);
+      } catch (raceErr) {
+        if (raceErr.code === "EEXIST")
+          return true;
+        throw raceErr;
+      }
+      fs9.writeSync(fd, String(now.getTime()));
+      return false;
+    }
+    const stat = fs9.fstatSync(fd);
+    if (now.getTime() - stat.mtimeMs < CLI_NOTICE_THROTTLE_MS)
+      return true;
+    fs9.ftruncateSync(fd, 0);
+    fs9.writeSync(fd, String(now.getTime()), 0);
+    try {
+      fs9.fchmodSync(fd, 384);
+    } catch {
+    }
+    return false;
+  } catch {
+    return true;
+  } finally {
+    if (fd !== null)
+      try {
+        fs9.closeSync(fd);
+      } catch {
+      }
+  }
+}
+function spawnCacheRefresh(dir, currentVersion, now) {
+  try {
+    const cliPath = fileURLToPath(new URL("../transports/cli/cli.js", import.meta.url));
+    if (!fs9.existsSync(cliPath))
+      return false;
+    const tag = /^[0-9A-Za-z.+-]+$/.test(currentVersion) ? currentVersion : "unknown";
+    const marker = path8.join(dir, `last-fresh-refresh.${tag}.lock`);
+    try {
+      if (now.getTime() - fs9.statSync(marker).mtimeMs < FRESH_CHECK_THROTTLE_MS)
+        return false;
+      fs9.unlinkSync(marker);
+    } catch {
+    }
+    fs9.mkdirSync(dir, { recursive: true, mode: 448 });
+    try {
+      const fd = fs9.openSync(marker, "wx", 384);
+      try {
+        fs9.writeSync(fd, `${process.pid}-${now.getTime()}`);
+      } finally {
+        fs9.closeSync(fd);
+      }
+    } catch {
+      return false;
+    }
+    const child = spawn(process.execPath, [cliPath, "status"], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env },
+      windowsHide: true
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var MCP_PENDING_RETRY_MS = 60 * 1e3;
+var ProcessMemo = class {
+  set;
+  key;
+  now;
+  retryPrefix;
+  constructor(set2, key, now) {
+    this.set = set2;
+    this.key = key;
+    this.now = now;
+    this.retryPrefix = `${key}#retry:`;
+  }
+  decided() {
+    if (!this.set)
+      return false;
+    if (this.set.has(this.key))
+      return true;
+    for (const entry of this.set) {
+      if (entry.startsWith(this.retryPrefix) && this.now.getTime() < Number(entry.slice(this.retryPrefix.length)))
+        return true;
+    }
+    return false;
+  }
+  decide() {
+    this.clearRetry();
+    this.set?.add(this.key);
+  }
+  retryLater() {
+    this.clearRetry();
+    this.set?.add(`${this.retryPrefix}${this.now.getTime() + MCP_PENDING_RETRY_MS}`);
+  }
+  clearRetry() {
+    if (!this.set)
+      return;
+    for (const entry of [...this.set])
+      if (entry.startsWith(this.retryPrefix))
+        this.set.delete(entry);
+  }
+};
+function updateNoticeForEntryPoint(input) {
+  try {
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    const memo = input.entryPoint === "mcp" ? new ProcessMemo(input.processOnce, input.currentVersion, now) : null;
+    if (memo?.decided())
+      return null;
+    const dir = input.dir ?? memeshDir();
+    const updateCheckEnabled = input.updateCheckEnabled ?? updateCheckEnabledIn(dir);
+    const tag = /^[0-9A-Za-z.+-]+$/.test(input.currentVersion) ? input.currentVersion : "unknown";
+    const cache = getLastUpdateCheck(input.currentVersion, { now, updateCheckPath: path8.join(dir, `update-check.${tag}.json`) });
+    if (updateCheckEnabled && shouldRefreshUpdateCache(input.currentVersion, cache, now)) {
+      (input.refresh ?? spawnCacheRefresh)(dir, input.currentVersion, now);
+    }
+    const notice = resolveUpdateNotice({ dir, currentVersion: input.currentVersion, cache, now, updateCheckEnabled });
+    if (notice.kind === "CHECK_FAILED" && !notice.attempted) {
+      memo?.retryLater();
+      return null;
+    }
+    memo?.decide();
+    if (notice.kind === "DISABLED" || notice.kind === "SNOOZED" || notice.kind === "UP_TO_DATE")
+      return null;
+    if (input.entryPoint === "mcp" && recentHookNoticeExists(dir, notice.currentVersion, notice.kind === "UPGRADE_AVAILABLE" ? notice.latestVersion : null, now)) {
+      return null;
+    }
+    if (input.entryPoint === "cli" && cliThrottled(dir, input.currentVersion, now))
+      return null;
+    if (notice.kind === "JUST_UPGRADED") {
+      const claimed = claimJustUpgradedMarker(dir);
+      if (!claimed)
+        return null;
+      return formatUpdateNoticeLine({ ...notice, from: claimed.from, to: claimed.to });
+    }
+    return formatUpdateNoticeLine(notice);
+  } catch {
+    return null;
+  }
+}
+
 // dist/transports/mcp/handlers.js
 function resolveTranscriptWorkspace(project, rootUris) {
   if (!rootUris)
@@ -30152,8 +31110,8 @@ function resolveTranscriptWorkspace(project, rootUris) {
       const parsed = new URL(uri);
       if (parsed.protocol !== "file:")
         continue;
-      const root = fs7.realpathSync(fileURLToPath(parsed));
-      if (!fs7.statSync(root).isDirectory() || getProjectName(root) !== project)
+      const root = fs10.realpathSync(fileURLToPath2(parsed));
+      if (!fs10.statSync(root).isDirectory() || getProjectName(root) !== project)
         continue;
       matches.add(root);
     } catch {
@@ -30173,17 +31131,25 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "remember",
-    description: "Store knowledge as an entity with observations, tags, and relations. Use this to remember decisions, patterns, lessons learned, and important context.",
+    description: "Store knowledge as an entity with observations, tags, and relations. Use this to remember decisions, patterns, lessons learned, and important context. Quickest form: pass only `note` (free text) and the server derives title, observations and name; the response echoes what it derived. To correct a memory, call again with its `name` and `replace: true` \u2014 the memory keeps the `type` it has unless you pass a different one \u2014 and the old content moves to metadata.replaced_history instead of staying next to the fix.",
     inputSchema: {
       type: "object",
       properties: {
         name: {
           type: "string",
-          description: 'Unique entity name (e.g., "auth-decision", "jwt-pattern"). Reusing a name appends observations and dedupes tags instead of replacing the entity.'
+          description: 'Unique entity name (e.g., "auth-decision", "jwt-pattern"). Reusing a name appends observations and dedupes tags instead of replacing the entity (unless `replace` is true). Required unless `note` is given, in which case it is derived from the text (same text \u2192 same name).'
         },
         type: {
           type: "string",
-          description: 'Entity type (e.g., "decision", "pattern", "lesson", "commit")'
+          description: 'Entity type (e.g., "decision", "pattern", "lesson", "commit"). Required unless `note` is given (it then defaults to "note"), or `replace: true` is sent with the `name` of a memory that exists \u2014 that call keeps the stored type. Passing one on a `replace` reclassifies the memory.'
+        },
+        note: {
+          type: "string",
+          description: "Free text, instead of title + observations: the first line becomes the title and each following paragraph an observation. Cannot be combined with `title` or `observations`. Control characters and credential-shaped strings are removed before storing."
+        },
+        replace: {
+          type: "boolean",
+          description: "Rewrite the memory named by `name` instead of appending to it: its observations are replaced (and its tags when `tags` is given, its title when `title` or `note` is given). The previous version is kept in metadata.replaced_history with the time it was replaced. Default false (append)."
         },
         title: {
           type: "string",
@@ -30221,8 +31187,12 @@ var TOOL_DEFINITIONS = [
           description: 'Namespace for organizing the entity. Omit it to leave an existing memory where it is \u2014 supplying it MOVES a memory that already exists, and it drops out of every other scoped view. New memories default to "personal".'
         }
       },
-      required: ["name", "type"],
-      additionalProperties: false
+      additionalProperties: false,
+      anyOf: [
+        { required: ["note"] },
+        { required: ["name", "type"] },
+        { required: ["name", "replace"], properties: { replace: { const: true } } }
+      ]
     }
   },
   {
@@ -30347,7 +31317,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "briefing",
-    description: "The work topology for a project, assembled and ready to use: where the work was left off (goal / next / blocked / done), decisions and direction, lessons not to repeat, what is known, and recent activity \u2014 the same block Claude Code receives at session start. Call once at the START of a session to load project context; use recall for specific questions after that. Content is wrapped as untrusted background data.",
+    description: "The work topology for a project, assembled and ready to use: where the work was left off (goal / next / blocked / done), decisions and direction, lessons not to repeat, what is known, recent activity, and a capped index of the project\u2019s durable memories (one line each, newest first, with [mem:id] handles; structured counts and token cost in `index`) \u2014 the same block Claude Code receives at session start. Call once at the START of a session to load project context; use recall for specific questions after that. Content is wrapped as untrusted background data.",
     inputSchema: {
       type: "object",
       properties: {
@@ -30466,8 +31436,8 @@ function fail(message) {
   return { content: [{ type: "text", text: message }], isError: true };
 }
 function formatIssue(issue2) {
-  const path7 = issue2.path.join(".");
-  return path7 ? `${path7}: ${issue2.message}` : issue2.message;
+  const path10 = issue2.path.join(".");
+  return path10 ? `${path10}: ${issue2.message}` : issue2.message;
 }
 function stripNullProps(value) {
   if (Array.isArray(value))
@@ -30506,7 +31476,26 @@ function parseOrFail(schema, args) {
 function normalizeClientHost(name) {
   return (name ?? "").replace(/[\u0000-\u001F\u007F]/g, "").trim().slice(0, 64) || "mcp";
 }
+var packageVersion = (() => {
+  try {
+    return JSON.parse(fs10.readFileSync(new URL("../../../package.json", import.meta.url), "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+})();
+var firstCallNoticeOnce = /* @__PURE__ */ new Set();
+function withFirstCallNotice(result) {
+  if (result.isError)
+    return result;
+  const line = updateNoticeForEntryPoint({ currentVersion: packageVersion, entryPoint: "mcp", processOnce: firstCallNoticeOnce });
+  if (!line)
+    return result;
+  return { ...result, content: [...result.content, { type: "text", text: line }] };
+}
 async function handleTool(name, args, sourceHost, signal, requestContext = {}) {
+  return withFirstCallNotice(await handleToolInner(name, args, sourceHost, signal, requestContext));
+}
+async function handleToolInner(name, args, sourceHost, signal, requestContext = {}) {
   try {
     if (name === "work_package") {
       const parsed = parseOrFail(WorkPackageSchema, args);
@@ -30666,9 +31655,9 @@ async function handleTool(name, args, sourceHost, signal, requestContext = {}) {
 }
 
 // dist/mcp/server.js
-var packageJsonPath = path6.resolve(path6.dirname(fileURLToPath2(import.meta.url)), "../../package.json");
-var packageVersion = JSON.parse(fs8.readFileSync(packageJsonPath, "utf8")).version ?? "0.0.0";
-var server = new Server({ name: "memesh", version: packageVersion }, { capabilities: { tools: {} } });
+var packageJsonPath = path9.resolve(path9.dirname(fileURLToPath3(import.meta.url)), "../../package.json");
+var packageVersion2 = JSON.parse(fs11.readFileSync(packageJsonPath, "utf8")).version ?? "0.0.0";
+var server = new Server({ name: "memesh", version: packageVersion2 }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: TOOL_DEFINITIONS.map((t) => ({
     name: t.name,