@pcircle/memesh 4.9.4 → 4.10.2

package/dist/mcp/server.js

@@ -3229,8 +3229,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path7) {
-      let input = path7;
+    function removeDotSegments(path11) {
+      let input = path11;
       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 [path11, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path11 && path11 !== "/" ? path11 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6670,7 +6670,7 @@ var require_formats = __commonJS({
       email: /^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i
     };
     exports.formatNames = Object.keys(exports.fullFormats);
-    function isLeapYear(year) {
+    function isLeapYear2(year) {
       return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
     }
     var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
@@ -6682,7 +6682,7 @@ var require_formats = __commonJS({
       const year = +matches[1];
       const month = +matches[2];
       const day = +matches[3];
-      return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
+      return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear2(year) ? 29 : DAYS[month]);
     }
     function compareDate(d1, d2) {
       if (!(d1 && d2))
@@ -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, fs13, 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, fs13[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 fs12 from "fs";
+import path10 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, path11) {
+  if (!path11)
     return obj;
-  return path7.reduce((acc, key) => acc?.[key], obj);
+  return path11.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(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path7);
+    iss.path.unshift(path11);
     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, path11 = []) => {
     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 }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path11, ...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, path11 = []) => {
     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 }, [...path11, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path7, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path11, ...issue2.path]);
       } else {
-        const fullpath = [...path7, ...issue2.path];
+        const fullpath = [...path11, ...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 path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     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 path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path7[0] === defsKey) {
-    const key = path7[1];
+  if (path11[0] === defsKey) {
+    const key = path11[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(path11, options = {}) {
+    super(path11, 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 fs11 from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // dist/core/scoring.js
 var DEFAULT_WEIGHTS = {
@@ -26941,16 +26994,158 @@ 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"];
 
 // dist/core/serializer.js
+var IMPORTABLE_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "title_source",
+  "source_kind",
+  "source",
+  "cluster_key",
+  "dreamed_at",
+  "kind",
+  "project",
+  "previous_namespace",
+  "namespace_moved_at",
+  "split_from",
+  "retired_recall",
+  "priority",
+  "success_criteria",
+  "verification_scenario",
+  "implementation_state",
+  "outcome_state",
+  "accepted_at",
+  "source_ids"
+]);
+var FORGOTTEN_HASH_RE = /^[a-f0-9]{64}$/;
+var MAX_IMPORTED_FORGOTTEN_HASHES = 1e3;
+function validateFreshForgottenHashes(value) {
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  const deduped = [...new Set(value)];
+  if (!deduped.every((h) => typeof h === "string" && FORGOTTEN_HASH_RE.test(h)))
+    return null;
+  return deduped.length <= MAX_IMPORTED_FORGOTTEN_HASHES ? deduped : null;
+}
+function validateFreshSignalScore(value) {
+  return typeof value === "number" && value >= 0 && value <= 1 ? value : null;
+}
+var MAX_IMPORTED_REPLACED_HISTORY_ENTRIES = 50;
+var MAX_IMPORTED_REPLACED_HISTORY_TOTAL_BYTES = 4 * 64 * 1024;
+var REPLACED_HISTORY_ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "replaced_at",
+  "title",
+  "observations",
+  "tags",
+  "truncated"
+]);
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var jsonBytesOf = (v) => Buffer.byteLength(JSON.stringify(v), "utf8");
+function isValidReplacedHistoryEntry(entry) {
+  if (!isPlainObject3(entry))
+    return false;
+  for (const key of Object.keys(entry)) {
+    if (!REPLACED_HISTORY_ENTRY_KEYS.has(key))
+      return false;
+  }
+  if (typeof entry.replaced_at !== "string" || entry.replaced_at.length > 64)
+    return false;
+  if (!(entry.title === null || typeof entry.title === "string" && entry.title.length <= 500))
+    return false;
+  if (!Array.isArray(entry.observations) || !entry.observations.every((o) => typeof o === "string"))
+    return false;
+  if (!Array.isArray(entry.tags) || !entry.tags.every((t) => typeof t === "string"))
+    return false;
+  if ("truncated" in entry && typeof entry.truncated !== "boolean")
+    return false;
+  return true;
+}
+function validateFreshReplacedHistory(value) {
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  if (value.length > MAX_IMPORTED_REPLACED_HISTORY_ENTRIES)
+    return null;
+  if (!value.every(isValidReplacedHistoryEntry))
+    return null;
+  return jsonBytesOf(value) <= MAX_IMPORTED_REPLACED_HISTORY_TOTAL_BYTES ? value : null;
+}
 function buildImportedMetadata(existingMetadata, args) {
-  const { guard: _guard, ...bundledSafe } = args.bundled ?? {};
-  void _guard;
+  const bundled = args.bundled ?? {};
+  const bundledSafe = {};
+  for (const [key, value] of Object.entries(bundled)) {
+    if (IMPORTABLE_METADATA_KEYS.has(key))
+      bundledSafe[key] = value;
+  }
+  const freshForgottenHashes = args.isNewEntity ? validateFreshForgottenHashes(bundled.forgotten_observation_hashes) : null;
+  const freshPin = args.isNewEntity && bundled.pin === true;
+  const freshSignalScore = args.isNewEntity ? validateFreshSignalScore(bundled.signal_score) : null;
+  const freshReplacedHistory = args.isNewEntity ? validateFreshReplacedHistory(bundled.replaced_history) : null;
   return {
     ...existingMetadata ?? {},
     ...bundledSafe,
+    ...freshForgottenHashes ? { forgotten_observation_hashes: freshForgottenHashes } : {},
+    ...freshSignalScore !== null ? { signal_score: freshSignalScore } : {},
+    ...freshPin ? { pin: true } : {},
+    ...freshReplacedHistory ? { replaced_history: freshReplacedHistory } : {},
     trust: "untrusted",
     provenance: {
       ...existingMetadata?.provenance ?? {},
@@ -27020,6 +27215,12 @@ function importMemories(args) {
   if (!MERGE_STRATEGIES.includes(args.merge_strategy)) {
     throw new Error(`Unknown merge strategy "${args.merge_strategy}". Use one of: ${MERGE_STRATEGIES.join(", ")}. Nothing was imported \u2014 refusing rather than guessing, because the wrong guess overwrites existing memories.`);
   }
+  if (args.restore_archived !== void 0 && typeof args.restore_archived !== "boolean") {
+    throw new Error('restore_archived must be the boolean true or false. Nothing was imported \u2014 refusing rather than guessing, because "yes" brings back memories the user forgot.');
+  }
+  if (args.restore_archived === true && args.merge_strategy === "skip") {
+    throw new Error('restore_archived (--restore-archived) only applies with merge strategy "append" or "overwrite"; "skip" leaves every existing entity untouched, so there is nothing to restore. Nothing was imported.');
+  }
   if (args.namespace !== void 0 && !NAMESPACES.includes(args.namespace)) {
     throw new Error(`Unknown namespace "${args.namespace}". Use one of: ${NAMESPACES.join(", ")}. Nothing was imported \u2014 an unrecognised namespace would move existing memories somewhere nothing queries.`);
   }
@@ -27034,6 +27235,7 @@ function importMemories(args) {
   const pendingRelations = [];
   let skipped = 0;
   let appended = 0;
+  let keptArchived = 0;
   const errors = [];
   const skippedRelations = [];
   const setCreatedAt = db2.prepare("UPDATE entities SET created_at = ? WHERE name = ?");
@@ -27054,11 +27256,14 @@ function importMemories(args) {
           bundled: entity.metadata,
           exportedAt: args.data.exported_at,
           importVersion: args.data.version,
-          mergeStrategy: args.merge_strategy
+          mergeStrategy: args.merge_strategy,
+          isNewEntity: !existing
         });
         if (existing) {
           if (args.merge_strategy === "skip")
             return { kind: "skipped" };
+          if (existing.archived && args.restore_archived !== true)
+            return { kind: "keptArchived" };
           if (args.merge_strategy === "append") {
             const existingText = new Set(existing.observations);
             const newObservations = (entity.observations ?? []).filter((o) => !existingText.has(o));
@@ -27107,6 +27312,8 @@ function importMemories(args) {
       }).immediate();
       if (outcome.kind === "skipped")
         skipped++;
+      else if (outcome.kind === "keptArchived")
+        keptArchived++;
       else if (outcome.kind === "appended")
         appended++;
       else {
@@ -27130,7 +27337,7 @@ function importMemories(args) {
       errors.push(`${rel.from} -${rel.type}-> ${rel.to}: relation not restored (${err instanceof Error ? err.message : String(err)})`);
     }
   }
-  return { imported, overwritten, skipped, appended, errors, skipped_relations: skippedRelations };
+  return { imported, overwritten, skipped, appended, kept_archived: keptArchived, errors, skipped_relations: skippedRelations };
 }
 
 // dist/core/operations.js
@@ -27152,19 +27359,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 +27474,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 +27504,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 +27590,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 +27637,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 +27827,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 +27937,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 +28143,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)) {
@@ -28058,10 +28369,72 @@ function computePatterns(db2, categories) {
   };
 }
 
-// dist/core/repo-state.js
-import { execFileSync as execFileSync2 } from "child_process";
+// dist/core/config.js
 import fs4 from "fs";
 import path4 from "path";
+function configDir() {
+  return memeshDir();
+}
+function configFilePath() {
+  return path4.join(configDir(), "config.json");
+}
+var lastConfigReadWarning = null;
+function warnUnreadable(p, detail) {
+  const key = `${p}::${detail}`;
+  if (key === lastConfigReadWarning)
+    return;
+  lastConfigReadWarning = key;
+  try {
+    process.stderr.write(`[memesh config] ${p} exists but could not be read as a settings object (${detail}). Existing settings are ignored and will not be overwritten until the file is fixed.
+`);
+  } catch {
+  }
+}
+function readRawConfigResult() {
+  const p = configFilePath();
+  if (!fs4.existsSync(p))
+    return { raw: {}, state: "absent" };
+  try {
+    const parsed = JSON.parse(fs4.readFileSync(p, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("top-level JSON value is not an object");
+    }
+    return { raw: parsed, state: "ok" };
+  } catch (error51) {
+    warnUnreadable(p, error51 instanceof Error ? error51.message : String(error51));
+    return { raw: {}, state: "unreadable" };
+  }
+}
+function selectConfig(raw) {
+  const config2 = {};
+  if (typeof raw.autoCapture === "boolean")
+    config2.autoCapture = raw.autoCapture;
+  if (typeof raw.sessionLimit === "number" && Number.isFinite(raw.sessionLimit)) {
+    config2.sessionLimit = raw.sessionLimit;
+  }
+  if (raw.autoUpdate === "off" || raw.autoUpdate === "patch" || raw.autoUpdate === "minor" || raw.autoUpdate === "major") {
+    config2.autoUpdate = raw.autoUpdate;
+  }
+  if (typeof raw.updateCheck === "boolean")
+    config2.updateCheck = raw.updateCheck;
+  if (typeof raw.setupCompleted === "boolean")
+    config2.setupCompleted = raw.setupCompleted;
+  if (raw.briefing !== void 0)
+    config2.briefing = raw.briefing;
+  return config2;
+}
+function readConfigResult() {
+  const result = readRawConfigResult();
+  return { config: selectConfig(result.raw), state: result.state };
+}
+function readConfig() {
+  return readConfigResult().config;
+}
+
+// dist/core/repo-state.js
+import { execFileSync as execFileSync2 } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
 var GIT_TIMEOUT_MS = 5e3;
 function tryGit2(cwd, args) {
   try {
@@ -28076,7 +28449,7 @@ function tryGit2(cwd, args) {
 }
 function declaredVersionOf(repoRoot) {
   try {
-    const raw = fs4.readFileSync(path4.join(repoRoot, "package.json"), "utf8");
+    const raw = fs5.readFileSync(path5.join(repoRoot, "package.json"), "utf8");
     const version2 = JSON.parse(raw).version;
     return typeof version2 === "string" && version2.length > 0 ? version2 : null;
   } catch {
@@ -28215,26 +28588,109 @@ function taskStateLines(state, project, now = /* @__PURE__ */ new Date()) {
   }
   return lines;
 }
+var STALE_TASK_STATE_HOURS = 72;
+var CLOCK_SKEW_ALLOWANCE_MINUTES = 5;
+var ZONED_INSTANT = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})[Tt](?<hour>\d{2}):(?<minute>\d{2})(?::(?<second>\d{2})(?:\.\d+)?)?(?:(?<zulu>[Zz])|(?<offSign>[+-])(?<offHour>\d{2}):?(?<offMinute>\d{2}))$/;
+function isLeapYear(year) {
+  return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function daysInMonth(year, month) {
+  return month === 2 && isLeapYear(year) ? 29 : DAYS_IN_MONTH[month - 1];
+}
+function isRealInstant(groups) {
+  const year = Number(groups.year);
+  const month = Number(groups.month);
+  const day = Number(groups.day);
+  const hour = Number(groups.hour);
+  const minute = Number(groups.minute);
+  const second = groups.second === void 0 ? 0 : Number(groups.second);
+  if (month < 1 || month > 12)
+    return false;
+  if (day < 1 || day > daysInMonth(year, month))
+    return false;
+  if (hour > 23)
+    return false;
+  if (minute > 59)
+    return false;
+  if (second > 59)
+    return false;
+  if (groups.zulu === void 0) {
+    const offHour = Number(groups.offHour);
+    const offMinute = Number(groups.offMinute);
+    if (offHour > 23 || offMinute > 59)
+      return false;
+    if (groups.offSign === "-" && offHour === 0 && offMinute === 0)
+      return false;
+  }
+  return true;
+}
+function resolveTaskStateAge(updatedAt, now) {
+  if (!updatedAt)
+    return { known: false };
+  const match = ZONED_INSTANT.exec(updatedAt);
+  if (!match?.groups || !isRealInstant(match.groups))
+    return { known: false };
+  const then = Date.parse(updatedAt);
+  if (Number.isNaN(then))
+    return { known: false };
+  const hours = (now.getTime() - then) / 36e5;
+  if (hours < -(CLOCK_SKEW_ALLOWANCE_MINUTES / 60))
+    return { known: false };
+  return { known: true, hours: Math.max(0, hours) };
+}
+function staleTaskStateLine(project, hours) {
+  const days = Math.floor(hours / 24);
+  const age = days >= 1 ? `${days} day${days === 1 ? "" : "s"} ago` : `${Math.floor(hours)} hour${Math.floor(hours) === 1 ? "" : "s"} ago`;
+  return `Task state for "${project}" was last stated ${age} \u2014 older than ${STALE_TASK_STATE_HOURS}h, so it is not shown as current. Run \`memesh task\` to see or update it.`;
+}
+function taskStateAgeUnknownLine(project) {
+  return `Task state for "${project}" has a missing, unreadable, or future-dated timestamp, so its age could not be established \u2014 not shown as current. Run \`memesh task\` to see or update it.`;
+}
+function briefingTaskStateLines(state, project, now = /* @__PURE__ */ new Date(), { includeFresh = true } = {}) {
+  if (isEmptyTaskState(state))
+    return [];
+  const age = resolveTaskStateAge(state.updated_at, now);
+  if (!age.known)
+    return [taskStateAgeUnknownLine(project)];
+  if (age.hours > STALE_TASK_STATE_HOURS) {
+    return [staleTaskStateLine(project, age.hours)];
+  }
+  return includeFresh ? taskStateLines(state, project, now) : [];
+}
 
 // dist/core/task-state-store.js
 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 };
@@ -28295,7 +28751,7 @@ function unreadInboxLines(count, project, recipient, everSeen) {
   const displayRecipient = JSON.stringify(recipient);
   if (count > 0) {
     const noun = count === 1 ? "message" : "messages";
-    return [`${count} ${noun} waiting for ${displayRecipient} in project ${displayProject} \u2014 poll the message tool with project ${displayProject} and recipient ${displayRecipient}, then fetch each message_id; fetching does not acknowledge.`];
+    return [`${count} ${noun} waiting for ${displayRecipient} in project ${displayProject} \u2014 poll the message tool with project ${displayProject} and recipient ${displayRecipient}, then fetch each message_id and record the intake action for it: fetching alone does not acknowledge, and only intake ends this line.`];
   }
   if (everSeen === false) {
     return [`No messages waiting for ${displayRecipient} in project ${displayProject} \u2014 and this recipient id has never been seen in this project (check for a typo).`];
@@ -28528,6 +28984,9 @@ function assembleTopologyBlock(stateLines, pools, projectName, budget = DEFAULT_
   lines.push(...globalLines);
   return lines;
 }
+function hasBriefingContent(lines) {
+  return lines.length > 0;
+}
 function buildReferenceContext(memoryLines) {
   const safeLines = memoryLines.map((line) => String(line ?? "").replace(/[\s\u0085\u001c-\u001e]+/g, " ").trim());
   let longestRun = 0;
@@ -28547,6 +29006,214 @@ 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-level.js
+var BRIEFING_LEVELS = ["minimal", "standard", "full"];
+var DEFAULT_BRIEFING_LEVEL = "standard";
+function isBriefingLevel(value) {
+  return typeof value === "string" && BRIEFING_LEVELS.includes(value);
+}
+var INVALID_VALUE_SERIALIZED_MAX = 100;
+var PRE_SLICE_RAW_MAX = 256;
+function safeRawPreSlice(value, maxUnits) {
+  if (value.length <= maxUnits)
+    return value;
+  let end = maxUnits;
+  const lastKept = value.charCodeAt(end - 1);
+  const nextUnit = value.charCodeAt(end);
+  const lastKeptIsHighSurrogate = lastKept >= 55296 && lastKept <= 56319;
+  const nextUnitIsLowSurrogate = nextUnit >= 56320 && nextUnit <= 57343;
+  if (lastKeptIsHighSurrogate && nextUnitIsLowSurrogate)
+    end -= 1;
+  return value.slice(0, end);
+}
+function truncateToSerializedBound(codePoints) {
+  let kept = 0;
+  for (; kept < codePoints.length; kept++) {
+    const candidate = JSON.stringify(`${codePoints.slice(0, kept + 1).join("")}\u2026`);
+    if (candidate.length > INVALID_VALUE_SERIALIZED_MAX)
+      break;
+  }
+  return JSON.stringify(`${codePoints.slice(0, kept).join("")}\u2026`);
+}
+function describeInvalidValue(value) {
+  if (typeof value === "string") {
+    if (value.length <= INVALID_VALUE_SERIALIZED_MAX) {
+      const whole = JSON.stringify(value);
+      if (whole.length <= INVALID_VALUE_SERIALIZED_MAX)
+        return whole;
+      return truncateToSerializedBound(Array.from(value));
+    }
+    return truncateToSerializedBound(Array.from(safeRawPreSlice(value, PRE_SLICE_RAW_MAX)));
+  }
+  if (Array.isArray(value))
+    return "[array]";
+  if (value !== null && typeof value === "object")
+    return "[object]";
+  if (typeof value === "bigint")
+    return "[bigint]";
+  if (typeof value === "symbol")
+    return "[symbol]";
+  if (typeof value === "function")
+    return "[function]";
+  return JSON.stringify(value) ?? String(value);
+}
+function resolveBriefingLevel(envValue, configValue) {
+  if (envValue !== void 0) {
+    if (isBriefingLevel(envValue))
+      return { level: envValue, invalid: null };
+    return { level: DEFAULT_BRIEFING_LEVEL, invalid: { source: "env", value: describeInvalidValue(envValue) } };
+  }
+  if (configValue !== void 0) {
+    if (isBriefingLevel(configValue))
+      return { level: configValue, invalid: null };
+    return { level: DEFAULT_BRIEFING_LEVEL, invalid: { source: "config", value: describeInvalidValue(configValue) } };
+  }
+  return { level: DEFAULT_BRIEFING_LEVEL, invalid: null };
+}
+var POLICIES = {
+  minimal: { global: false, foreign: false, taskState: false, index: false, workPackageNotice: false },
+  standard: { global: false, foreign: false, taskState: true, index: true, workPackageNotice: false },
+  full: { global: true, foreign: true, taskState: true, index: true, workPackageNotice: true }
+};
+function briefingLevelPolicy(level) {
+  return POLICIES[level];
+}
+
 // dist/core/briefing.js
 var PROJECT_LIMIT = 30;
 var RECENT_LIMIT = 5;
@@ -28587,16 +29254,61 @@ 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 resolvedLevel = resolveBriefingLevel(process.env.MEMESH_BRIEFING, readConfig().briefing);
+  if (resolvedLevel.invalid) {
+    const { source, value } = resolvedLevel.invalid;
+    try {
+      process.stderr.write(`[memesh briefing] invalid ${source} briefing level ${value} \u2014 using "${resolvedLevel.level}"
+`);
+    } catch {
+    }
+  }
+  const level = resolvedLevel.level;
+  const policy = briefingLevelPolicy(level);
   const repoLines = project === void 0 || project === getProjectName() ? repoStateLines(readRepoState()) : [];
-  const { state } = getTaskState(projectName);
+  let taskLines;
+  try {
+    taskLines = briefingTaskStateLines(getTaskState(projectName).state, projectName, /* @__PURE__ */ new Date(), {
+      includeFresh: policy.taskState
+    });
+  } 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");
@@ -28607,17 +29319,17 @@ function assembleBriefing(project, recipient) {
      ORDER BY e.id DESC
      LIMIT ?`).all(`project:${projectName}`, TOPOLOGY_CANDIDATE_CAP);
   const projectPool = selectPool(projectRows, PROJECT_LIMIT);
-  const globalRows = hasNamespace ? db2.prepare(`SELECT ${CANDIDATE_COLUMNS}
+  const globalRows = policy.global && hasNamespace ? db2.prepare(`SELECT ${CANDIDATE_COLUMNS}
        FROM entities e
        WHERE e.namespace = 'global' AND e.status = 'active'
        ORDER BY e.id DESC
        LIMIT ?`).all(TOPOLOGY_CANDIDATE_CAP) : [];
   const globalPool = selectPool(globalRows, GLOBAL_TOPOLOGY_LIMIT);
-  const recentRows = db2.prepare(`SELECT ${CANDIDATE_COLUMNS}
-     FROM entities e
-     WHERE e.status = 'active'${nonGlobal}
-     ORDER BY e.id DESC
-     LIMIT ?`).all(TOPOLOGY_CANDIDATE_CAP);
+  const recentRows = policy.foreign ? db2.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM entities e
+       WHERE e.status = 'active'${nonGlobal}
+       ORDER BY e.id DESC
+       LIMIT ?`).all(TOPOLOGY_CANDIDATE_CAP) : [];
   const recentPool = selectPool(recentRows, RECENT_LIMIT);
   const survivorIds = [...new Set([...projectPool, ...globalPool, ...recentPool].map((row) => row.id))];
   const snippets = /* @__PURE__ */ new Map();
@@ -28641,11 +29353,18 @@ 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 indexLines = policy.index ? index.lines : [];
+  const block = withRepo.length > 0 && indexLines.length > 0 ? [...withRepo, "", ...indexLines] : [...withRepo, ...indexLines];
+  const empty = !hasBriefingContent(block);
   return {
     project: projectName,
-    text: lines.length > 0 ? buildReferenceContext(withRepo) : "",
+    text: empty ? "" : buildReferenceContext(block),
     entityCount: lines.filter((l) => l.startsWith("- [")).length,
-    hasTaskState: stateLines.length > 0
+    hasTaskState: stateLines.length > 0,
+    index,
+    level,
+    empty
   };
 }
 
@@ -28653,11 +29372,11 @@ 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 fs5 from "node:fs";
+import { createHash as createHash8, randomUUID } from "node:crypto";
+import fs6 from "node:fs";
 var TERMINAL_WORKFLOW_STATES = /* @__PURE__ */ new Set(["completed", "cancelled", "rejected"]);
 var AgentMessageStorageError = class extends Error {
   code;
@@ -29289,7 +30008,7 @@ function parseTargetKind(value) {
 }
 function parseJsonObject(json2, label) {
   const parsed = parseJsonObjectOrValue(json2);
-  if (!isPlainObject3(parsed))
+  if (!isPlainObject4(parsed))
     throw new AgentMessagingError(`${label} must contain a JSON object.`);
   return parsed;
 }
@@ -29304,7 +30023,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)
@@ -29339,7 +30058,7 @@ function assertJsonValue(value, label) {
     value.forEach((entry, index) => assertJsonValue(entry, `${label}[${index}]`));
     return;
   }
-  if (isPlainObject3(value)) {
+  if (isPlainObject4(value)) {
     for (const [key, entry] of Object.entries(value)) {
       assertJsonValue(entry, `${label}.${key}`);
     }
@@ -29351,7 +30070,7 @@ function normalizeObject(value) {
   assertJsonValue(value, "object");
   return value;
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function requireText(label, value, maxLength) {
@@ -29454,14 +30173,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(),
@@ -29496,7 +30239,8 @@ var ExportResultSchema = external_exports.object({
 var ImportSchema = external_exports.object({
   data: ExportResultSchema,
   namespace: external_exports.enum(NAMESPACES).optional(),
-  merge_strategy: external_exports.enum(["skip", "overwrite", "append"])
+  merge_strategy: external_exports.enum(["skip", "overwrite", "append"]),
+  restore_archived: external_exports.boolean().optional()
 }).strict();
 var LearnSchema = external_exports.object({
   error: external_exports.string().min(1).max(5e3),
@@ -29623,9 +30367,9 @@ var MessageSchema = external_exports.discriminatedUnion("action", [
 
 // dist/core/agent-router.js
 import { randomUUID as randomUUID3 } from "node:crypto";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import net from "node:net";
-import path5 from "node:path";
+import path6 from "node:path";
 var AGENT_ROUTER_PROTOCOL_VERSION = 2;
 var AGENT_ROUTER_MAX_FRAME_BYTES = 64 * 1024;
 var MAX_LEASE_MS = 5 * 6e4;
@@ -29633,9 +30377,9 @@ var DEFAULT_CLIENT_TIMEOUT_MS = 2e3;
 var MAX_FIELD_LENGTH = 200;
 var MAX_ADAPTER_RECEIPT_BYTES = 16 * 1024;
 function isLegacyAgentRouterVersionMismatchResponse(value) {
-  if (!isPlainObject4(value) || value.version !== 1 || value.request_id !== "" || value.ok !== false)
+  if (!isPlainObject5(value) || value.version !== 1 || value.request_id !== "" || value.ok !== false)
     return false;
-  if (!isPlainObject4(value.error))
+  if (!isPlainObject5(value.error))
     return false;
   return value.error.code === "unsupported_type" || value.error.code === "unsupported_version";
 }
@@ -29703,7 +30447,7 @@ async function sendAgentRouterRequest(socketPath, request, timeoutMs = DEFAULT_C
         if (isLegacyAgentRouterVersionMismatchResponse(response)) {
           throw new AgentRouterProtocolError("router_version_mismatch", "router_version_mismatch: the configured router endpoint uses a stale protocol; restart that router with the current MeMesh version.");
         }
-        const uncorrelatedError = response.request_id === "" && response.ok === false && isPlainObject4(response.error) && typeof response.error.code === "string" && typeof response.error.message === "string";
+        const uncorrelatedError = response.request_id === "" && response.ok === false && isPlainObject5(response.error) && typeof response.error.code === "string" && typeof response.error.message === "string";
         if (response.version !== AGENT_ROUTER_PROTOCOL_VERSION || response.request_id !== request.request_id && !uncorrelatedError) {
           throw new AgentRouterProtocolError("invalid_response", "Router response identity does not match.");
         }
@@ -29722,7 +30466,7 @@ async function sendAgentRouterRequest(socketPath, request, timeoutMs = DEFAULT_C
   });
 }
 function validateRouterSuccessResult(request, value) {
-  if (!isPlainObject4(value)) {
+  if (!isPlainObject5(value)) {
     throw new AgentRouterProtocolError("invalid_response", "Router response result must be an object.");
   }
   const requireResultString = (field) => {
@@ -29780,17 +30524,17 @@ function validateRouterSuccessResult(request, value) {
   return value;
 }
 function isSelectionCard(value, project) {
-  if (!isPlainObject4(value))
+  if (!isPlainObject5(value))
     return false;
   return typeof value.session_id === "string" && typeof value.principal_id === "string" && ["codex", "claude", "gemini", "other"].includes(String(value.host_kind)) && value.project === project && (value.model === null || typeof value.model === "string") && (value.work_summary === null || typeof value.work_summary === "string") && value.active === true && Number.isSafeInteger(value.generation) && value.generation >= 1 && Number.isSafeInteger(value.lease_expires_at_ms) && value.lease_expires_at_ms >= 0;
 }
 function validateSocketPath(socketPath) {
-  if (typeof socketPath !== "string" || !path5.isAbsolute(socketPath) || Buffer.byteLength(socketPath) > 103) {
+  if (typeof socketPath !== "string" || !path6.isAbsolute(socketPath) || Buffer.byteLength(socketPath) > 103) {
     throw new AgentRouterProtocolError("invalid_socket_path", "Router socket path must be absolute and at most 103 bytes.");
   }
   return socketPath;
 }
-function isPlainObject4(value) {
+function isPlainObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -30142,6 +30886,543 @@ async function executeAgentMessageAction(db2, rawInput, context, dependencies =
   }
 }
 
+// dist/core/update-entrypoint.js
+import fs10 from "fs";
+import path9 from "path";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+// dist/core/version-check.js
+import fs8 from "fs";
+import path7 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 path7.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 (!fs8.existsSync(targetPath))
+      return null;
+    return parseStoredUpdateCheck(JSON.parse(fs8.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 fs9 from "fs";
+import path8 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 (!fs9.existsSync(file2))
+      return null;
+    const parsed = JSON.parse(fs9.readFileSync(file2, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function readSnooze(dir) {
+  const raw = readJson(path8.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(path8.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 {
+    fs9.unlinkSync(path8.join(dir, JUST_UPGRADED_FILE));
+  } catch {
+  }
+}
+function claimJustUpgradedMarker(dir) {
+  const file2 = path8.join(dir, JUST_UPGRADED_FILE);
+  const taken = `${file2}.claimed-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    fs9.renameSync(file2, taken);
+  } catch {
+    return null;
+  }
+  const raw = readJson(taken);
+  try {
+    fs9.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 = path9.join(dir, "update-prompt-claims");
+  let names;
+  try {
+    names = fs10.readdirSync(claims);
+  } catch {
+    return false;
+  }
+  for (const name of names) {
+    if (!name.endsWith(".json"))
+      continue;
+    const file2 = path9.join(claims, name);
+    let fd = null;
+    try {
+      fd = fs10.openSync(file2, "r");
+      const stat = fs10.fstatSync(fd);
+      if (now.getTime() - stat.mtimeMs > RECENT_HOOK_NOTICE_MS)
+        continue;
+      const value = JSON.parse(fs10.readFileSync(fd, "utf8"));
+      if (value.currentVersion === currentVersion && (latestVersion === null || value.latestVersion === latestVersion))
+        return true;
+    } catch {
+    } finally {
+      if (fd !== null)
+        try {
+          fs10.closeSync(fd);
+        } catch {
+        }
+    }
+  }
+  return false;
+}
+function updateCheckEnabledIn(dir) {
+  try {
+    const raw = JSON.parse(fs10.readFileSync(path9.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 = path9.join(dir, `last-cli-update-notice.${tag}.lock`);
+  let fd = null;
+  try {
+    try {
+      fd = fs10.openSync(marker, "r+");
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        return true;
+      }
+      fs10.mkdirSync(dir, { recursive: true, mode: 448 });
+      try {
+        fd = fs10.openSync(marker, "wx", 384);
+      } catch (raceErr) {
+        if (raceErr.code === "EEXIST")
+          return true;
+        throw raceErr;
+      }
+      fs10.writeSync(fd, String(now.getTime()));
+      return false;
+    }
+    const stat = fs10.fstatSync(fd);
+    if (now.getTime() - stat.mtimeMs < CLI_NOTICE_THROTTLE_MS)
+      return true;
+    fs10.ftruncateSync(fd, 0);
+    fs10.writeSync(fd, String(now.getTime()), 0);
+    try {
+      fs10.fchmodSync(fd, 384);
+    } catch {
+    }
+    return false;
+  } catch {
+    return true;
+  } finally {
+    if (fd !== null)
+      try {
+        fs10.closeSync(fd);
+      } catch {
+      }
+  }
+}
+function spawnCacheRefresh(dir, currentVersion, now) {
+  try {
+    const cliPath = fileURLToPath(new URL("../transports/cli/cli.js", import.meta.url));
+    if (!fs10.existsSync(cliPath))
+      return false;
+    const tag = /^[0-9A-Za-z.+-]+$/.test(currentVersion) ? currentVersion : "unknown";
+    const marker = path9.join(dir, `last-fresh-refresh.${tag}.lock`);
+    try {
+      if (now.getTime() - fs10.statSync(marker).mtimeMs < FRESH_CHECK_THROTTLE_MS)
+        return false;
+      fs10.unlinkSync(marker);
+    } catch {
+    }
+    fs10.mkdirSync(dir, { recursive: true, mode: 448 });
+    try {
+      const fd = fs10.openSync(marker, "wx", 384);
+      try {
+        fs10.writeSync(fd, `${process.pid}-${now.getTime()}`);
+      } finally {
+        fs10.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: path9.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 +31433,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 = fs11.realpathSync(fileURLToPath2(parsed));
+      if (!fs11.statSync(root).isDirectory() || getProjectName(root) !== project)
         continue;
       matches.add(root);
     } catch {
@@ -30173,17 +31454,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 +31510,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 } } }
+      ]
     }
   },
   {
@@ -30291,7 +31584,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "import",
-    description: "Import memories from a JSON export snapshot. Supports skip, append, or overwrite strategies for handling existing entities.",
+    description: "Import memories from a JSON export snapshot. Supports skip, append, or overwrite strategies for handling existing entities. A local memory that was forgotten (archived) stays archived unless restore_archived is true; the result reports how many were left as they were in kept_archived.",
     inputSchema: {
       type: "object",
       properties: {
@@ -30301,6 +31594,10 @@ var TOOL_DEFINITIONS = [
           type: "string",
           enum: ["skip", "overwrite", "append"],
           description: "Required. How to handle an entity that already exists: skip = leave it untouched, append = add these observations to it, overwrite = REPLACE its observations and tags (the old ones are deleted, not archived \u2014 this cannot be undone)"
+        },
+        restore_archived: {
+          type: "boolean",
+          description: "Optional, default false. With append or overwrite, a local entity that is archived (forgotten) is left untouched and counted in kept_archived. Set true to bring it back to active and merge or overwrite it like any other; it requires merge_strategy append or overwrite (an error with skip). Only set it when the user asked for archived memories to return."
         }
       },
       required: ["data", "merge_strategy"],
@@ -30329,7 +31626,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: "task_state",
-    description: 'Read or update where the work stands on this project: the goal, what is next, what is blocked, what was just finished. Call with no arguments to read it. Injected at the start of the next session, so record ONLY what the user actually stated \u2014 never infer a goal or a next step from files edited or commands run, and leave a field out if it was not said. Pass an empty string to clear a field (e.g. blocked: "" once a blocker is resolved).',
+    description: `Read or update where the work stands on this project: the goal, what is next, what is blocked, what was just finished. Call with no arguments to read it. Included in the next session's briefing at the default level, so record ONLY what the user actually stated \u2014 never infer a goal or a next step from files edited or commands run, and leave a field out if it was not said. Pass an empty string to clear a field (e.g. blocked: "" once a blocker is resolved).`,
     inputSchema: {
       type: "object",
       properties: {
@@ -30347,7 +31644,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 memory block Claude Code receives at session start (at `full`, the SessionStart hook additionally appends a work-package notice; that notice is a host-agent instruction, not memory, and is never part of this tool\u2019s output). How much of this is assembled follows the `briefing` setting (`minimal`, `standard` \u2014 the default, described above \u2014 or `full`, which additionally includes memories from other projects and global memory); at `minimal` it is only this project\u2019s live repository state, decisions, lessons, known facts and recent activity, with no task state and no index, and may be empty. 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 +31763,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 path11 = issue2.path.join(".");
+  return path11 ? `${path11}: ${issue2.message}` : issue2.message;
 }
 function stripNullProps(value) {
   if (Array.isArray(value))
@@ -30506,7 +31803,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(fs11.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 +31982,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 = path10.resolve(path10.dirname(fileURLToPath3(import.meta.url)), "../../package.json");
+var packageVersion2 = JSON.parse(fs12.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,