@gamaze/hicortex 0.18.0 → 0.18.2

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;

package/dist/type-labels.js

@@ -1,43 +1,114 @@
 "use strict";
 /**
- * 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).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMORY_TYPE_LABELS = void 0;
+exports.ACCEPTED_MEMORY_TYPES = exports.MEMORY_TYPE_LABELS = void 0;
 exports.labelForType = labelForType;
+exports.normalizeMemoryType = normalizeMemoryType;
+exports.isAcceptedMemoryType = isAcceptedMemoryType;
 /**
- * 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.
  */
 exports.MEMORY_TYPE_LABELS = {
+    // Canonical (post-v13) values.
+    knowledge: "Knowledge",
+    experience: "Experience",
+    decisions: "Decisions",
+    learnings: "Learnings",
+    // Legacy raw enum (kept so stale readers render correctly during the
+    // migration window). Same labels — these are the SAME types, renamed.
     fact: "Knowledge",
     episode: "Experience",
     decision: "Decisions",
     lesson: "Learnings",
 };
 /**
- * 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.
  */
 function labelForType(t) {
     if (!t)
         return "—";
     return exports.MEMORY_TYPE_LABELS[t] ?? t;
 }
+/**
+ * Map BOTH legacy raw enum values AND canonical human terms TO the canonical
+ * value stored in the DB (post-v13). Used to normalize request input
+ * (`/ingest`, `/update`, MCP tools) so the wire/agent surface accepts the old
+ * vocabulary while the storage layer always sees the canonical term.
+ * Unknown inputs pass through untouched so the caller's own validation can
+ * reject them with a precise error (this helper never silently remaps).
+ *
+ * Lookup is case-insensitive on the input (the human terms are documented in
+ * Titlecase but agents/users send any casing); the four canonical values and
+ * the four legacy raw values are all lowercase in the DB.
+ */
+const TO_CANONICAL = {
+    // Legacy raw → canonical.
+    fact: "knowledge",
+    episode: "experience",
+    decision: "decisions",
+    lesson: "learnings",
+    // Canonical passthrough (also covered case-insensitively).
+    knowledge: "knowledge",
+    experience: "experience",
+    decisions: "decisions",
+    learnings: "learnings",
+};
+/**
+ * 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.
+ */
+function normalizeMemoryType(input) {
+    return TO_CANONICAL[input.toLowerCase()] ?? input;
+}
+/**
+ * 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).
+ */
+exports.ACCEPTED_MEMORY_TYPES = Object.freeze([
+    "knowledge", "experience", "decisions", "learnings",
+    "fact", "episode", "decision", "lesson",
+]);
+/**
+ * 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.
+ */
+function isAcceptedMemoryType(input) {
+    return exports.ACCEPTED_MEMORY_TYPES.includes(input.toLowerCase());
+}

package/dist/types.d.ts

@@ -30,7 +30,7 @@ export interface Memory {
      */
     source_domain: string | null;
     privacy: ("PUBLIC" | "WORK" | "PERSONAL" | "SENSITIVE") | null;
-    memory_type: "episode" | "lesson" | "fact" | "decision";
+    memory_type: "experience" | "learnings" | "knowledge" | "decisions";
     updated_at: string | null;
 }
 /** A link between two memories. */

package/hermes-plugin/hicortex/client.py

@@ -169,7 +169,7 @@ class HicortexClient:
         content: str,
         source_agent: Optional[str] = None,
         project: Optional[str] = None,
-        memory_type: str = "episode",
+        memory_type: str = "experience",
         privacy: str = "WORK",
     ) -> tuple[int, dict[str, Any]]:
         return self._post(

package/hermes-plugin/hicortex/provider.py

@@ -132,7 +132,7 @@ def _order_section_names(names: Iterable[str]) -> List[str]:
 
 
 def _render_context_block(sections: Dict[str, Any]) -> str:
-    """Render the ``## Context`` block, or "" when every section is blank."""
+    """Render the ``## Identity`` block, or "" when every section is blank."""
     body_parts: List[str] = []
     for name in _order_section_names(sections.keys()):
         body = sections.get(name)
@@ -141,7 +141,7 @@ def _render_context_block(sections: Dict[str, Any]) -> str:
         body_parts.extend([f"### {_title_case_section(name)}", "", body.strip()])
     if not body_parts:
         return ""
-    return "\n".join(["## Context", "", *body_parts])
+    return "\n".join(["## Identity", "", *body_parts])
 
 
 class HicortexProvider(MemoryProvider):
@@ -397,7 +397,7 @@ class HicortexProvider(MemoryProvider):
         return "\n\n".join(b for b in blocks if b)
 
     def _context_block(self, client: HicortexClient) -> str:
-        """Fetch the standing context layer and render a ``## Context`` block,
+        """Fetch the standing context layer and render a ``## Identity`` block,
         or "" when nothing should be injected. Gates (ALL): "hermes" in the
         server-resolved ``clients``; when an agent id was SENT, the response
         echoes ``agent`` (old-server guard — a pre-0.13 server ignores ?agent=
@@ -444,7 +444,7 @@ class HicortexProvider(MemoryProvider):
             "the recall index), and `hicortex_recent` for recent memories by project.",
         ]
         if lessons:
-            lines.append("Lessons:")
+            lines.append("Learnings:")
             for l in lessons:
                 c = (l.get("content") or "").strip().replace("\n", " ")
                 # Legacy lessons were stored with a "## Lesson:" prefix; new ones are
@@ -455,7 +455,7 @@ class HicortexProvider(MemoryProvider):
                 lines.append(f"- {c[:200]}")
         if idx.get("total"):
             lines.append(
-                f"({idx.get('total')} memories, {idx.get('lessonCount')} lessons "
+                f"({idx.get('total')} memories, {idx.get('lessonCount')} learnings "
                 f"across {idx.get('sourceCount')} agents)"
             )
         return "\n".join(lines)
@@ -523,7 +523,7 @@ class HicortexProvider(MemoryProvider):
                 "name": "hicortex_ingest",
                 "description": (
                     "Store a new memory in long-term storage. "
-                    "Use for important facts, decisions, or lessons."
+                    "Use for Knowledge, Decisions, or Learnings."
                 ),
                 "parameters": {
                     "type": "object",
@@ -532,8 +532,8 @@ class HicortexProvider(MemoryProvider):
                         "project": {"type": "string", "description": "Project this memory belongs to"},
                         "memory_type": {
                             "type": "string",
-                            "enum": ["episode", "lesson", "fact", "decision"],
-                            "description": "Type of memory (default: episode)",
+                            "enum": ["knowledge", "experience", "decisions", "learnings", "fact", "episode", "decision", "lesson"],
+                            "description": "Type of memory (default: experience). Accepted: Knowledge/Experience/Decisions/Learnings (legacy raw enum also accepted, normalized server-side).",
                         },
                     },
                     "required": ["content"],
@@ -542,7 +542,7 @@ class HicortexProvider(MemoryProvider):
             {
                 "name": "hicortex_lessons",
                 "description": (
-                    "Get actionable lessons learned from past sessions. "
+                    "Get actionable Learnings distilled from past sessions. "
                     "Auto-generated insights about mistakes to avoid."
                 ),
                 "parameters": {
@@ -603,8 +603,8 @@ class HicortexProvider(MemoryProvider):
                         "project": {"type": "string", "description": "New project name"},
                         "memory_type": {
                             "type": "string",
-                            "enum": ["episode", "lesson", "fact", "decision"],
-                            "description": "New memory type",
+                            "enum": ["knowledge", "experience", "decisions", "learnings", "fact", "episode", "decision", "lesson"],
+                            "description": "New memory type. Accepted: Knowledge/Experience/Decisions/Learnings (legacy raw enum also accepted, normalized server-side).",
                         },
                     },
                     "required": ["id"],
@@ -677,7 +677,7 @@ class HicortexProvider(MemoryProvider):
                     content=content,
                     source_agent="hermes/manual",
                     project=args.get("project") or self._project,
-                    memory_type=args.get("memory_type", "episode"),
+                    memory_type=args.get("memory_type", "experience"),
                 )
                 if status not in (200, 201):
                     return json.dumps({"error": resp.get("error", f"HTTP {status}")})
@@ -688,7 +688,7 @@ class HicortexProvider(MemoryProvider):
                 data = client.lessons()
                 lessons = (data.get("lessons") or [])
                 if not lessons:
-                    return json.dumps({"message": "No lessons found."})
+                    return json.dumps({"message": "No Learnings found."})
                 return json.dumps([{"content": l.get("content", "")[:500]} for l in lessons])
 
             elif tool_name == "hicortex_index":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "Persistent agent identity for AI agents — a hand-edited identity layer, nightly-distilled experience, and lessons injected every session, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, and Pi.",
   "main": "dist/index.js",
   "bin": {