@theglitchking/semantic-memory 1.2.2 → 1.5.1

package/dist/chunk-7M3JZOYH.js

@@ -0,0 +1,105 @@
+import {
+  appendToSection,
+  replaceSectionBody
+} from "./chunk-WSU4QIPB.js";
+
+// src/core/profile.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import matter from "gray-matter";
+var SPEAKER_PROFILE_PATH = "profile/speaker.md";
+var PROFILE_SECTIONS = [
+  "Severity calibration",
+  "Chronic omissions",
+  "Verbosity preference",
+  "Shorthand & terms"
+];
+function speakerProfileTemplate() {
+  return `# Speaker profile
+
+_How this human communicates \u2014 learned over time, corrected in place. One human, one profile._
+
+## Severity calibration
+
+_What their words map to. e.g. "annoying" = low, "broken" = ship-blocking, "on fire" = drop everything._
+
+## Chronic omissions
+
+_What they habitually leave unsaid \u2014 env, repro steps, which service \u2014 so you ask up front._
+
+## Verbosity preference
+
+_How much detail they want back: terse answer first, or full reasoning? Code or prose?_
+
+## Shorthand & terms
+
+_Non-entity shorthand: "the usual", "ship it", "the thing from yesterday" \u2014 and what each has meant._
+`;
+}
+function isPlaceholderLine(line) {
+  const t = line.trim();
+  return t === "" || /^_.*_$/.test(t);
+}
+async function readSpeakerProfile(vaultPath, maxLines = 30) {
+  const abs = join(vaultPath, SPEAKER_PROFILE_PATH);
+  if (!existsSync(abs)) return null;
+  try {
+    const raw = await readFile(abs, "utf-8");
+    const { content } = matter(raw);
+    const body = content.trim();
+    const kept = [];
+    let lastWasHeading = false;
+    for (const line of body.split("\n")) {
+      const isHeading = /^#{1,6}\s/.test(line);
+      if (isHeading) {
+        kept.push(line.replace(/^#+\s*/, "").trim());
+        lastWasHeading = true;
+        continue;
+      }
+      if (isPlaceholderLine(line)) continue;
+      kept.push(line.trim());
+      lastWasHeading = false;
+    }
+    void lastWasHeading;
+    const head = kept.slice(0, maxLines).join("\n").trim();
+    return { path: SPEAKER_PROFILE_PATH, body, head };
+  } catch {
+    return null;
+  }
+}
+async function initSpeakerProfile(vaultPath, today) {
+  const abs = join(vaultPath, SPEAKER_PROFILE_PATH);
+  if (existsSync(abs)) return { path: SPEAKER_PROFILE_PATH, created: false };
+  const date = today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const fm = {
+    title: "Speaker profile",
+    type: "profile",
+    status: "active",
+    last_verified: date,
+    confidence: "medium",
+    evergreen: true
+  };
+  await mkdir(dirname(abs), { recursive: true });
+  await writeFile(abs, matter.stringify(speakerProfileTemplate(), fm), "utf-8");
+  return { path: SPEAKER_PROFILE_PATH, created: true };
+}
+async function updateProfileSection(vaultPath, section, text, mode = "append") {
+  await initSpeakerProfile(vaultPath);
+  const abs = join(vaultPath, SPEAKER_PROFILE_PATH);
+  const raw = await readFile(abs, "utf-8");
+  const parsed = matter(raw);
+  const patchedBody = mode === "replace" ? replaceSectionBody(parsed.content, section, text.trim()) : appendToSection(parsed.content, section, `- ${text.trim()}`);
+  await writeFile(abs, matter.stringify(patchedBody, parsed.data), "utf-8");
+  return { path: SPEAKER_PROFILE_PATH };
+}
+
+export {
+  SPEAKER_PROFILE_PATH,
+  PROFILE_SECTIONS,
+  speakerProfileTemplate,
+  readSpeakerProfile,
+  initSpeakerProfile,
+  updateProfileSection
+};
+//# sourceMappingURL=chunk-7M3JZOYH.js.map

package/dist/chunk-7M3JZOYH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/profile.ts"],"sourcesContent":["import { readFile, writeFile, mkdir } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport matter from \"gray-matter\";\nimport { replaceSectionBody, appendToSection } from \"./dossier.js\";\n\n/**\n * Speaker profile (v1.5 Phase 11) — the model of THIS human.\n *\n * The difference between an expert who knows the system and one who knows the\n * system *and knows you*: how this person calibrates severity (\"annoying\" vs\n * \"broken\" vs \"on fire\"), what they chronically leave unsaid, how much detail they\n * want back, and the shorthand they use that isn't an entity. One note, one human\n * (multi-speaker is an explicit non-goal). Injected at SessionStart alongside the\n * session digest; updated via capture cues when the user corrects an interpretation.\n */\n\nexport const SPEAKER_PROFILE_PATH = \"profile/speaker.md\";\n\n/** The fixed sections a speaker profile carries. */\nexport const PROFILE_SECTIONS = [\n  \"Severity calibration\",\n  \"Chronic omissions\",\n  \"Verbosity preference\",\n  \"Shorthand & terms\",\n] as const;\n\nexport type ProfileSection = (typeof PROFILE_SECTIONS)[number];\n\nexport interface SpeakerProfile {\n  path: string;\n  /** The whole note body (frontmatter stripped), trimmed. */\n  body: string;\n  /** A capped, injection-ready rendering (headings + non-placeholder lines). */\n  head: string;\n}\n\nexport function speakerProfileTemplate(): string {\n  return `# Speaker profile\n\n_How this human communicates — learned over time, corrected in place. One human, one profile._\n\n## Severity calibration\n\n_What their words map to. e.g. \"annoying\" = low, \"broken\" = ship-blocking, \"on fire\" = drop everything._\n\n## Chronic omissions\n\n_What they habitually leave unsaid — env, repro steps, which service — so you ask up front._\n\n## Verbosity preference\n\n_How much detail they want back: terse answer first, or full reasoning? Code or prose?_\n\n## Shorthand & terms\n\n_Non-entity shorthand: \"the usual\", \"ship it\", \"the thing from yesterday\" — and what each has meant._\n`;\n}\n\n/** True when a line is only a template placeholder (italic prompt) or blank. */\nfunction isPlaceholderLine(line: string): boolean {\n  const t = line.trim();\n  return t === \"\" || /^_.*_$/.test(t);\n}\n\n/**\n * Read the speaker profile, returning a capped injection head that drops the\n * template placeholders (so an unfilled profile injects nothing but its headings,\n * and a filled one injects only the real content). Returns null when absent.\n */\nexport async function readSpeakerProfile(vaultPath: string, maxLines = 30): Promise<SpeakerProfile | null> {\n  const abs = join(vaultPath, SPEAKER_PROFILE_PATH);\n  if (!existsSync(abs)) return null;\n  try {\n    const raw = await readFile(abs, \"utf-8\");\n    const { content } = matter(raw);\n    const body = content.trim();\n    // Build the head: keep headings and real (non-placeholder) content lines.\n    const kept: string[] = [];\n    let lastWasHeading = false;\n    for (const line of body.split(\"\\n\")) {\n      const isHeading = /^#{1,6}\\s/.test(line);\n      if (isHeading) {\n        // Drop a heading immediately followed by nothing real (avoid trailing empty sections at render).\n        kept.push(line.replace(/^#+\\s*/, \"\").trim());\n        lastWasHeading = true;\n        continue;\n      }\n      if (isPlaceholderLine(line)) continue;\n      kept.push(line.trim());\n      lastWasHeading = false;\n    }\n    void lastWasHeading;\n    const head = kept.slice(0, maxLines).join(\"\\n\").trim();\n    return { path: SPEAKER_PROFILE_PATH, body, head };\n  } catch {\n    return null;\n  }\n}\n\nexport interface InitProfileResult {\n  path: string;\n  created: boolean;\n}\n\n/** Scaffold the speaker profile note. No-op (created:false) if it already exists. */\nexport async function initSpeakerProfile(vaultPath: string, today?: string): Promise<InitProfileResult> {\n  const abs = join(vaultPath, SPEAKER_PROFILE_PATH);\n  if (existsSync(abs)) return { path: SPEAKER_PROFILE_PATH, created: false };\n  const date = today ?? new Date().toISOString().slice(0, 10);\n  const fm = {\n    title: \"Speaker profile\",\n    type: \"profile\",\n    status: \"active\",\n    last_verified: date,\n    confidence: \"medium\",\n    evergreen: true,\n  };\n  await mkdir(dirname(abs), { recursive: true });\n  await writeFile(abs, matter.stringify(speakerProfileTemplate(), fm), \"utf-8\");\n  return { path: SPEAKER_PROFILE_PATH, created: true };\n}\n\n/**\n * Update one section of the speaker profile. `mode: \"replace\"` swaps the section\n * body; `mode: \"append\"` adds a line (accretion). Scaffolds the note first if\n * absent. Returns the resolved path.\n */\nexport async function updateProfileSection(\n  vaultPath: string,\n  section: string,\n  text: string,\n  mode: \"replace\" | \"append\" = \"append\"\n): Promise<{ path: string }> {\n  await initSpeakerProfile(vaultPath);\n  const abs = join(vaultPath, SPEAKER_PROFILE_PATH);\n  const raw = await readFile(abs, \"utf-8\");\n  const parsed = matter(raw);\n  const patchedBody = mode === \"replace\"\n    ? replaceSectionBody(parsed.content, section, text.trim())\n    : appendToSection(parsed.content, section, `- ${text.trim()}`);\n  await writeFile(abs, matter.stringify(patchedBody, parsed.data), \"utf-8\");\n  return { path: SPEAKER_PROFILE_PATH };\n}\n"],"mappings":";;;;;;AAAA,SAAS,UAAU,WAAW,aAAa;AAC3C,SAAS,kBAAkB;AAC3B,SAAS,MAAM,eAAe;AAC9B,OAAO,YAAY;AAcZ,IAAM,uBAAuB;AAG7B,IAAM,mBAAmB;AAAA,EAC9B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAYO,SAAS,yBAAiC;AAC/C,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBT;AAGA,SAAS,kBAAkB,MAAuB;AAChD,QAAM,IAAI,KAAK,KAAK;AACpB,SAAO,MAAM,MAAM,SAAS,KAAK,CAAC;AACpC;AAOA,eAAsB,mBAAmB,WAAmB,WAAW,IAAoC;AACzG,QAAM,MAAM,KAAK,WAAW,oBAAoB;AAChD,MAAI,CAAC,WAAW,GAAG,EAAG,QAAO;AAC7B,MAAI;AACF,UAAM,MAAM,MAAM,SAAS,KAAK,OAAO;AACvC,UAAM,EAAE,QAAQ,IAAI,OAAO,GAAG;AAC9B,UAAM,OAAO,QAAQ,KAAK;AAE1B,UAAM,OAAiB,CAAC;AACxB,QAAI,iBAAiB;AACrB,eAAW,QAAQ,KAAK,MAAM,IAAI,GAAG;AACnC,YAAM,YAAY,YAAY,KAAK,IAAI;AACvC,UAAI,WAAW;AAEb,aAAK,KAAK,KAAK,QAAQ,UAAU,EAAE,EAAE,KAAK,CAAC;AAC3C,yBAAiB;AACjB;AAAA,MACF;AACA,UAAI,kBAAkB,IAAI,EAAG;AAC7B,WAAK,KAAK,KAAK,KAAK,CAAC;AACrB,uBAAiB;AAAA,IACnB;AACA,SAAK;AACL,UAAM,OAAO,KAAK,MAAM,GAAG,QAAQ,EAAE,KAAK,IAAI,EAAE,KAAK;AACrD,WAAO,EAAE,MAAM,sBAAsB,MAAM,KAAK;AAAA,EAClD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQA,eAAsB,mBAAmB,WAAmB,OAA4C;AACtG,QAAM,MAAM,KAAK,WAAW,oBAAoB;AAChD,MAAI,WAAW,GAAG,EAAG,QAAO,EAAE,MAAM,sBAAsB,SAAS,MAAM;AACzE,QAAM,OAAO,UAAS,oBAAI,KAAK,GAAE,YAAY,EAAE,MAAM,GAAG,EAAE;AAC1D,QAAM,KAAK;AAAA,IACT,OAAO;AAAA,IACP,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,eAAe;AAAA,IACf,YAAY;AAAA,IACZ,WAAW;AAAA,EACb;AACA,QAAM,MAAM,QAAQ,GAAG,GAAG,EAAE,WAAW,KAAK,CAAC;AAC7C,QAAM,UAAU,KAAK,OAAO,UAAU,uBAAuB,GAAG,EAAE,GAAG,OAAO;AAC5E,SAAO,EAAE,MAAM,sBAAsB,SAAS,KAAK;AACrD;AAOA,eAAsB,qBACpB,WACA,SACA,MACA,OAA6B,UACF;AAC3B,QAAM,mBAAmB,SAAS;AAClC,QAAM,MAAM,KAAK,WAAW,oBAAoB;AAChD,QAAM,MAAM,MAAM,SAAS,KAAK,OAAO;AACvC,QAAM,SAAS,OAAO,GAAG;AACzB,QAAM,cAAc,SAAS,YACzB,mBAAmB,OAAO,SAAS,SAAS,KAAK,KAAK,CAAC,IACvD,gBAAgB,OAAO,SAAS,SAAS,KAAK,KAAK,KAAK,CAAC,EAAE;AAC/D,QAAM,UAAU,KAAK,OAAO,UAAU,aAAa,OAAO,IAAI,GAAG,OAAO;AACxE,SAAO,EAAE,MAAM,qBAAqB;AACtC;","names":[]}

package/dist/chunk-A3KYHKB5.js

@@ -0,0 +1,176 @@
+import {
+  listDossiers
+} from "./chunk-WSU4QIPB.js";
+import {
+  deriveSessionDir
+} from "./chunk-S4KW7VH4.js";
+
+// src/core/lexicon.ts
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { glob } from "glob";
+import matter from "gray-matter";
+var CACHE_FILE = "lexicon-cache.json";
+var LEXICON_DIR = "lexicon";
+function normalizePhrase(s) {
+  return s.toLowerCase().trim().replace(/\s+/g, " ");
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "alias";
+}
+function confidenceFor(evidenceCount) {
+  return evidenceCount >= 3 ? "high" : evidenceCount >= 2 ? "medium" : "low";
+}
+async function compileLexicon(vaultPath) {
+  const files = await glob(`${LEXICON_DIR}/**/*.md`, { cwd: vaultPath });
+  const entries = [];
+  for (const rel of files) {
+    try {
+      const { data } = matter(await readFile(join(vaultPath, rel), "utf-8"));
+      if (data.type !== "alias" || typeof data.canonical !== "string") continue;
+      const phrases = Array.isArray(data.phrases) ? data.phrases.map(String).map((p) => p.trim()).filter(Boolean) : [];
+      entries.push({
+        canonical: data.canonical,
+        phrases,
+        confidence: ["low", "medium", "high"].includes(data.confidence) ? data.confidence : confidenceFor(1),
+        evidence_count: typeof data.evidence_count === "number" ? data.evidence_count : phrases.length ? 1 : 0,
+        last_used: typeof data.last_used === "string" ? data.last_used : void 0,
+        source: data.source === "authored" ? "authored" : "learned",
+        path: rel
+      });
+    } catch {
+    }
+  }
+  try {
+    const dossiers = await listDossiers(vaultPath);
+    for (const d of dossiers) {
+      if (d.aliases.length === 0) continue;
+      if (entries.some((e) => e.canonical === d.path)) continue;
+      entries.push({
+        canonical: d.path,
+        phrases: d.aliases,
+        confidence: "high",
+        evidence_count: d.aliases.length,
+        source: "authored",
+        path: d.path
+      });
+    }
+  } catch {
+  }
+  try {
+    const dir = deriveSessionDir(vaultPath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, CACHE_FILE), JSON.stringify({ compiledAt: (/* @__PURE__ */ new Date()).toISOString(), aliases: entries }, null, 2), "utf-8");
+  } catch {
+  }
+  return entries;
+}
+async function loadLexiconCache(vaultPath) {
+  const cachePath = join(deriveSessionDir(vaultPath), CACHE_FILE);
+  if (existsSync(cachePath)) {
+    try {
+      const data = JSON.parse(await readFile(cachePath, "utf-8"));
+      if (Array.isArray(data?.aliases)) return data.aliases;
+    } catch {
+    }
+  }
+  return compileLexicon(vaultPath);
+}
+function lookupPhrase(aliases, phrase) {
+  const n = normalizePhrase(phrase);
+  return aliases.filter((a) => a.phrases.some((p) => normalizePhrase(p) === n));
+}
+function expandQuery(aliases, query) {
+  const nq = normalizePhrase(query);
+  const matched = aliases.filter((a) => a.phrases.some((p) => p && nq.includes(normalizePhrase(p))));
+  if (matched.length === 0) return { expanded: query, matched: [] };
+  const additions = [...new Set(matched.map((a) => a.canonical))].join(" ");
+  return { expanded: `${query} ${additions}`, matched };
+}
+async function writeAliasNote(vaultPath, rel, entry) {
+  const fm = {
+    type: "alias",
+    canonical: entry.canonical,
+    phrases: entry.phrases,
+    confidence: entry.confidence,
+    evidence_count: entry.evidence_count,
+    last_used: entry.last_used,
+    source: entry.source
+  };
+  const body = `# Alias: ${entry.canonical}
+
+Human phrases that refer to \`${entry.canonical}\`.
+`;
+  const abs = join(vaultPath, rel);
+  await mkdir(dirname(abs), { recursive: true });
+  await writeFile(abs, matter.stringify(body, fm), "utf-8");
+}
+async function addAlias(vaultPath, input) {
+  const existing = await compileLexicon(vaultPath);
+  const match = existing.find((a) => a.canonical === input.canonical);
+  const today = input.today ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const cleanPhrases = input.phrases.map((p) => p.trim()).filter(Boolean);
+  if (match) {
+    const phrases = [.../* @__PURE__ */ new Set([...match.phrases, ...cleanPhrases])];
+    const evidence_count2 = match.evidence_count + 1;
+    const confidence2 = confidenceFor(evidence_count2);
+    await writeAliasNote(vaultPath, match.path, { ...match, phrases, evidence_count: evidence_count2, confidence: confidence2, last_used: today });
+    await compileLexicon(vaultPath);
+    return { path: match.path, created: false, evidence_count: evidence_count2, confidence: confidence2 };
+  }
+  const rel = join(LEXICON_DIR, `${slugify(input.canonical)}.md`);
+  const evidence_count = 1;
+  const confidence = confidenceFor(evidence_count);
+  await writeAliasNote(vaultPath, rel, {
+    canonical: input.canonical,
+    phrases: cleanPhrases,
+    confidence,
+    evidence_count,
+    last_used: today,
+    source: input.source ?? "learned"
+  });
+  await compileLexicon(vaultPath);
+  return { path: rel, created: true, evidence_count, confidence };
+}
+function findAliasConflicts(aliases) {
+  const byPhrase = /* @__PURE__ */ new Map();
+  for (const a of aliases) {
+    for (const p of a.phrases) {
+      const n = normalizePhrase(p);
+      if (!n) continue;
+      if (!byPhrase.has(n)) byPhrase.set(n, /* @__PURE__ */ new Set());
+      byPhrase.get(n).add(a.canonical);
+    }
+  }
+  const conflicts = [];
+  for (const [phrase, canonicals] of byPhrase) {
+    if (canonicals.size > 1) conflicts.push({ phrase, canonicals: [...canonicals].sort() });
+  }
+  return conflicts.sort((a, b) => a.phrase.localeCompare(b.phrase));
+}
+async function removeAlias(vaultPath, canonical) {
+  const existing = await compileLexicon(vaultPath);
+  const match = existing.find((a) => a.canonical === canonical);
+  if (!match) return false;
+  try {
+    await unlink(join(vaultPath, match.path));
+  } catch {
+    return false;
+  }
+  await compileLexicon(vaultPath);
+  return true;
+}
+
+export {
+  normalizePhrase,
+  slugify,
+  compileLexicon,
+  loadLexiconCache,
+  lookupPhrase,
+  expandQuery,
+  addAlias,
+  findAliasConflicts,
+  removeAlias
+};
+//# sourceMappingURL=chunk-A3KYHKB5.js.map

package/dist/chunk-A3KYHKB5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/lexicon.ts"],"sourcesContent":["import { readFile, writeFile, mkdir, unlink } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport { join, dirname } from \"node:path\";\nimport { glob } from \"glob\";\nimport matter from \"gray-matter\";\nimport { deriveSessionDir } from \"./session.js\";\nimport { listDossiers } from \"./dossier.js\";\n\n/**\n * Lexicon corpus (v1.4 Phase 3) — the learned human→artifact vocabulary.\n *\n * The heart of the human→LLM bridge: maps the human's own phrasing (\"the flaky\n * thing\", \"the deploy dance\") to concrete artifacts (paths / code symbols).\n * Canonical storage is markdown notes of type `alias` under <vault>/lexicon/;\n * a derived JSON cache under .claude/.semantic-memory/ is what the hot-path hook\n * reads for deterministic query expansion.\n */\n\nexport type Confidence = \"low\" | \"medium\" | \"high\";\n\nexport interface AliasEntry {\n  /** The concrete target: a note path or a code symbol/path. */\n  canonical: string;\n  /** The human's actual words that refer to it (verbatim). */\n  phrases: string[];\n  confidence: Confidence;\n  evidence_count: number;\n  last_used?: string;\n  source: \"learned\" | \"authored\";\n  /** The lexicon note path this entry came from. */\n  path: string;\n}\n\nconst CACHE_FILE = \"lexicon-cache.json\";\nconst LEXICON_DIR = \"lexicon\";\n\nexport function normalizePhrase(s: string): string {\n  return s.toLowerCase().trim().replace(/\\s+/g, \" \");\n}\n\nexport function slugify(s: string): string {\n  return s.toLowerCase().replace(/[^a-z0-9]+/g, \"-\").replace(/^-+|-+$/g, \"\").slice(0, 60) || \"alias\";\n}\n\nfunction confidenceFor(evidenceCount: number): Confidence {\n  return evidenceCount >= 3 ? \"high\" : evidenceCount >= 2 ? \"medium\" : \"low\";\n}\n\n/** Read every lexicon note into entries and write the derived cache. */\nexport async function compileLexicon(vaultPath: string): Promise<AliasEntry[]> {\n  const files = await glob(`${LEXICON_DIR}/**/*.md`, { cwd: vaultPath });\n  const entries: AliasEntry[] = [];\n  for (const rel of files) {\n    try {\n      const { data } = matter(await readFile(join(vaultPath, rel), \"utf-8\"));\n      if (data.type !== \"alias\" || typeof data.canonical !== \"string\") continue;\n      const phrases = Array.isArray(data.phrases) ? data.phrases.map(String).map((p) => p.trim()).filter(Boolean) : [];\n      entries.push({\n        canonical: data.canonical,\n        phrases,\n        confidence: ([\"low\", \"medium\", \"high\"] as const).includes(data.confidence) ? data.confidence : confidenceFor(1),\n        evidence_count: typeof data.evidence_count === \"number\" ? data.evidence_count : phrases.length ? 1 : 0,\n        last_used: typeof data.last_used === \"string\" ? data.last_used : undefined,\n        source: data.source === \"authored\" ? \"authored\" : \"learned\",\n        path: rel,\n      });\n    } catch {\n      /* skip unreadable note */\n    }\n  }\n  // Fold in dossier aliases (v1.5 Phase 8): a dossier's `aliases:` are the human's\n  // phrases for that entity, so they become query-expansion bindings pointing at the\n  // dossier note. Authored, not learned — the human named the entity deliberately.\n  // A lexicon note for the same canonical wins (it carries real evidence_count).\n  try {\n    const dossiers = await listDossiers(vaultPath);\n    for (const d of dossiers) {\n      if (d.aliases.length === 0) continue;\n      if (entries.some((e) => e.canonical === d.path)) continue;\n      entries.push({\n        canonical: d.path,\n        phrases: d.aliases,\n        confidence: \"high\",\n        evidence_count: d.aliases.length,\n        source: \"authored\",\n        path: d.path,\n      });\n    }\n  } catch {\n    /* dossiers optional — lexicon compiles fine without them */\n  }\n  try {\n    const dir = deriveSessionDir(vaultPath);\n    await mkdir(dir, { recursive: true });\n    await writeFile(join(dir, CACHE_FILE), JSON.stringify({ compiledAt: new Date().toISOString(), aliases: entries }, null, 2), \"utf-8\");\n  } catch {\n    /* cache write is best-effort */\n  }\n  return entries;\n}\n\n/** Fast read for the hook: use the cache if present, else compile. */\nexport async function loadLexiconCache(vaultPath: string): Promise<AliasEntry[]> {\n  const cachePath = join(deriveSessionDir(vaultPath), CACHE_FILE);\n  if (existsSync(cachePath)) {\n    try {\n      const data = JSON.parse(await readFile(cachePath, \"utf-8\"));\n      if (Array.isArray(data?.aliases)) return data.aliases as AliasEntry[];\n    } catch {\n      /* fall through to recompile */\n    }\n  }\n  return compileLexicon(vaultPath);\n}\n\nexport function lookupPhrase(aliases: AliasEntry[], phrase: string): AliasEntry[] {\n  const n = normalizePhrase(phrase);\n  return aliases.filter((a) => a.phrases.some((p) => normalizePhrase(p) === n));\n}\n\n/**\n * Expand a query by appending the canonical targets of any alias phrases that\n * appear in it. Deterministic, no LLM — this is the Tier-1 hook-time expansion.\n */\nexport function expandQuery(aliases: AliasEntry[], query: string): { expanded: string; matched: AliasEntry[] } {\n  const nq = normalizePhrase(query);\n  const matched = aliases.filter((a) => a.phrases.some((p) => p && nq.includes(normalizePhrase(p))));\n  if (matched.length === 0) return { expanded: query, matched: [] };\n  const additions = [...new Set(matched.map((a) => a.canonical))].join(\" \");\n  return { expanded: `${query} ${additions}`, matched };\n}\n\nasync function writeAliasNote(vaultPath: string, rel: string, entry: Omit<AliasEntry, \"path\">): Promise<void> {\n  const fm = {\n    type: \"alias\",\n    canonical: entry.canonical,\n    phrases: entry.phrases,\n    confidence: entry.confidence,\n    evidence_count: entry.evidence_count,\n    last_used: entry.last_used,\n    source: entry.source,\n  };\n  const body = `# Alias: ${entry.canonical}\\n\\nHuman phrases that refer to \\`${entry.canonical}\\`.\\n`;\n  const abs = join(vaultPath, rel);\n  await mkdir(dirname(abs), { recursive: true });\n  await writeFile(abs, matter.stringify(body, fm), \"utf-8\");\n}\n\n/**\n * Upsert an alias. New canonical → new note (evidence 1). Existing canonical →\n * merge phrases, bump evidence_count, recompute confidence. Recompiles the cache.\n */\nexport async function addAlias(\n  vaultPath: string,\n  input: { canonical: string; phrases: string[]; source?: \"learned\" | \"authored\"; today?: string }\n): Promise<{ path: string; created: boolean; evidence_count: number; confidence: Confidence }> {\n  const existing = await compileLexicon(vaultPath);\n  const match = existing.find((a) => a.canonical === input.canonical);\n  const today = input.today ?? new Date().toISOString().slice(0, 10);\n  const cleanPhrases = input.phrases.map((p) => p.trim()).filter(Boolean);\n\n  if (match) {\n    const phrases = [...new Set([...match.phrases, ...cleanPhrases])];\n    const evidence_count = match.evidence_count + 1;\n    const confidence = confidenceFor(evidence_count);\n    await writeAliasNote(vaultPath, match.path, { ...match, phrases, evidence_count, confidence, last_used: today });\n    await compileLexicon(vaultPath);\n    return { path: match.path, created: false, evidence_count, confidence };\n  }\n\n  const rel = join(LEXICON_DIR, `${slugify(input.canonical)}.md`);\n  const evidence_count = 1;\n  const confidence = confidenceFor(evidence_count);\n  await writeAliasNote(vaultPath, rel, {\n    canonical: input.canonical,\n    phrases: cleanPhrases,\n    confidence,\n    evidence_count,\n    last_used: today,\n    source: input.source ?? \"learned\",\n  });\n  await compileLexicon(vaultPath);\n  return { path: rel, created: true, evidence_count, confidence };\n}\n\nexport interface AliasConflict {\n  phrase: string;\n  canonicals: string[];\n}\n\n/**\n * Find conflicting bindings: the same (normalized) phrase mapping to more than one\n * canonical target. A wrong alias silently misroutes every future query with that\n * phrase, so conflicts are surfaced (never auto-resolved) for a human to fix.\n */\nexport function findAliasConflicts(aliases: AliasEntry[]): AliasConflict[] {\n  const byPhrase = new Map<string, Set<string>>();\n  for (const a of aliases) {\n    for (const p of a.phrases) {\n      const n = normalizePhrase(p);\n      if (!n) continue;\n      if (!byPhrase.has(n)) byPhrase.set(n, new Set());\n      byPhrase.get(n)!.add(a.canonical);\n    }\n  }\n  const conflicts: AliasConflict[] = [];\n  for (const [phrase, canonicals] of byPhrase) {\n    if (canonicals.size > 1) conflicts.push({ phrase, canonicals: [...canonicals].sort() });\n  }\n  return conflicts.sort((a, b) => a.phrase.localeCompare(b.phrase));\n}\n\n/** Remove an alias note by canonical. Returns whether one was removed. */\nexport async function removeAlias(vaultPath: string, canonical: string): Promise<boolean> {\n  const existing = await compileLexicon(vaultPath);\n  const match = existing.find((a) => a.canonical === canonical);\n  if (!match) return false;\n  try {\n    await unlink(join(vaultPath, match.path));\n  } catch {\n    return false;\n  }\n  await compileLexicon(vaultPath);\n  return true;\n}\n"],"mappings":"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","names":["evidence_count","confidence"]}

package/dist/{chunk-CYWPDFNI.js → chunk-CSXZ7QUU.js}

@@ -1,7 +1,7 @@
 import {
   loadSchema,
   validateNote
-} from "./chunk-E2Z4J4MK.js";
+} from "./chunk-OWZWMB4P.js";
 
 // src/core/crud.ts
 import { readFile, writeFile, unlink, rename, mkdir } from "fs/promises";
@@ -707,6 +707,7 @@ function buildSynthesizeChangeSet(input) {
     ...input.decision_maker && { decision_maker: input.decision_maker },
     ...input.decided_on && { decided_on: input.decided_on },
     ...input.severity && { severity: input.severity },
+    ...input.symptoms && input.symptoms.length > 0 && { symptoms: input.symptoms },
     ...isProposal && { proposed_target: canonicalPath },
     ...input.extra_frontmatter ?? {}
   };
@@ -917,203 +918,6 @@ async function inspectAgentsContract(projectRoot) {
   return { path, exists: true, has_managed_block: true, local_notes_chars: localTail.length };
 }
 
-// src/core/session.ts
-import { mkdir as mkdir3, readFile as readFile6, writeFile as writeFile6, rm } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
-import { spawn } from "child_process";
-var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
-var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
-var TAIL_BYTES = 4096;
-var SessionManager = class {
-  constructor(sessionDir) {
-    this.sessionDir = sessionDir;
-  }
-  sessionDir;
-  get sessionPath() {
-    return join6(this.sessionDir, "session.json");
-  }
-  async start(task, opts = {}) {
-    if (!task || task.trim().length === 0) {
-      return { ok: false, error: "session_start requires a non-empty task." };
-    }
-    await mkdir3(this.sessionDir, { recursive: true });
-    const existing = await this.read();
-    if (existing && !existing.closed_at) {
-      const reuseSameTask = opts.reuseSameTask !== false;
-      if (reuseSameTask && existing.task === task) {
-        return { ok: true, id: existing.id, reused: true };
-      }
-      return {
-        ok: false,
-        error: `Session already open: id=${existing.id}, task=${JSON.stringify(existing.task)}. Close it with session_finish first.`
-      };
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `ses_${now.replace(/[:.]/g, "-")}`;
-    const state = {
-      id,
-      task: task.trim(),
-      started_at: now,
-      last_activity_at: now,
-      verifications: [],
-      notes_touched: []
-    };
-    await writeFile6(this.sessionPath, JSON.stringify(state, null, 2), "utf-8");
-    return { ok: true, id };
-  }
-  async status() {
-    const state = await this.read();
-    if (!state || state.closed_at) return { state: "no_session" };
-    const age = Date.now() - new Date(state.last_activity_at).getTime();
-    const label = age > STALE_THRESHOLD_MS ? "stale" : "active";
-    return { ...state, state: label };
-  }
-  async run(cmd, timeoutMs) {
-    const state = await this.read();
-    if (!state || state.closed_at) {
-      return { ok: false, error: "No active session. Run session_start first." };
-    }
-    if (!cmd || cmd.trim().length === 0) {
-      return { ok: false, error: "session_run requires a non-empty command." };
-    }
-    const start = Date.now();
-    const record = await this.spawnAndCapture(cmd, timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    record.duration_ms = Date.now() - start;
-    state.verifications.push(record);
-    state.last_activity_at = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile6(this.sessionPath, JSON.stringify(state, null, 2), "utf-8");
-    return { ok: true, record };
-  }
-  async finish(input) {
-    const state = await this.read();
-    if (!state || state.closed_at) {
-      return { ok: false, error: "No active session to finish." };
-    }
-    const explicitWaiver = input.verified === false;
-    if (!explicitWaiver && state.verifications.length === 0) {
-      return {
-        ok: false,
-        error: "session_finish refused: no verification commands recorded. Run session_run with a real verification command (tests, lint, etc.) first, OR pass verified=false with a reason to waive verification (e.g. for doc-only edits)."
-      };
-    }
-    if (explicitWaiver && (!input.reason || input.reason.trim().length === 0)) {
-      return {
-        ok: false,
-        error: "session_finish refused: verified=false requires a non-empty `reason` explaining why verification is not applicable to this task."
-      };
-    }
-    if (!input.summary || input.summary.trim().length === 0) {
-      return { ok: false, error: "session_finish requires a non-empty `summary`." };
-    }
-    const closed = {
-      ...state,
-      closed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      closed_summary: input.summary.trim(),
-      ...explicitWaiver && {
-        closed_verified_waived: true,
-        closed_waiver_reason: input.reason.trim()
-      }
-    };
-    await rm(this.sessionPath, { force: true });
-    return { ok: true, closed };
-  }
-  /**
-   * Append paths to notes_touched on the active session, deduplicating. No-op when no
-   * session is active. Used by patch tools to record what the session edited.
-   */
-  async recordNotesTouched(paths) {
-    if (paths.length === 0) return;
-    const state = await this.read();
-    if (!state || state.closed_at) return;
-    const set = new Set(state.notes_touched);
-    for (const p of paths) set.add(p);
-    state.notes_touched = Array.from(set);
-    state.last_activity_at = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile6(this.sessionPath, JSON.stringify(state, null, 2), "utf-8");
-  }
-  /**
-   * Read the active session WITHOUT computing the stale label. Returns null when no
-   * session is active or when the file is unparseable.
-   */
-  async readActive() {
-    const state = await this.read();
-    if (!state || state.closed_at) return null;
-    return state;
-  }
-  async read() {
-    if (!existsSync5(this.sessionPath)) return null;
-    try {
-      const raw = await readFile6(this.sessionPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (typeof parsed?.id !== "string") return null;
-      return parsed;
-    } catch {
-      return null;
-    }
-  }
-  spawnAndCapture(cmd, timeoutMs) {
-    return new Promise((resolve) => {
-      const proc = spawn(cmd, { shell: true });
-      let buf = "";
-      let killedByTimeout = false;
-      const timer = setTimeout(() => {
-        killedByTimeout = true;
-        proc.kill("SIGTERM");
-        setTimeout(() => {
-          try {
-            proc.kill("SIGKILL");
-          } catch {
-          }
-        }, 1e3).unref();
-      }, timeoutMs);
-      const onData = (chunk) => {
-        buf += chunk.toString("utf-8");
-        if (buf.length > TAIL_BYTES * 4) {
-          buf = buf.slice(buf.length - TAIL_BYTES * 2);
-        }
-      };
-      proc.stdout?.on("data", onData);
-      proc.stderr?.on("data", onData);
-      proc.on("close", (code, signal) => {
-        clearTimeout(timer);
-        const tail = buf.slice(-TAIL_BYTES);
-        resolve({
-          cmd,
-          exit: killedByTimeout ? null : code,
-          signal: killedByTimeout ? "SIGTERM (timeout)" : signal ?? null,
-          duration_ms: 0,
-          tail,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      });
-      proc.on("error", (err) => {
-        clearTimeout(timer);
-        const tail = buf + `
-[spawn error: ${err.message}]`;
-        resolve({
-          cmd,
-          exit: null,
-          signal: null,
-          duration_ms: 0,
-          tail: tail.slice(-TAIL_BYTES),
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      });
-    });
-  }
-};
-function deriveProjectRoot(notesPath) {
-  const norm = notesPath.replace(/[\\/]+$/, "");
-  if (norm.endsWith("/.claude/.vault") || norm.endsWith("\\.claude\\.vault")) {
-    return norm.slice(0, -".claude/.vault".length).replace(/[\\/]+$/, "");
-  }
-  return norm;
-}
-function deriveSessionDir(notesPath) {
-  return join6(deriveProjectRoot(notesPath), ".claude", ".semantic-memory");
-}
-
 export {
   NoteCrud,
   FrontmatterManager,
@@ -1128,9 +932,6 @@ export {
   buildSynthesizeChangeSet,
   buildPromoteChangeSet,
   regenerateAgentsContract,
-  inspectAgentsContract,
-  SessionManager,
-  deriveProjectRoot,
-  deriveSessionDir
+  inspectAgentsContract
 };
-//# sourceMappingURL=chunk-CYWPDFNI.js.map
+//# sourceMappingURL=chunk-CSXZ7QUU.js.map