@theglitchking/semantic-memory 1.2.2 → 1.5.0

package/dist/mcp/server.js

@@ -1,19 +1,53 @@
+import {
+  SPEAKER_PROFILE_PATH,
+  initSpeakerProfile,
+  readSpeakerProfile,
+  updateProfileSection
+} from "../chunk-7M3JZOYH.js";
 import {
   FrontmatterManager,
   NoteCrud,
-  SessionManager,
   TagManager,
   Watcher,
   applyPatch,
   buildIngestChangeSet,
   buildPromoteChangeSet,
   buildSynthesizeChangeSet,
-  deriveSessionDir,
   inspectAgentsContract,
   regenDirectoryIndex,
   regenIndexesForPaths,
   regenerateAgentsContract
-} from "../chunk-CYWPDFNI.js";
+} from "../chunk-CSXZ7QUU.js";
+import {
+  lintVault
+} from "../chunk-FM26NFTR.js";
+import {
+  appendEvent,
+  readSelectionLog,
+  recordSearchForCorrelation,
+  wasRecentlySearched
+} from "../chunk-NTYYS53O.js";
+import {
+  addAlias,
+  compileLexicon,
+  expandQuery,
+  loadLexiconCache,
+  removeAlias
+} from "../chunk-A3KYHKB5.js";
+import {
+  appendIncident,
+  compileDossiers,
+  extractSection,
+  initDossier,
+  listDossiers,
+  resolveDossierPath,
+  setCurrentState
+} from "../chunk-WSU4QIPB.js";
+import {
+  SessionManager,
+  deriveProjectRoot,
+  deriveSessionDir
+} from "../chunk-S4KW7VH4.js";
 import {
   Embedder,
   GraphBuilder,
@@ -22,17 +56,19 @@ import {
 } from "../chunk-25EIQWXL.js";
 import {
   Indexer
-} from "../chunk-HODDRXJK.js";
+} from "../chunk-V45NJIHI.js";
 import {
   logEvent,
   logQuery
 } from "../chunk-JPQHNG3R.js";
-import {
-  lintVault
-} from "../chunk-CAN2GWUG.js";
 import {
   installDefaultSchema
-} from "../chunk-E2Z4J4MK.js";
+} from "../chunk-OWZWMB4P.js";
+import {
+  computeDecay,
+  loadDecayConfig,
+  normalizeVerifiedDate
+} from "../chunk-5ZKNO6ZD.js";
 import {
   __export
 } from "../chunk-PZ5AY32C.js";
@@ -43,10 +79,83 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 
 // src/mcp/context.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+
+// src/core/path-class.ts
+import { existsSync, readFileSync } from "fs";
 import { join } from "path";
-import { existsSync } from "fs";
+import { parse as parseYaml } from "yaml";
+import { minimatch } from "minimatch";
+var DEFAULT_PATH_CLASS_CONFIG = {
+  enabled: true,
+  rules: [{ glob: "archive/**", multiplier: 0.3 }]
+};
+function pathClassMultiplier(path, config) {
+  if (!config.enabled) return 1;
+  for (const rule of config.rules) {
+    if (typeof rule.multiplier !== "number") continue;
+    if (minimatch(path, rule.glob)) return rule.multiplier;
+  }
+  return 1;
+}
+function loadPathClassConfig(vaultPath) {
+  try {
+    const schemaPath = join(vaultPath, "vault.schema.yml");
+    if (!existsSync(schemaPath)) return DEFAULT_PATH_CLASS_CONFIG;
+    const parsed = parseYaml(readFileSync(schemaPath, "utf-8"));
+    const p = parsed?.path_class;
+    if (!p || typeof p !== "object") return DEFAULT_PATH_CLASS_CONFIG;
+    return {
+      enabled: typeof p.enabled === "boolean" ? p.enabled : DEFAULT_PATH_CLASS_CONFIG.enabled,
+      rules: Array.isArray(p.rules) ? p.rules.filter((r) => !!r && typeof r.glob === "string" && typeof r.multiplier === "number") : DEFAULT_PATH_CLASS_CONFIG.rules
+    };
+  } catch {
+    return DEFAULT_PATH_CLASS_CONFIG;
+  }
+}
+
+// src/core/usage-boost.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { parse as parseYaml2 } from "yaml";
+var DEFAULT_USAGE_BOOST_CONFIG = {
+  enabled: true,
+  cap: 1.5,
+  per_citation: 0.1
+};
+function loadUsageBoostConfig(vaultPath) {
+  try {
+    const schemaPath = join2(vaultPath, "vault.schema.yml");
+    if (!existsSync2(schemaPath)) return { ...DEFAULT_USAGE_BOOST_CONFIG };
+    const parsed = parseYaml2(readFileSync2(schemaPath, "utf-8"));
+    const u = parsed?.usage_boost;
+    if (!u || typeof u !== "object") return { ...DEFAULT_USAGE_BOOST_CONFIG };
+    return {
+      enabled: typeof u.enabled === "boolean" ? u.enabled : DEFAULT_USAGE_BOOST_CONFIG.enabled,
+      cap: typeof u.cap === "number" && u.cap >= 1 ? u.cap : DEFAULT_USAGE_BOOST_CONFIG.cap,
+      per_citation: typeof u.per_citation === "number" && u.per_citation >= 0 ? u.per_citation : DEFAULT_USAGE_BOOST_CONFIG.per_citation
+    };
+  } catch {
+    return { ...DEFAULT_USAGE_BOOST_CONFIG };
+  }
+}
+function computeUsageBoost(citations, config) {
+  if (!config.enabled || citations <= 0) return 1;
+  return Math.min(config.cap, 1 + citations * config.per_citation);
+}
+async function loadCitationCounts(vaultPath) {
+  const events = await readSelectionLog(vaultPath);
+  const counts = {};
+  for (const e of events) {
+    if (e.kind === "selection") counts[e.note_path] = (counts[e.note_path] ?? 0) + 1;
+  }
+  return counts;
+}
+
+// src/mcp/context.ts
 async function buildContext(notesPath, options = {}) {
-  const indexPath = join(notesPath, ".semantic-sidekick-index");
+  const indexPath = join3(notesPath, ".semantic-sidekick-index");
   await mkdir(indexPath, { recursive: true });
   const indexer = new Indexer(notesPath);
   const embedder = new Embedder(options.model, options.workers, options.batchSize, options.quantized);
@@ -66,9 +175,9 @@ async function buildContext(notesPath, options = {}) {
     try {
       indexState = "loading";
       await embedder.init();
-      const metaPath = join(indexPath, "meta.json");
+      const metaPath = join3(indexPath, "meta.json");
       let meta = null;
-      if (existsSync(metaPath)) {
+      if (existsSync3(metaPath)) {
         try {
           meta = JSON.parse(await readFile(metaPath, "utf-8"));
           if (meta?.model && meta.model !== embedder.getModel()) {
@@ -168,7 +277,7 @@ async function buildContext(notesPath, options = {}) {
       newVector.save(indexPath),
       embedder.saveEmbeddings(cumulativeEmbeddings, indexPath),
       indexer.saveDocsCache(indexPath, newDocs),
-      writeFile(join(indexPath, "meta.json"), JSON.stringify({
+      writeFile(join3(indexPath, "meta.json"), JSON.stringify({
         model: embedder.getModel(),
         dimensions: embedder.getDimensions(),
         totalChunks: allChunks.length,
@@ -212,6 +321,72 @@ async function buildContext(notesPath, options = {}) {
     if (doc?.loadPriority === void 0) return score;
     return score * (1 + (doc.loadPriority - 5) * 0.04);
   }
+  let decayConfig = null;
+  function getDecayConfig() {
+    if (!decayConfig) decayConfig = loadDecayConfig(notesPath);
+    return decayConfig;
+  }
+  function applyDecay(r) {
+    const cfg = getDecayConfig();
+    if (!cfg.enabled) return r;
+    const doc = docByPath.get(r.path);
+    if (!doc) return r;
+    const fm = doc.frontmatter ?? {};
+    const d = computeDecay({
+      type: typeof fm.type === "string" ? fm.type : void 0,
+      last_verified: normalizeVerifiedDate(fm.last_verified),
+      evergreen: fm.evergreen === true,
+      config: cfg
+    });
+    const scored = { ...r, score: r.score * d.multiplier };
+    if (d.multiplier < 1) {
+      return {
+        ...scored,
+        decay: {
+          multiplier: Math.round(d.multiplier * 1e3) / 1e3,
+          age_days: Math.round(d.age_days),
+          effective_half_life: d.effective_half_life,
+          reason: d.reason
+        }
+      };
+    }
+    return scored;
+  }
+  let pathClassConfig = null;
+  function getPathClassConfig() {
+    if (!pathClassConfig) pathClassConfig = loadPathClassConfig(notesPath);
+    return pathClassConfig;
+  }
+  function applyPathClass(r) {
+    const m = pathClassMultiplier(r.path, getPathClassConfig());
+    return m === 1 ? r : { ...r, score: r.score * m };
+  }
+  let usageBoostConfig = null;
+  function getUsageBoostConfig() {
+    if (!usageBoostConfig) usageBoostConfig = loadUsageBoostConfig(notesPath);
+    return usageBoostConfig;
+  }
+  let citationCounts = {};
+  let citationLoadedAtMs = 0;
+  const CITATION_TTL_MS = 15e3;
+  async function refreshUsageBoost() {
+    if (!getUsageBoostConfig().enabled) return;
+    const now = Date.now();
+    if (now - citationLoadedAtMs < CITATION_TTL_MS && citationLoadedAtMs > 0) return;
+    try {
+      citationCounts = await loadCitationCounts(notesPath);
+      citationLoadedAtMs = now;
+    } catch {
+    }
+  }
+  function applyUsageBoost(r) {
+    const cfg = getUsageBoostConfig();
+    if (!cfg.enabled) return r;
+    const citations = citationCounts[r.path] ?? 0;
+    const m = computeUsageBoost(citations, cfg);
+    if (m === 1) return r;
+    return { ...r, score: r.score * m, usage: { citations, multiplier: Math.round(m * 1e3) / 1e3 } };
+  }
   function applyDateFilter(results, modifiedAfter, modifiedBefore) {
     if (!modifiedAfter && !modifiedBefore) return results;
     const after = modifiedAfter ? new Date(modifiedAfter).getTime() : -Infinity;
@@ -248,6 +423,10 @@ async function buildContext(notesPath, options = {}) {
     indexingMessage,
     enrichResult,
     applyPriorityBoost,
+    applyDecay,
+    applyPathClass,
+    applyUsageBoost,
+    refreshUsageBoost,
     applyDateFilter
   };
 }
@@ -4294,10 +4473,19 @@ var coerce = {
 var NEVER = INVALID;
 
 // src/mcp/tools/search.ts
+async function logSearch(ctx, tool, query, enriched) {
+  const results = enriched.map((r) => ({
+    path: r.path,
+    score: r.score,
+    ...r.decay ? { decay: r.decay.multiplier } : {}
+  }));
+  recordSearchForCorrelation(ctx.notesPath, results.map((r) => r.path));
+  await appendEvent(ctx.notesPath, { kind: "search", tool, query, results });
+}
 function registerSearchTools(server, ctx) {
   server.tool(
     "search_semantic",
-    "Vector similarity search \u2014 find notes similar to a query by meaning. Scores are boosted by load_priority when present.",
+    "Vector similarity search \u2014 find notes similar to a query by meaning. Scores are boosted by load_priority and down-weighted by confidence decay (time since last_verified); decayed results carry a `decay` block. Set decay.enabled:false in vault.schema.yml to disable.",
     {
       query: external_exports.string(),
       limit: external_exports.coerce.number().optional().default(10),
@@ -4315,8 +4503,9 @@ function registerSearchTools(server, ctx) {
         );
       }
       const queryEmbed = await ctx.embedder.embed(query);
+      await ctx.refreshUsageBoost();
       let results = vectorIndex.search(queryEmbed, limit * 3);
-      results = results.map((r) => ({ ...r, score: ctx.applyPriorityBoost(r.score, r.path) }));
+      results = results.map((r) => ctx.applyUsageBoost(ctx.applyPathClass(ctx.applyDecay({ ...r, score: ctx.applyPriorityBoost(r.score, r.path) }))));
       results.sort((a, b) => b.score - a.score);
       results = ctx.applyDateFilter(results, modifiedAfter, modifiedBefore);
       const docByPath = ctx.getDocByPath();
@@ -4324,6 +4513,7 @@ function registerSearchTools(server, ctx) {
       if (tier) results = results.filter((r) => docByPath.get(r.path)?.tier === tier);
       if (domain) results = results.filter((r) => docByPath.get(r.path)?.domains?.includes(domain));
       const enriched = results.slice(0, limit).map((r) => ctx.enrichResult(r));
+      await logSearch(ctx, "search_semantic", query, enriched);
       return ctx.textResponse(JSON.stringify(enriched, null, 2));
     }
   );
@@ -4373,7 +4563,7 @@ function registerSearchTools(server, ctx) {
   );
   server.tool(
     "search_hybrid",
-    "Combined semantic + graph search \u2014 vector results re-ranked by graph proximity and load_priority",
+    "Combined semantic + graph search \u2014 vector results re-ranked by graph proximity and load_priority, and down-weighted by confidence decay (time since last_verified); decayed results carry a `decay` block.",
     {
       query: external_exports.string(),
       limit: external_exports.coerce.number().optional().default(10),
@@ -4391,16 +4581,20 @@ function registerSearchTools(server, ctx) {
         );
       }
       const queryEmbed = await ctx.embedder.embed(query);
+      await ctx.refreshUsageBoost();
       const semanticResults = vectorIndex.search(queryEmbed, limit * 3);
       const graphResults = ctx.graph.searchGraph(query, 2);
       const graphPaths = new Set(graphResults.map((r) => r.path));
-      let hybrid = semanticResults.map((r) => ({
-        ...r,
-        score: ctx.applyPriorityBoost(
-          graphPaths.has(r.path) ? r.score * 1.3 : r.score,
-          r.path
+      let hybrid = semanticResults.map(
+        (r) => ctx.applyUsageBoost(
+          ctx.applyPathClass(
+            ctx.applyDecay({
+              ...r,
+              score: ctx.applyPriorityBoost(graphPaths.has(r.path) ? r.score * 1.3 : r.score, r.path)
+            })
+          )
         )
-      }));
+      );
       hybrid.sort((a, b) => b.score - a.score);
       hybrid = ctx.applyDateFilter(hybrid, modifiedAfter, modifiedBefore);
       const docByPath = ctx.getDocByPath();
@@ -4408,6 +4602,7 @@ function registerSearchTools(server, ctx) {
       if (tier) hybrid = hybrid.filter((r) => docByPath.get(r.path)?.tier === tier);
       if (domain) hybrid = hybrid.filter((r) => docByPath.get(r.path)?.domains?.includes(domain));
       const enriched = hybrid.slice(0, limit).map((r) => ctx.enrichResult(r));
+      await logSearch(ctx, "search_hybrid", query, enriched);
       return ctx.textResponse(JSON.stringify(enriched, null, 2));
     }
   );
@@ -4417,10 +4612,20 @@ function registerSearchTools(server, ctx) {
 function registerReadTools(server, ctx) {
   server.tool(
     "read_note",
-    "Read the full content of a specific note by path",
-    { path: external_exports.string() },
-    async ({ path }) => {
+    "Read a note by path. Pass `section` (a heading name) to read only that heading's section instead of the whole file \u2014 cheaper when you only need one part (e.g. a dossier's 'Knobs' section).",
+    { path: external_exports.string(), section: external_exports.string().optional().describe("Heading name \u2014 return only that section (heading through the next same-or-higher heading).") },
+    async ({ path, section }) => {
       const content = await ctx.crud.read(path);
+      await appendEvent(ctx.notesPath, {
+        kind: "selection",
+        note_path: path,
+        via: "read_note",
+        correlated: wasRecentlySearched(ctx.notesPath, path)
+      });
+      if (section) {
+        const extracted = extractSection(content, section);
+        return ctx.textResponse(extracted ?? `Section "${section}" not found in ${path}. Read without \`section\` for the full note.`);
+      }
       return ctx.textResponse(content);
     }
   );
@@ -4528,7 +4733,7 @@ function registerWriteTools(server, ctx) {
 
 // src/mcp/tools/patch.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 import matter from "gray-matter";
 function registerPatchTools(server, ctx) {
   if (ctx.options.readOnly) return;
@@ -4601,6 +4806,7 @@ function registerPatchTools(server, ctx) {
       decision_maker: external_exports.string().optional(),
       decided_on: external_exports.string().optional(),
       severity: external_exports.string().optional(),
+      symptoms: external_exports.array(external_exports.string()).optional().describe("Verbatim symptom phrases in the user's own words (e.g. 'it hangs after the second reindex'). Stored as `symptoms:` frontmatter and symptom-keyed at index time so terse symptom queries match this note \u2014 the retrieval key for next time."),
       dry_run: external_exports.boolean().optional().default(false),
       proposal: external_exports.boolean().optional().default(false).describe("Write to proposals/<date>-<slug>.md with status:proposal instead of the canonical destination. Use for review-first workflows."),
       proposal_subdir: external_exports.string().optional().describe("Override the proposal subdirectory (default 'proposals'). Useful for source segregation, e.g. 'proposals/research'."),
@@ -4644,6 +4850,7 @@ ${verifLines.join("\n")}
         decision_maker: args.decision_maker,
         decided_on: args.decided_on,
         severity: args.severity,
+        symptoms: args.symptoms,
         proposal: args.proposal,
         proposal_subdir: args.proposal_subdir
       });
@@ -4698,7 +4905,7 @@ ${verifLines.join("\n")}
       dry_run: external_exports.boolean().optional().default(false)
     },
     async (args) => {
-      const absoluteProposalPath = join2(ctx.notesPath, args.proposal_path);
+      const absoluteProposalPath = join4(ctx.notesPath, args.proposal_path);
       let raw;
       try {
         raw = await readFile2(absoluteProposalPath, "utf-8");
@@ -4825,6 +5032,160 @@ ${verifLines.join("\n")}
       );
     }
   );
+  server.tool(
+    "verify_note",
+    "Re-verify a note: stamp `last_verified` to today WITHOUT changing content or any other frontmatter field, and log a `verify` event. Resets the confidence-decay clock so the note ranks fresh again. Returns the note's new decay multiplier (typically 1.0).",
+    { path: external_exports.string() },
+    async ({ path }) => {
+      let fm;
+      try {
+        fm = await ctx.frontmatterManager.get(path);
+      } catch {
+        return ctx.textResponse(`verify_note: note not found: ${path}`);
+      }
+      const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      await ctx.frontmatterManager.update(path, { last_verified: today });
+      await logEvent(ctx.notesPath, {
+        kind: "verify",
+        summary: `verified ${path}`,
+        payload: { path, last_verified: today }
+      });
+      const d = computeDecay({
+        type: typeof fm.type === "string" ? fm.type : void 0,
+        last_verified: today,
+        evergreen: fm.evergreen === true,
+        config: loadDecayConfig(ctx.notesPath)
+      });
+      return ctx.textResponse(
+        JSON.stringify({ path, last_verified: today, decay_multiplier: d.multiplier }, null, 2)
+      );
+    }
+  );
+  server.tool(
+    "manage_lexicon",
+    "Manage the learned human\u2192artifact lexicon (v1.4). `action`: add (upsert a canonical target + the human phrases that refer to it; bumps evidence_count on repeats), lookup (expand a query via matching alias phrases), list (all aliases), remove (by canonical), compile (rebuild the derived cache). The lexicon maps how THIS human names things to concrete paths/symbols.",
+    {
+      action: external_exports.enum(["add", "lookup", "list", "remove", "compile"]),
+      canonical: external_exports.string().optional().describe("For add/remove: the concrete target (note path or code symbol)."),
+      phrases: external_exports.array(external_exports.string()).optional().describe("For add: the human's verbatim phrases for the canonical target."),
+      query: external_exports.string().optional().describe("For lookup: the utterance to expand via alias phrases."),
+      source: external_exports.enum(["learned", "authored"]).optional().describe("For add: provenance of the binding (default learned).")
+    },
+    async ({ action, canonical, phrases, query, source }) => {
+      switch (action) {
+        case "add": {
+          if (!canonical || !phrases || phrases.length === 0) return ctx.textResponse("manage_lexicon add requires `canonical` and non-empty `phrases`");
+          const r = await addAlias(ctx.notesPath, { canonical, phrases, source });
+          return ctx.textResponse(JSON.stringify(r, null, 2));
+        }
+        case "lookup": {
+          if (!query) return ctx.textResponse("manage_lexicon lookup requires `query`");
+          const aliases = await loadLexiconCache(ctx.notesPath);
+          const { expanded, matched } = expandQuery(aliases, query);
+          return ctx.textResponse(JSON.stringify({ query, expanded, matched }, null, 2));
+        }
+        case "list": {
+          return ctx.textResponse(JSON.stringify(await loadLexiconCache(ctx.notesPath), null, 2));
+        }
+        case "remove": {
+          if (!canonical) return ctx.textResponse("manage_lexicon remove requires `canonical`");
+          const removed = await removeAlias(ctx.notesPath, canonical);
+          return ctx.textResponse(removed ? `removed alias: ${canonical}` : `no alias for canonical: ${canonical}`);
+        }
+        case "compile": {
+          const entries = await compileLexicon(ctx.notesPath);
+          return ctx.textResponse(`compiled ${entries.length} alias(es) to lexicon-cache.json`);
+        }
+      }
+    }
+  );
+  server.tool(
+    "manage_dossier",
+    "Manage entity dossiers (v1.5) \u2014 the per-component living notes that organize memory by entity instead of by file. `action`: init (scaffold a dossier for an entity with the fixed Purpose/Failure modes/Knobs/Incident log/Current state sections), append_incident (append a dated line to the Incident log \u2014 accretion, never a new note), set_state (replace the Current state one-liner), get (read a dossier by entity/alias/path), list (all dossiers with their current state). Knowledge about a critical component accretes IN PLACE here.",
+    {
+      action: external_exports.enum(["init", "append_incident", "set_state", "get", "list"]),
+      entity: external_exports.string().optional().describe("For init/append_incident/set_state/get: the entity name, one of its aliases, or a dossier path."),
+      aliases: external_exports.array(external_exports.string()).optional().describe("For init: the human's phrases for this entity (fed to the lexicon compiler for query expansion)."),
+      purpose: external_exports.string().optional().describe("For init: seed the Purpose section instead of the placeholder."),
+      seeded_from: external_exports.string().optional().describe("For init: provenance of the scaffold (e.g. a babel-fish project-map entry)."),
+      incident: external_exports.string().optional().describe("For append_incident: what happened \u2192 cause \u2192 fix, in one line. Dated automatically."),
+      state: external_exports.string().optional().describe("For set_state: the single freshest sentence about where the entity stands.")
+    },
+    async ({ action, entity, aliases, purpose, seeded_from, incident, state }) => {
+      switch (action) {
+        case "init": {
+          if (!entity) return ctx.textResponse("manage_dossier init requires `entity`");
+          const r = await initDossier(ctx.notesPath, entity, { aliases, purpose, seeded_from });
+          if (r.created) await ctx.sessions.recordNotesTouched([r.path]).catch(() => {
+          });
+          return ctx.textResponse(JSON.stringify(r, null, 2));
+        }
+        case "append_incident": {
+          if (!entity || !incident) return ctx.textResponse("manage_dossier append_incident requires `entity` and `incident`");
+          const r = await appendIncident(ctx.notesPath, entity, incident);
+          if (!r) return ctx.textResponse(`no dossier for entity: ${entity} (run action:init first)`);
+          await ctx.sessions.recordNotesTouched([r.path]).catch(() => {
+          });
+          await logEvent(ctx.notesPath, { kind: "synthesis", summary: `dossier incident: ${entity}`, payload: { path: r.path, incident } }).catch(() => {
+          });
+          return ctx.textResponse(JSON.stringify(r, null, 2));
+        }
+        case "set_state": {
+          if (!entity || !state) return ctx.textResponse("manage_dossier set_state requires `entity` and `state`");
+          const r = await setCurrentState(ctx.notesPath, entity, state);
+          if (!r) return ctx.textResponse(`no dossier for entity: ${entity} (run action:init first)`);
+          await ctx.sessions.recordNotesTouched([r.path]).catch(() => {
+          });
+          return ctx.textResponse(JSON.stringify(r, null, 2));
+        }
+        case "get": {
+          if (!entity) return ctx.textResponse("manage_dossier get requires `entity`");
+          const rel = await resolveDossierPath(ctx.notesPath, entity);
+          if (!rel) return ctx.textResponse(`no dossier for entity: ${entity}`);
+          const content = await readFile2(join4(ctx.notesPath, rel), "utf-8");
+          return ctx.textResponse(JSON.stringify({ path: rel, content }, null, 2));
+        }
+        case "list": {
+          await compileDossiers(ctx.notesPath);
+          const entries = await listDossiers(ctx.notesPath);
+          return ctx.textResponse(JSON.stringify(entries, null, 2));
+        }
+      }
+    }
+  );
+  server.tool(
+    "manage_profile",
+    'Manage the speaker profile (v1.5) \u2014 the model of how THIS human communicates (severity calibration, chronic omissions, verbosity preference, non-entity shorthand). `action`: init (scaffold profile/speaker.md with the fixed sections), get (read it), update_section (append a learned line to \u2014 or replace \u2014 one section; scaffolds first if absent). Update it when the user corrects an interpretation ("no, when I say X I mean Y"). One human, one profile.',
+    {
+      action: external_exports.enum(["init", "get", "update_section"]),
+      section: external_exports.string().optional().describe("For update_section: the section heading (e.g. 'Severity calibration', 'Shorthand & terms')."),
+      text: external_exports.string().optional().describe("For update_section: the learned line or replacement body."),
+      mode: external_exports.enum(["append", "replace"]).optional().describe("For update_section: append a line (default) or replace the section body.")
+    },
+    async ({ action, section, text, mode }) => {
+      switch (action) {
+        case "init": {
+          const r = await initSpeakerProfile(ctx.notesPath);
+          if (r.created) await ctx.sessions.recordNotesTouched([r.path]).catch(() => {
+          });
+          return ctx.textResponse(JSON.stringify(r, null, 2));
+        }
+        case "get": {
+          const p = await readSpeakerProfile(ctx.notesPath);
+          if (!p) return ctx.textResponse(`no speaker profile yet (run action:init or manage_profile update_section)`);
+          const content = await readFile2(join4(ctx.notesPath, SPEAKER_PROFILE_PATH), "utf-8");
+          return ctx.textResponse(JSON.stringify({ path: p.path, head: p.head, content }, null, 2));
+        }
+        case "update_section": {
+          if (!section || !text) return ctx.textResponse("manage_profile update_section requires `section` and `text`");
+          const r = await updateProfileSection(ctx.notesPath, section, text, mode ?? "append");
+          await ctx.sessions.recordNotesTouched([r.path]).catch(() => {
+          });
+          return ctx.textResponse(JSON.stringify(r, null, 2));
+        }
+      }
+    }
+  );
 }
 
 // src/mcp/tools/lint.ts
@@ -4833,7 +5194,11 @@ var RULE_KEY_FOR_CHECK = {
   schema: "schema_violations",
   provenance: "missing_provenance",
   stale: "stale",
-  broken_links: "broken_links"
+  broken_links: "broken_links",
+  code_symbols: "code_symbols",
+  decay_candidates: "decay_candidates",
+  alias_conflicts: "alias_conflicts",
+  decoys: "decoys"
 };
 function registerLintTools(server, ctx) {
   server.tool(
@@ -4874,13 +5239,19 @@ function registerLintTools(server, ctx) {
   );
   server.tool(
     "lint_vault",
-    "Run lint rules across the vault. Default returns the full LintReport with all findings grouped by rule. Pass `checks` to filter to specific rules (schema, provenance, stale, broken_links) \u2014 when filtered, byRule contains only the requested rules.",
+    "Run lint rules across the vault. Default returns the full LintReport with all findings grouped by rule. Pass `checks` to filter to specific rules (schema, provenance, stale, broken_links, code_symbols, decay_candidates) \u2014 when filtered, byRule contains only the requested rules. Two checks are opt-in only (never in the default report): `code_symbols` flags inline-code file-path references that no longer exist under the project root (no-op outside a code repo); `decay_candidates` cross-references the selection log against current decay to surface frequently-retrieved-but-decayed notes (no-op with no selection log). `decoys` flags notes retrieved 3+ times but never cited - surfaced for review, never auto-down-ranked (v1.5 Q5).",
     {
       pathGlob: external_exports.string().optional(),
-      checks: external_exports.array(external_exports.enum(["schema", "provenance", "stale", "broken_links"])).optional().describe("Filter to specific lint rules. Omit for full report.")
+      checks: external_exports.array(external_exports.enum(["schema", "provenance", "stale", "broken_links", "code_symbols", "decay_candidates", "alias_conflicts", "decoys"])).optional().describe("Filter to specific lint rules. Omit for full report (excludes the opt-in code_symbols / decay_candidates / alias_conflicts / decoys).")
     },
     async ({ pathGlob, checks }) => {
-      const report = await lintVault(ctx.notesPath, { pathGlob });
+      const report = await lintVault(ctx.notesPath, {
+        pathGlob,
+        checkCodeSymbols: !!checks?.includes("code_symbols"),
+        checkDecayCandidates: !!checks?.includes("decay_candidates"),
+        checkAliasConflicts: !!checks?.includes("alias_conflicts"),
+        checkDecoys: !!checks?.includes("decoys")
+      });
       if (!checks || checks.length === 0) {
         return ctx.textResponse(JSON.stringify(report, null, 2));
       }
@@ -5138,6 +5509,10 @@ var CURRENT_TOOL_INVENTORY = [
   { name: "synthesize_promote", description: "Move a reviewed proposal note to its canonical destination, stripping proposal markers.", group: "patch" },
   { name: "ingest_source", description: "Build + apply a ChangeSet that ingests a source and the notes extracted from it.", group: "patch" },
   { name: "install_schema", description: "Bootstrap vault.schema.yml in the vault root with the default schema.", group: "patch" },
+  { name: "verify_note", description: "Stamp last_verified to today (content unchanged) to reset the confidence-decay clock; logs a verify event.", group: "patch" },
+  { name: "manage_lexicon", description: "Manage the learned human\u2192artifact lexicon (add/lookup/list/remove/compile aliases).", group: "patch" },
+  { name: "manage_dossier", description: "Manage entity dossiers \u2014 per-component living notes (init/append_incident/set_state/get/list). Knowledge accretes in place.", group: "patch" },
+  { name: "manage_profile", description: "Manage the speaker profile \u2014 how this human communicates (init/get/update_section).", group: "patch" },
   // lint
   { name: "find_schema_violations", description: "Scan for schema violations.", group: "lint", deprecated: true },
   { name: "find_missing_provenance", description: "Scan for notes lacking sources/derived_from.", group: "lint", deprecated: true },
@@ -5172,6 +5547,29 @@ var CURRENT_TOOL_INVENTORY = [
 ];
 
 // src/mcp/tools/contract.ts
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+function pluginVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+      const pkgPath = join5(dir, "package.json");
+      if (existsSync4(pkgPath)) {
+        const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+        if (pkg?.name === "@theglitchking/semantic-memory" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
 function registerContractTools(server, ctx) {
   if (ctx.options.readOnly) return;
   server.tool(
@@ -5195,7 +5593,7 @@ function registerContractTools(server, ctx) {
       ];
       const result = await regenerateAgentsContract({
         projectRoot: root,
-        pluginVersion: "1.1.0",
+        pluginVersion: pluginVersion(),
         tools,
         modes,
         force
@@ -5310,6 +5708,43 @@ function registerSessionTools(server, ctx) {
   );
 }
 
+// src/core/tools-config.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
+import { parse as parseYaml3 } from "yaml";
+function loadToolsConfig(vaultPath) {
+  try {
+    const schemaPath = join6(vaultPath, "vault.schema.yml");
+    if (!existsSync5(schemaPath)) return { conditional: false };
+    const parsed = parseYaml3(readFileSync4(schemaPath, "utf-8"));
+    return { conditional: parsed?.tools?.conditional === true };
+  } catch {
+    return { conditional: false };
+  }
+}
+function readActiveMode(vaultPath) {
+  const root = deriveProjectRoot(vaultPath);
+  const candidates = [
+    join6(root, ".claude", ".semantic-memory", "mode"),
+    join6(root, ".claude", ".sidekick-mode")
+  ];
+  for (const p of candidates) {
+    try {
+      if (existsSync5(p)) {
+        const v = readFileSync4(p, "utf-8").trim();
+        if (v) return v;
+      }
+    } catch {
+    }
+  }
+  return "vault-first";
+}
+function useMinimalToolSurface(vaultPath) {
+  const cfg = loadToolsConfig(vaultPath);
+  if (!cfg.conditional) return false;
+  return readActiveMode(vaultPath) === "outage-silence";
+}
+
 // src/mcp/server.ts
 async function createServer(notesPath, options = {}) {
   const ctx = await buildContext(notesPath, options);
@@ -5317,17 +5752,20 @@ async function createServer(notesPath, options = {}) {
     name: "semantic-memory",
     version: "1.0.0"
   });
+  const minimal = useMinimalToolSurface(notesPath);
   registerSearchTools(server, ctx);
   registerReadTools(server, ctx);
-  registerWriteTools(server, ctx);
-  registerPatchTools(server, ctx);
-  registerLintTools(server, ctx);
-  registerLogTools(server, ctx);
-  registerMetadataTools(server, ctx);
-  registerGraphTools(server, ctx);
   registerSystemTools(server, ctx);
-  registerContractTools(server, ctx);
-  registerSessionTools(server, ctx);
+  if (!minimal) {
+    registerWriteTools(server, ctx);
+    registerPatchTools(server, ctx);
+    registerLintTools(server, ctx);
+    registerLogTools(server, ctx);
+    registerMetadataTools(server, ctx);
+    registerGraphTools(server, ctx);
+    registerContractTools(server, ctx);
+    registerSessionTools(server, ctx);
+  }
   if (options.waitForReady) {
     await ctx.tryLoadCachedIndex();
     await ctx.fullIndex();