@gamaze/hicortex 0.18.0 → 0.18.2

package/dist/mcp-server.js

@@ -73,6 +73,7 @@ const recall_index_js_1 = require("./recall-index.js");
 const type_labels_js_1 = require("./type-labels.js");
 const health_js_1 = require("./health.js");
 const seed_lesson_js_1 = require("./seed-lesson.js");
+const learnings_identity_js_1 = require("./learnings-identity.js");
 const distiller_js_1 = require("./distiller.js");
 const dedup_js_1 = require("./dedup.js");
 const redact_js_1 = require("./redact.js");
@@ -182,10 +183,10 @@ function createMcpServer() {
         }
     });
     // -- hicortex_ingest --
-    server.tool("hicortex_ingest", "Store a new memory in long-term storage. Use for important facts, decisions, or lessons.", {
+    server.tool("hicortex_ingest", "Store a new memory in long-term storage. Use for Knowledge, Decisions, or Learnings.", {
         content: zod_1.z.string().describe("Memory content to store"),
         project: zod_1.z.string().optional().describe("Project this memory belongs to"),
-        memory_type: zod_1.z.enum(["episode", "lesson", "fact", "decision"]).optional().describe("Type of memory (default: episode)"),
+        memory_type: zod_1.z.enum(["knowledge", "experience", "decisions", "learnings", "fact", "episode", "decision", "lesson"]).optional().describe("Type of memory (default: Experience). Accepted: Knowledge/Experience/Decisions/Learnings (legacy raw enum also accepted, normalized to the canonical term)."),
     }, async ({ content, project, memory_type }) => {
         if (!db)
             return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
@@ -194,7 +195,8 @@ function createMcpServer() {
             const id = storage.insertMemory(db, content, embedding, {
                 sourceAgent: "claude-code/manual",
                 project,
-                memoryType: memory_type ?? "episode",
+                // Normalize legacy raw enum to the canonical term the DB stores.
+                memoryType: memory_type ? (0, type_labels_js_1.normalizeMemoryType)(memory_type) : "experience",
             });
             return { content: [{ type: "text", text: `Memory stored (id: ${id.slice(0, 8)})` }] };
         }
@@ -207,7 +209,7 @@ function createMcpServer() {
         id: zod_1.z.string().describe("Memory ID (from search results, first 8 chars or full UUID)"),
         content: zod_1.z.string().optional().describe("New content text"),
         project: zod_1.z.string().optional().describe("New project name"),
-        memory_type: zod_1.z.enum(["episode", "lesson", "fact", "decision"]).optional().describe("New memory type"),
+        memory_type: zod_1.z.enum(["knowledge", "experience", "decisions", "learnings", "fact", "episode", "decision", "lesson"]).optional().describe("New memory type. Accepted: Knowledge/Experience/Decisions/Learnings (legacy raw enum also accepted, normalized to the canonical term)."),
     }, async ({ id, content, project, memory_type }) => {
         if (!db)
             return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
@@ -221,8 +223,9 @@ function createMcpServer() {
                 fields.content = content;
             if (project !== undefined)
                 fields.project = project;
+            // Normalize legacy raw enum to canonical human terms before DB write.
             if (memory_type !== undefined)
-                fields.memory_type = memory_type;
+                fields.memory_type = (0, type_labels_js_1.normalizeMemoryType)(memory_type);
             if (Object.keys(fields).length === 0) {
                 return { content: [{ type: "text", text: "No fields to update" }], isError: true };
             }
@@ -260,23 +263,56 @@ function createMcpServer() {
             return { content: [{ type: "text", text: `Delete failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
-    // -- hicortex_lessons --
-    server.tool("hicortex_lessons", "Get actionable lessons learned from past sessions. Auto-generated insights about mistakes to avoid.", {
-        days: zod_1.z.coerce.number().optional().describe("Look back N days (default 7)"),
-        project: zod_1.z.string().optional().describe("Filter by project name"),
-    }, async ({ days, project }) => {
+    // -- hicortex_learnings (canonical) + hicortex_lessons (alias) --
+    const learningsHandler = async ({ days, project }) => {
         if (!db)
             return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
         try {
             const lessons = storage.getLessons(db, days ?? 7, project);
             if (lessons.length === 0) {
-                return { content: [{ type: "text", text: "No lessons found for the specified period." }] };
+                return { content: [{ type: "text", text: "No Learnings found for the specified period." }] };
             }
             const text = lessons.map((l) => `- ${l.content.slice(0, 500)}`).join("\n");
             return { content: [{ type: "text", text }] };
         }
         catch (err) {
-            return { content: [{ type: "text", text: `Lessons fetch failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+            return { content: [{ type: "text", text: `Learnings fetch failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    };
+    const learningsSchema = {
+        days: zod_1.z.coerce.number().optional().describe("Look back N days (default 7)"),
+        project: zod_1.z.string().optional().describe("Filter by project name"),
+    };
+    server.tool("hicortex_learnings", "Get actionable Learnings from past sessions. Auto-generated insights about mistakes to avoid.", learningsSchema, learningsHandler);
+    server.tool("hicortex_lessons", "Get actionable Learnings from past sessions. (Alias for hicortex_learnings.)", learningsSchema, learningsHandler);
+    // -- hicortex_identity --
+    // Standing identity layer on-demand (the same data GET /identity returns and
+    // the SessionStart hook injects). Lets an agent re-read its identity after
+    // context compaction, or look up one named section, mid-session. Renders the
+    // same `### <Title>` section markdown the hook injects (shared pipeline in
+    // learnings-identity.ts → buildIdentityToolResult) so the agent sees one
+    // consistent shape. The handler is a thin wrapper over that pure function;
+    // tests exercise it directly (no MCP SDK plumbing re-implemented).
+    server.tool("hicortex_identity", "Fetch your standing identity — the hand-edited 'who you are + how you work' layer (personality, rules, preferences). Returns all sections or a specific one. Use this to re-read your identity after context compaction or to look up a specific rule. On multi-agent installs, pass `agent` to fetch a specific agent's scoped identity; omit for the global identity.", {
+        name: zod_1.z.string().optional().describe("Fetch a specific identity section by name (e.g. 'rules'). Omit for all sections."),
+        agent: zod_1.z.string().optional().describe("Fetch a specific agent's identity scope (for per-agent installs). Omit for global."),
+    }, async ({ name, agent }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        try {
+            const identityDir = (0, node_path_1.join)(stateDir, "identity");
+            // Single pipeline shared with REST /identity + the SessionStart hook
+            // (#264 CRITICAL + WARNING-1 + WARNING-2). The pure function owns
+            // handleIdentityGet → injectMemorySection → renderIdentityBlock.
+            const result = (0, learnings_identity_js_1.buildIdentityToolResult)(identityDir, identityClients, identityAgents, {
+                name,
+                agent,
+                memoryInstructionsEnabled,
+            });
+            return { content: [{ type: "text", text: result.text }], isError: result.isError };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Identity fetch failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
         }
     });
     // -- hicortex_index --
@@ -285,7 +321,7 @@ function createMcpServer() {
         const moduleIndex = state.moduleIndex;
         if (moduleIndex && moduleIndex.domains.length > 0) {
             const text = moduleIndex.domains.map((d) => {
-                const head = `**${d.name}** (${d.memoryCount} memories, ${d.lessonCount} lessons)`;
+                const head = `**${d.name}** (${d.memoryCount} memories, ${d.lessonCount} Learnings)`;
                 // Content-based domains carry a description and no projects; legacy
                 // project-grouping domains carry a project list + keywords.
                 if (d.description && d.projects.length === 0) {
@@ -606,8 +642,11 @@ async function startServer(options = {}) {
             llmLabel: llmConfig ? `${llmConfig.provider}/${llmConfig.model}` : "not configured",
         }));
     });
-    // REST /lessons — return lessons + memory index for client CLAUDE.md injection
-    app.get("/lessons", (_req, res) => {
+    // REST /learnings (canonical, #264) + /lessons (alias) — return lessons +
+    // memory index for client CLAUDE.md injection. Both routes share ONE handler
+    // so the alias can never drift from the canonical shape. The legacy name is
+    // kept indefinitely (existing SessionStart hooks literally fetch /lessons).
+    const learningsIndexHandler = (_req, res) => {
         if (!db) {
             res.status(503).json({ error: "Server not initialized" });
             return;
@@ -639,9 +678,11 @@ async function startServer(options = {}) {
             });
         }
         catch (err) {
-            (0, health_js_1.logAndSendInternalError)(res, "lessons", err);
+            (0, health_js_1.logAndSendInternalError)(res, "learnings", err);
         }
-    });
+    };
+    app.get("/learnings", learningsIndexHandler);
+    app.get("/lessons", learningsIndexHandler); // #264 backcompat alias
     // REST /ingest — accept pre-distilled memories from remote clients
     app.post("/ingest", async (req, res) => {
         if (!db) {
@@ -653,11 +694,15 @@ async function startServer(options = {}) {
             res.status(400).json({ error: "Missing or invalid 'content' field" });
             return;
         }
-        const validTypes = ["episode", "lesson", "fact", "decision"];
+        const validTypes = type_labels_js_1.ACCEPTED_MEMORY_TYPES;
         if (memory_type && !validTypes.includes(memory_type)) {
             res.status(400).json({ error: `Invalid memory_type: ${memory_type}` });
             return;
         }
+        // Normalize legacy raw enum (fact/episode/decision/lesson) to the
+        // canonical term the DB stores (knowledge/experience/decisions/learnings).
+        // Canonical values pass through unchanged.
+        const normalizedType = memory_type ? (0, type_labels_js_1.normalizeMemoryType)(memory_type) : memory_type;
         // Dedup by source_session (idempotent — skip if already ingested)
         if (source_session) {
             const existing = db.prepare("SELECT COUNT(*) as cnt FROM memories WHERE source_session = ?").get(source_session);
@@ -675,7 +720,7 @@ async function startServer(options = {}) {
                 sourceDomain: typeof source_domain === "string" ? source_domain : null,
                 sourceSession: source_session ?? undefined,
                 project: project ?? undefined,
-                memoryType: memory_type ?? "episode",
+                memoryType: normalizedType ?? "experience",
                 // 0.16.x: privacy defaults to null (vestigial column). A legacy client
                 // that sends an explicit value is honored; absent → null.
                 privacy: typeof privacy === "string" ? privacy : null,
@@ -1022,9 +1067,9 @@ async function startServer(options = {}) {
                         sourceSession: sourcePrefix ? `${sourcePrefix}#${i}` : undefined,
                         project: project ?? undefined,
                         // #216: the distiller now classifies each entry as
-                        // episode/fact/decision via the [E]/[F]/[D] tag parsed in
+                        // experience/knowledge/decisions via the [E]/[K]/[D] tag parsed in
                         // distiller.ts. Pre-#216 distiller output (no tag) defaults to
-                        // episode in the parser, so this is backward compatible.
+                        // experience in the parser, so this is backward compatible.
                         memoryType,
                         // 0.16.x: privacy defaults to null (vestigial column). A legacy
                         // client that sends an explicit value is honored; absent → null.
@@ -1072,19 +1117,24 @@ async function startServer(options = {}) {
             fields.content = content;
         if (project !== undefined)
             fields.project = project;
-        if (memory_type !== undefined)
-            fields.memory_type = memory_type;
         if (privacy !== undefined)
             fields.privacy = privacy;
-        if (Object.keys(fields).length === 0) {
-            res.status(400).json({ error: "No fields to update" });
-            return;
-        }
-        const validTypes = ["episode", "lesson", "fact", "decision"];
+        // Validate + normalize memory_type BEFORE adding to `fields` so the
+        // empty-fields check below correctly counts a memory_type-only update.
+        const validTypes = type_labels_js_1.ACCEPTED_MEMORY_TYPES;
         if (memory_type !== undefined && !validTypes.includes(memory_type)) {
             res.status(400).json({ error: `Invalid memory_type: ${memory_type}` });
             return;
         }
+        // Normalize legacy raw enum (fact/episode/decision/lesson) to the
+        // canonical term the DB stores (knowledge/experience/decisions/learnings).
+        // Canonical values pass through unchanged.
+        if (memory_type !== undefined)
+            fields.memory_type = (0, type_labels_js_1.normalizeMemoryType)(memory_type);
+        if (Object.keys(fields).length === 0) {
+            res.status(400).json({ error: "No fields to update" });
+            return;
+        }
         try {
             storage.updateMemory(db, fullId, fields);
             // Re-embed when content changes

package/dist/prompts.js

@@ -48,7 +48,7 @@ function reflection(memoriesBlock, recentLessons) {
 Like human learning: we grow fastest when we reinforce what works AND correct what doesn't. A system that only learns from mistakes becomes overly cautious. A system that only learns from successes never improves. The combination multiplies.
 
 GENERALITY BAR (read carefully — the most important rule):
-Every lesson MUST be a generalizable operating principle that transfers across contexts, agents, and projects. It is NOT: an incident report, a changelog entry, a one-event fact, a tool-specific recipe, or a note about a named entity. If a memory is only interesting as "what happened today", it is an EPISODE — do not emit a lesson for it. Abstract away specific tool names, hostnames, and incident details from the lesson text; state the transferable rule.
+Every lesson MUST be a generalizable operating principle that transfers across contexts, agents, and projects. It is NOT: an incident report, a changelog entry, a one-event fact, a tool-specific recipe, or a note about a named entity. If a memory is only interesting as "what happened today", it is an EXPERIENCE — do not emit a lesson for it. Abstract away specific tool names, hostnames, and incident details from the lesson text; state the transferable rule.
 
 Quality over quantity. 1-3 lessons is typical. An empty array [] is the CORRECT response when memories show routine competent work without noteworthy patterns, surprises, or friction. Do not manufacture lessons from nothing.
 
@@ -121,8 +121,8 @@ EXTRACT into this markdown format:
 ### Decisions Made
 - [D] [SUBJECT]: [decision] — [reasoning] (${date})
 
-### Facts Learned
-- [F] [SUBJECT]: [fact] — [context/source] (${date})
+### Knowledge Learned
+- [K] [SUBJECT]: [knowledge] — [context/source] (${date})
 
 ### Problems & Solutions
 - [E] [SUBJECT]: [problem] → [solution that worked] (${date})
@@ -131,7 +131,7 @@ EXTRACT into this markdown format:
 - [D] [SUBJECT]: [what changed], [from → to] (${date})
 
 ### Key Entities & Relationships
-- [F] [entity A] → [relationship] → [entity B] (${date})
+- [K] [entity A] → [relationship] → [entity B] (${date})
 
 ### Corrections & Rejections
 - [E] [SUBJECT]: [what AI proposed] → [why rejected/corrected] → [what user wanted instead] (${date})
@@ -139,18 +139,18 @@ EXTRACT into this markdown format:
    user corrections of AI assumptions, quality complaints like "too verbose")
 
 TYPE TAG (critical — prefix EVERY bullet with exactly one letter + space):
-- [E] EPISODE — a specific event, interaction, or narrative: "tried X, failed
+- [E] EXPERIENCE — a specific event, interaction, or narrative: "tried X, failed
   because Y", a correction, a debugging session, a one-time occurrence. The
   DEFAULT when in doubt.
-- [F] FACT — a durable truth that will hold across sessions: "the API is at
+- [K] KNOWLEDGE — a durable truth that will hold across sessions: "the API is at
   :8787", "uv is used for packages", "config lives in ~/.hicortex/". Not tied
   to a single moment.
-- [D] DECISION — a choice made that future work builds on, and that a later
+- [D] DECISIONS — a choice made that future work builds on, and that 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
+  graded-schema tag model". Not knowledge (it can change) and not experience
   (it persists and constrains).
-- NEVER use [L] (lesson). Lessons are extracted by a SEPARATE reflection stage,
-  not here. If the model emits [L], it is wrong — re-tag as episode/fact/decision.
+- NEVER use [L] (learnings). Learnings are extracted by a SEPARATE reflection stage,
+  not here. If the model emits [L], it is wrong — re-tag as experience/knowledge/decisions.
 The type tag goes BEFORE the subject, never as a section/category bracket.
 
 TOPIC-FIRST RULE (critical — read carefully):
@@ -159,8 +159,8 @@ concrete thing it is about — the system, file, component, decision area, or
 entity. The subject is what a future reader would search for.
 - Write:  "[E] Electrical load calculation: don't bundle unknown loads into one figure — user rejected the estimate"
 - NOT:    "[E] User rejected AI's bundling of unknown loads"
-- Write:  "[F] Nightly capture (Hermes): cron sessions are excluded — source='cron' is skipped before distillation"
-- NOT:    "[F] Discovered that cron sessions are filtered out"
+- Write:  "[K] Nightly capture (Hermes): cron sessions are excluded — source='cron' is skipped before distillation"
+- NOT:    "[K] Discovered that cron sessions are filtered out"
 Reason: each item's first words (after the type tag) become the memory's one-line
 index entry AND dominate its search embedding. An item that opens with a category
 label, a sentiment ("Strong Negative"), or "User rejected…" is unfindable — it

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>;
 /**