@gamaze/hicortex 0.18.1 → 0.18.2

package/dist/recall-index.js

@@ -255,10 +255,15 @@ function handleMemoryGet(db, query) {
     // `citation` is server-rendered so every plugin surfaces the same built-in
     // provenance norm (owner directive 27.07) — see #193.
     const date = (mem.created_at ?? "").slice(0, 10);
+    // Shallow-copy and apply the human-term label to memory_type so the REST
+    // response surfaces the user-facing vocabulary, not the raw DB enum. The
+    // underlying DB row (`mem`) is NOT mutated — the DB IS the raw-enum source
+    // of truth; the label is a presentation concern applied at the boundary.
+    const memory = { ...mem, memory_type: (0, type_labels_js_1.labelForType)(mem.memory_type) };
     return {
         status: 200,
         body: {
-            memory: mem,
+            memory,
             citation: `(memory ${String(mem.id).slice(0, 8)}, ${date}, from ${mem.source_agent ?? "unknown"}, FETCHED)`,
         },
     };
@@ -284,7 +289,7 @@ function formatMemoryGetText(db, query) {
     const date = (mem.created_at ?? "").slice(0, 10);
     // #264 WS2: render the human-term label (Knowledge/Experience/...), not the
     // internal enum, in the citation header shown to the agent/user.
-    const header = `[memory ${mem.id} | ${(0, type_labels_js_1.labelForType)(mem.memory_type ?? "episode")} | ${mem.project ?? "-"} | from ${mem.source_agent ?? "unknown"} | ${date}]\n` +
+    const header = `[memory ${mem.id} | ${(0, type_labels_js_1.labelForType)(mem.memory_type ?? "experience")} | ${mem.project ?? "-"} | from ${mem.source_agent ?? "unknown"} | ${date}]\n` +
         `Cite as ${citation} where this shapes your answer; it may be stale — newer memories supersede older.`;
     return { status: 200, text: `${header}\n\n${mem.content ?? ""}` };
 }

package/dist/retrieval.js

@@ -69,6 +69,7 @@ exports.retrieve = retrieve;
 exports.searchRecent = searchRecent;
 const storage = __importStar(require("./storage.js"));
 const schema_prototypes_js_1 = require("./schema-prototypes.js");
+const type_labels_js_1 = require("./type-labels.js");
 /** Default decay half-life (days) at importance 0.5. #192: was 0.0005/h
  *  (~115-day half-life at base 0.5) — aggressive enough to bury the long tail
  *  in ranking. Long-term remembering is the product; time preference stays,
@@ -450,7 +451,7 @@ function formatResult(memory, score, effStr, connections, provenance) {
         score: Math.round(score * 1e6) / 1e6,
         effective_strength: Math.round(effStr * 1e6) / 1e6,
         access_count: memory.access_count ?? 0,
-        memory_type: memory.memory_type ?? "episode",
+        memory_type: (0, type_labels_js_1.labelForType)(memory.memory_type ?? "experience"),
         project: memory.project ?? null,
         source_agent: memory.source_agent ?? null,
         created_at: memory.created_at ?? "",

package/dist/seed-lesson.js

@@ -63,7 +63,7 @@ async function injectSeedLesson(database, log = console.log) {
         storage.insertMemory(database, exports.SEED_LESSON, embedding, {
             sourceAgent: "hicortex/seed",
             project: "global",
-            memoryType: "lesson",
+            memoryType: "learnings",
             baseStrength: 0.95,
         });
         log("[hicortex] Seed lesson injected: Daily Self-Improvement Protocol");

package/dist/status.d.ts

@@ -10,4 +10,12 @@
  * out as invalid (the hook sends none) rather than silently accepted.
  */
 export declare function statusAgentLine(config: Record<string, unknown>): string;
+/**
+ * Format the memory-type breakdown for `hicortex status`. Each raw DB enum key
+ * is rendered through {@link labelForType} so the printed line uses the human
+ * vocabulary (Knowledge/Experience/Decisions/Learnings), not the raw enum.
+ * Extracted from `runStatus` so the labeling is unit-testable without booting
+ * the full status printer. Unknown keys pass through verbatim (forward-compat).
+ */
+export declare function formatTypeBreakdown(byType: Record<string, number>): string;
 export declare function runStatus(): Promise<void>;

package/dist/status.js

@@ -4,6 +4,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.statusAgentLine = statusAgentLine;
+exports.formatTypeBreakdown = formatTypeBreakdown;
 exports.runStatus = runStatus;
 const paths_js_1 = require("./paths.js");
 const node_fs_1 = require("node:fs");
@@ -14,6 +15,7 @@ const db_js_1 = require("./db.js");
 const features_js_1 = require("./features.js");
 const state_js_1 = require("./state.js");
 const identity_store_js_1 = require("./identity-store.js");
+const type_labels_js_1 = require("./type-labels.js");
 const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
 const CC_SETTINGS = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "settings.json");
 const OC_CONFIG = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
@@ -36,6 +38,18 @@ function statusAgentLine(config) {
             return "(not set — global identity)";
     }
 }
+/**
+ * Format the memory-type breakdown for `hicortex status`. Each raw DB enum key
+ * is rendered through {@link labelForType} so the printed line uses the human
+ * vocabulary (Knowledge/Experience/Decisions/Learnings), not the raw enum.
+ * Extracted from `runStatus` so the labeling is unit-testable without booting
+ * the full status printer. Unknown keys pass through verbatim (forward-compat).
+ */
+function formatTypeBreakdown(byType) {
+    return Object.entries(byType)
+        .map(([k, v]) => `${(0, type_labels_js_1.labelForType)(k)}=${v}`)
+        .join(", ");
+}
 async function runStatus() {
     console.log("Hicortex Status");
     console.log("─".repeat(40));
@@ -48,7 +62,7 @@ async function runStatus() {
             const { initDb, getStats } = await import("./db.js");
             const db = initDb(dbPath);
             const stats = getStats(db, dbPath);
-            const typeStr = Object.entries(stats.by_type).map(([k, v]) => `${k}=${v}`).join(", ");
+            const typeStr = formatTypeBreakdown(stats.by_type);
             console.log(`Memories:     ${stats.memories} (${typeStr || "none"})`);
             console.log(`Links:        ${stats.links}`);
             console.log(`DB size:      ${(stats.db_size_bytes / 1024).toFixed(1)} KB`);

package/dist/storage.js

@@ -72,7 +72,7 @@ function insertMemory(db, content, embedding, opts = {}) {
         created_at, ingested_at, source_agent, source_agent_id, source_session,
         source_domain, project, privacy, memory_type)
        VALUES (?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(id, content, opts.baseStrength ?? 0.5, ts, ts, ingestedTs, opts.sourceAgent ?? "default", opts.sourceAgentId ?? null, sourceSession, opts.sourceDomain ?? null, opts.project ?? null, opts.privacy ?? null, opts.memoryType ?? "episode");
+        .run(id, content, opts.baseStrength ?? 0.5, ts, ts, ingestedTs, opts.sourceAgent ?? "default", opts.sourceAgentId ?? null, sourceSession, opts.sourceDomain ?? null, opts.project ?? null, opts.privacy ?? null, opts.memoryType ?? "experience");
     if (result.changes > 0) {
         // New row — store its vector.
         db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(id, embedToBlob(embedding));
@@ -469,7 +469,7 @@ function insertMemoriesBatch(db, memories) {
         for (const mem of memories) {
             const id = (0, node_crypto_1.randomUUID)();
             const ts = nowIso();
-            insertMem.run(id, mem.content, mem.baseStrength ?? 0.5, ts, ts, ts, mem.sourceAgent ?? "default", mem.sourceAgentId ?? null, mem.sourceSession ?? null, mem.sourceDomain ?? null, mem.project ?? null, mem.privacy ?? null, mem.memoryType ?? "episode");
+            insertMem.run(id, mem.content, mem.baseStrength ?? 0.5, ts, ts, ts, mem.sourceAgent ?? "default", mem.sourceAgentId ?? null, mem.sourceSession ?? null, mem.sourceDomain ?? null, mem.project ?? null, mem.privacy ?? null, mem.memoryType ?? "experience");
             insertVec.run(id, embedToBlob(mem.embedding));
             count++;
         }
@@ -514,14 +514,14 @@ function getLessons(db, days = 7, project) {
     if (project) {
         const rows = db
             .prepare(`SELECT * FROM memories
-         WHERE memory_type = 'lesson' AND created_at > ? AND project = ?
+         WHERE memory_type = 'learnings' AND created_at > ? AND project = ?
          ORDER BY created_at DESC`)
             .all(cutoff, project);
         return rows.map(rowToMemory);
     }
     const rows = db
         .prepare(`SELECT * FROM memories
-       WHERE memory_type = 'lesson' AND created_at > ?
+       WHERE memory_type = 'learnings' AND created_at > ?
        ORDER BY created_at DESC`)
         .all(cutoff);
     return rows.map(rowToMemory);

package/dist/type-classify.d.ts

@@ -1,41 +1,41 @@
 /**
- * `hicortex classify-types` — deliberate, resumable episode→fact/decision
- * reclassification pass over the memories corpus (#216).
+ * `hicortex classify-types` — deliberate, resumable experience→knowledge/
+ * decisions reclassification pass over the memories corpus (#216).
  *
  * WHY THIS EXISTS
  * ---------------
  * Before #216 the distiller NEVER set memory_type — every distilled memory
- * defaulted to "episode" (storage.ts insertMemory `?? "episode"`), so the
- * corpus was ~98% episodes. The distiller now classifies each entry at extract
- * time via the [E]/[F]/[D] tag (distiller.ts), but the EXISTING corpus needs a
- * one-shot backfill. This command is that backfill — modelled on
+ * defaulted to "experience" (storage.ts insertMemory `?? "experience"`), so
+ * the corpus was ~98% experiences. The distiller now classifies each entry at
+ * extract time via the [E]/[K]/[D] tag (distiller.ts), but the EXISTING corpus
+ * needs a one-shot backfill. This command is that backfill — modelled on
  * `classify-domains` (resumable cursor, batched, infra-error-safe).
  *
  * WHAT IT DOES
  * ------------
  * Walks memories ordered by rowid in batches (default 200). Default scope =
- * episodes only (`memory_type = 'episode'`); `--all` reclassifies every memory
- * regardless of current type **except lessons** (see below). For each memory,
- * ONE constrained LLM call asks the model to classify the content as
- * episode / fact / decision. The reply is parsed + validated, and
+ * experiences only (`memory_type = 'experience'`); `--all` reclassifies every
+ * memory regardless of current type **except learnings** (see below). For each
+ * memory, ONE constrained LLM call asks the model to classify the content as
+ * experience / knowledge / decisions. The reply is parsed + validated, and
  * `UPDATE memories SET memory_type = ? WHERE id = ?` runs inside a per-batch
  * transaction. The cursor (`typeCursor` in state.json) advances to the last
  * committed rowid after each batch — crash-safe and infra-abort-safe (same
  * discipline as classify-domains).
  *
- * Lessons are NEVER touched here: the reflection stage owns them. The `--all`
- * scope explicitly excludes `memory_type = 'lesson'` — this is the primary
- * defence. (The prompt asks only for episode/fact/decision, so a lesson that
- * DID enter scope would be overwritten to E/F/D — the model never replies
- * "lesson". `parseTypeReply`'s rejection of a "lesson" reply is a backstop, not
- * the main guard.)
+ * Learnings are NEVER touched here: the reflection stage owns them. The
+ * `--all` scope explicitly excludes `memory_type = 'learnings'` — this is the
+ * primary defence. (The prompt asks only for experience/knowledge/decisions,
+ * so a learning that DID enter scope would be overwritten — the model never
+ * replies "learnings". `parseTypeReply`'s rejection of a "learnings" reply is
+ * a backstop, not the main guard.)
  *
  * This command does NOT use the consolidation budget — it is a standalone CLI,
  * not a nightly stage.
  */
 import { LlmClient } from "./llm.js";
 export interface ClassifyTypesOptions {
-    /** Reclassify EVERY memory, not just episodes. */
+    /** Reclassify EVERY memory, not just experiences. */
     all?: boolean;
     /** Memories per batch (default 200). Cursor advances per committed batch. */
     batchSize?: number;
@@ -55,7 +55,7 @@ export interface ClassifyTypesReport {
     scanned: number;
     /** Memories whose memory_type was changed. */
     reclassified: number;
-    /** Episodes confirmed as episode (no change). */
+    /** Experiences confirmed as experience (no change). */
     unchanged: number;
     /** Memories skipped due to an infra error (LLM threw twice). */
     failed: number;
@@ -70,23 +70,26 @@ export interface ClassifyTypesReport {
 }
 /**
  * Build the constrained type-classification prompt for one memory. The model
- * must reply with ONLY the type word (episode/fact/decision) — no prose. The
- * distinction mirrors the distiller's [E]/[F]/[D] tag definitions (prompts.ts),
- * so distill-time and backfill-time classification stay consistent.
+ * must reply with ONLY the type word (experience/knowledge/decisions) — no
+ * prose. The distinction mirrors the distiller's [E]/[K]/[D] tag definitions
+ * (prompts.ts), so distill-time and backfill-time classification stay
+ * consistent. (The stored enum was renamed in #264: episode→experience,
+ * fact→knowledge, decision→decisions; the conceptual definitions are
+ * unchanged.)
  */
 export declare function buildTypeClassifyPrompt(content: string): string;
 /**
  * Parse the model's reply into a validated type. Accepts the bare word
  * (case-insensitive), tolerating surrounding whitespace, a trailing period, a
- * leading "Type:" label, and markdown emphasis. "lesson" is NEVER accepted
- * (the reflection stage owns lessons; a model that emits it is wrong) — returns
- * null so the caller retries.
+ * leading "Type:" label, and markdown emphasis. "learnings" (and the legacy
+ * "lesson") are NEVER accepted (the reflection stage owns learnings; a model
+ * that emits either is wrong) — returns null so the caller retries.
  *
  * Returns null on anything unparseable or out-of-vocabulary so the caller can
  * retry once (matching classify-domains' two-attempt discipline).
  */
 export declare function parseTypeReply(reply: string): {
-    type: "episode" | "fact" | "decision";
+    type: "experience" | "knowledge" | "decisions";
     score: number;
 } | null;
 /**
@@ -95,7 +98,7 @@ export declare function parseTypeReply(reply: string): {
  * (caller leaves the memory untouched and retries via the cursor next run).
  */
 export declare function classifyMemoryType(content: string, llm: LlmClient): Promise<{
-    type: "episode" | "fact" | "decision";
+    type: "experience" | "knowledge" | "decisions";
     score: number;
 } | null>;
 /**

package/dist/type-classify.js

@@ -1,35 +1,35 @@
 "use strict";
 /**
- * `hicortex classify-types` — deliberate, resumable episode→fact/decision
- * reclassification pass over the memories corpus (#216).
+ * `hicortex classify-types` — deliberate, resumable experience→knowledge/
+ * decisions reclassification pass over the memories corpus (#216).
  *
  * WHY THIS EXISTS
  * ---------------
  * Before #216 the distiller NEVER set memory_type — every distilled memory
- * defaulted to "episode" (storage.ts insertMemory `?? "episode"`), so the
- * corpus was ~98% episodes. The distiller now classifies each entry at extract
- * time via the [E]/[F]/[D] tag (distiller.ts), but the EXISTING corpus needs a
- * one-shot backfill. This command is that backfill — modelled on
+ * defaulted to "experience" (storage.ts insertMemory `?? "experience"`), so
+ * the corpus was ~98% experiences. The distiller now classifies each entry at
+ * extract time via the [E]/[K]/[D] tag (distiller.ts), but the EXISTING corpus
+ * needs a one-shot backfill. This command is that backfill — modelled on
  * `classify-domains` (resumable cursor, batched, infra-error-safe).
  *
  * WHAT IT DOES
  * ------------
  * Walks memories ordered by rowid in batches (default 200). Default scope =
- * episodes only (`memory_type = 'episode'`); `--all` reclassifies every memory
- * regardless of current type **except lessons** (see below). For each memory,
- * ONE constrained LLM call asks the model to classify the content as
- * episode / fact / decision. The reply is parsed + validated, and
+ * experiences only (`memory_type = 'experience'`); `--all` reclassifies every
+ * memory regardless of current type **except learnings** (see below). For each
+ * memory, ONE constrained LLM call asks the model to classify the content as
+ * experience / knowledge / decisions. The reply is parsed + validated, and
  * `UPDATE memories SET memory_type = ? WHERE id = ?` runs inside a per-batch
  * transaction. The cursor (`typeCursor` in state.json) advances to the last
  * committed rowid after each batch — crash-safe and infra-abort-safe (same
  * discipline as classify-domains).
  *
- * Lessons are NEVER touched here: the reflection stage owns them. The `--all`
- * scope explicitly excludes `memory_type = 'lesson'` — this is the primary
- * defence. (The prompt asks only for episode/fact/decision, so a lesson that
- * DID enter scope would be overwritten to E/F/D — the model never replies
- * "lesson". `parseTypeReply`'s rejection of a "lesson" reply is a backstop, not
- * the main guard.)
+ * Learnings are NEVER touched here: the reflection stage owns them. The
+ * `--all` scope explicitly excludes `memory_type = 'learnings'` — this is the
+ * primary defence. (The prompt asks only for experience/knowledge/decisions,
+ * so a learning that DID enter scope would be overwritten — the model never
+ * replies "learnings". `parseTypeReply`'s rejection of a "learnings" reply is
+ * a backstop, not the main guard.)
  *
  * This command does NOT use the consolidation budget — it is a standalone CLI,
  * not a nightly stage.
@@ -49,8 +49,8 @@ const type_labels_js_1 = require("./type-labels.js");
 const HICORTEX_HOME = (0, paths_js_1.hicortexHome)();
 /** Max chars of memory content fed to the classify prompt. */
 const CLASSIFY_CONTENT_MAX_CHARS = 1500;
-/** Valid distillation-time memory types (NO lesson — reflection owns that). */
-const VALID_TYPES = new Set(["episode", "fact", "decision"]);
+/** Valid distillation-time memory types (NO learnings — reflection owns that). */
+const VALID_TYPES = new Set(["experience", "knowledge", "decisions"]);
 function readConfig(stateDir) {
     try {
         return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(stateDir, "config.json"), "utf-8"));
@@ -61,9 +61,12 @@ function readConfig(stateDir) {
 }
 /**
  * Build the constrained type-classification prompt for one memory. The model
- * must reply with ONLY the type word (episode/fact/decision) — no prose. The
- * distinction mirrors the distiller's [E]/[F]/[D] tag definitions (prompts.ts),
- * so distill-time and backfill-time classification stay consistent.
+ * must reply with ONLY the type word (experience/knowledge/decisions) — no
+ * prose. The distinction mirrors the distiller's [E]/[K]/[D] tag definitions
+ * (prompts.ts), so distill-time and backfill-time classification stay
+ * consistent. (The stored enum was renamed in #264: episode→experience,
+ * fact→knowledge, decision→decisions; the conceptual definitions are
+ * unchanged.)
  */
 function buildTypeClassifyPrompt(content) {
     const truncated = content.length > CLASSIFY_CONTENT_MAX_CHARS
@@ -71,28 +74,31 @@ function buildTypeClassifyPrompt(content) {
         : content;
     return (`You are classifying a single memory by its TYPE and IMPORTANCE.\n\n` +
         `TYPES:\n` +
-        `- episode: a specific event, interaction, or narrative — a one-time ` +
+        `- experience: a specific event, interaction, or narrative — a one-time ` +
         `occurrence ("tried X, failed because Y", a correction, a debugging session).\n` +
-        `- fact: a durable truth that holds across sessions, not tied to a single ` +
-        `moment ("the API is at :8787", "uv is used for packages").\n` +
-        `- decision: a choice made that future work builds on and a later decision ` +
-        `can supersede ("switched from gemma4 to qwen3.5", "adopted the graded-schema ` +
-        `tag model"). Not a fact (it can change) and not an episode (it persists).\n\n` +
+        `- knowledge: a durable truth that holds across sessions, not tied to a ` +
+        `single moment ("the API is at :8787", "uv is used for packages").\n` +
+        `- decisions: a choice made that future work builds on and a later ` +
+        `decision can supersede ("switched from gemma4 to qwen3.5", "adopted the ` +
+        `graded-schema tag model"). Not knowledge (it can change) and not an ` +
+        `experience (it persists).\n\n` +
         `IMPORTANCE (0.0–1.0):\n` +
-        `- 0.8–1.0: load-bearing — a core fact or decision the agent must know.\n` +
+        `- 0.8–1.0: load-bearing — a core piece of knowledge or a decision the ` +
+        `agent must know.\n` +
         `- 0.5–0.8: useful context — relevant to current and future work.\n` +
         `- 0.2–0.5: marginal — situational, likely to fade.\n` +
         `- 0.0–0.2: noise — low value, safe to forget.\n` +
-        `Facts and decisions tend to score higher than episodes (they persist).\n\n` +
+        `Knowledge and decisions tend to score higher than experiences (they ` +
+        `persist).\n\n` +
         `MEMORY:\n${truncated}\n\n` +
-        `Reply with ONLY: type importance (e.g. "fact 0.8"). No prose, no explanation.`);
+        `Reply with ONLY: type importance (e.g. "knowledge 0.8"). No prose, no explanation.`);
 }
 /**
  * Parse the model's reply into a validated type. Accepts the bare word
  * (case-insensitive), tolerating surrounding whitespace, a trailing period, a
- * leading "Type:" label, and markdown emphasis. "lesson" is NEVER accepted
- * (the reflection stage owns lessons; a model that emits it is wrong) — returns
- * null so the caller retries.
+ * leading "Type:" label, and markdown emphasis. "learnings" (and the legacy
+ * "lesson") are NEVER accepted (the reflection stage owns learnings; a model
+ * that emits either is wrong) — returns null so the caller retries.
  *
  * Returns null on anything unparseable or out-of-vocabulary so the caller can
  * retry once (matching classify-domains' two-attempt discipline).
@@ -112,8 +118,8 @@ function parseTypeReply(reply) {
         .replace(/^[*_`"'\s]+/, "")
         .replace(/[*_`"']+$/, "")
         .trim();
-    // Expected format: "type score" (e.g. "fact 0.8"). Parse both.
-    const match = cleaned.toLowerCase().match(/^(episode|fact|decision)\s+([0-9]*\.?[0-9]+)/);
+    // Expected format: "type score" (e.g. "knowledge 0.8"). Parse both.
+    const match = cleaned.toLowerCase().match(/^(experience|knowledge|decisions)\s+([0-9]*\.?[0-9]+)/);
     if (match) {
         const type = match[1];
         let score = parseFloat(match[2]);
@@ -158,7 +164,7 @@ async function classifyMemoryType(content, llm) {
         }
     }
     // Two successful calls, neither parseable → leave the memory's type unchanged.
-    // We do NOT default to episode here: a model that can't decide should not
+    // We do NOT default to experience here: a model that can't decide should not
     // silently overwrite an existing type. Return null so the caller records a
     // failed classification and the cursor still advances past this row.
     return null;
@@ -208,17 +214,18 @@ async function runClassifyTypes(options = {}) {
     try {
         let cursor = options.reset ? 0 : ((0, state_js_1.loadState)(stateDir).typeCursor ?? 0);
         report.cursor = cursor;
-        console.log(`[hicortex] classify-types starting: scope ${all ? "ALL" : "episodes only"}, ` +
+        console.log(`[hicortex] classify-types starting: scope ${all ? "ALL" : "experiences only"}, ` +
             `batch ${batchSize}, cursor ${cursor}${options.reset ? " (reset)" : ""}`);
-        // Scope filter: default = episodes only; --all = everything EXCEPT lessons.
-        // Lessons are owned by the reflection stage — they must never be
-        // reclassified here. (The prompt asks only for episode/fact/decision, so a
-        // lesson row in scope gets overwritten: the model never replies "lesson".
-        // The scope exclusion is therefore the real guard; parseTypeReply's
-        // "lesson" rejection is a backstop, not the primary defence.)
+        // Scope filter: default = experiences only; --all = everything EXCEPT
+        // learnings. Learnings are owned by the reflection stage — they must never
+        // be reclassified here. (The prompt asks only for experience/knowledge/
+        // decisions, so a learning row in scope gets overwritten: the model never
+        // replies "learnings". The scope exclusion is therefore the real guard;
+        // parseTypeReply's "learnings" rejection is a backstop, not the primary
+        // defence.)
         const scopeSql = all
-            ? "rowid > ? AND (memory_type IS NULL OR memory_type != 'lesson')"
-            : "rowid > ? AND memory_type = 'episode'";
+            ? "rowid > ? AND (memory_type IS NULL OR memory_type != 'learnings')"
+            : "rowid > ? AND memory_type = 'experience'";
         const batchStmt = db.prepare(`SELECT rowid AS __rowid, id, content, memory_type FROM memories
        WHERE ${scopeSql} ORDER BY rowid ASC LIMIT ?`);
         // Set true when the classifier returns null (infra error): finish the

package/dist/type-labels.d.ts

@@ -1,30 +1,61 @@
 /**
- * Human-term labels for the internal `memory_type` enum (#264 WS2).
+ * Human-term labels + normalization for the `memory_type` enum (#264 final).
  *
- * The data model stores four types under unintuitive internal names
- * (`fact` / `episode` / `decision` / `lesson`). Product-facing surfaces show
- * the human terms instead — Knowledge / Experience / Decisions / Learnings —
- * via this single label map. The enum values themselves are NEVER changed:
- * no DB column, query, distiller tag, or storage path is altered. This is a
- * DISPLAY rename only; every user-facing rendering routes through
- * `labelForType`.
+ * The DB column `memories.memory_type` stores the four CANONICAL human terms:
+ *   knowledge / experience / decisions / learnings
+ * These replaced the older raw internal enum (fact/episode/decision/lesson)
+ * via migration v13. Every SQL query, the distiller's type tag mapping, the
+ * type-classify prompt, and the CREATE TABLE default all use the new terms.
+ *
+ * Backward-compat window: the OLD raw values are still accepted on the
+ * request/agent wire (REST `/ingest` + `/update`, MCP tools, OC + Hermes
+ * plugin schemas) and normalized to the new canonical value before any DB
+ * write via {@link normalizeMemoryType}. The label map also still carries
+ * the old keys so a briefly-stale reader (e.g. a snapshot taken mid-migrate)
+ * renders correctly.
  *
  * Mapping (decided 2026-08-11, research/2026-08-11-identity-reframe-brainstorm.md):
- *   fact     → Knowledge
- *   episode  → Experience
- *   decision → Decisions
- *   lesson   → Learnings
+ *   fact     → knowledge
+ *   episode  → experience
+ *   decision → decisions
+ *   lesson   → learnings
  *
  * Unknown / future types fall back to the raw value (never silently remapped).
  */
 /**
- * The four documented memory types mapped to their human-term labels.
- * Kept as a plain record so it can be iterated for coverage assertions.
+ * The four canonical memory types mapped to their human-term labels, PLUS the
+ * legacy raw keys kept during the backward-compat window (old values may appear
+ * briefly in snapshots taken before migration v13, or in-flight requests from
+ * older clients). Kept as a plain record so it can be iterated for coverage
+ * assertions.
  */
 export declare const MEMORY_TYPE_LABELS: Record<string, string>;
 /**
- * Return the human-term label for a `memory_type` enum value. Unknown or
- * future types (including null/undefined) fall back to the raw input so new
- * types are visible rather than silently mislabeled.
+ * Return the human-term label for a `memory_type` value (canonical OR legacy).
+ * Unknown or future types (including null/undefined) fall back to the raw
+ * input so new types are visible rather than silently mislabeled.
  */
 export declare function labelForType(t: string | null | undefined): string;
+/**
+ * Normalize a `memory_type` input (from a request body, MCP tool arg, etc.)
+ * to the canonical value the DB stores (post-v13). Accepts the four legacy
+ * raw enum values (fact/episode/decision/lesson, mapped to the new terms) AND
+ * the four canonical human terms (passthrough). Unknown values pass through
+ * verbatim — the caller validates.
+ */
+export declare function normalizeMemoryType(input: string): string;
+/**
+ * The full accept-set for input validation: the four canonical values plus the
+ * four legacy raw values (kept for backward compat of older clients). Exposed
+ * so every validating surface (REST `/ingest`, `/update`, MCP zod enums, OC
+ * JSON-schema enums, the Hermes plugin) lists the SAME accepted values — no
+ * drift. Compare membership case-insensitively (caller normalizes via
+ * {@link normalizeMemoryType} before the DB write).
+ */
+export declare const ACCEPTED_MEMORY_TYPES: readonly string[];
+/**
+ * True if `input` is one of the accepted memory_type values (canonical OR
+ * legacy raw, any casing). Use this as the validation gate; follow with
+ * {@link normalizeMemoryType} to map the accepted value to the canonical term.
+ */
+export declare function isAcceptedMemoryType(input: string): boolean;