npm - @gamaze/hicortex - Versions diffs - 0.17.2 → 0.17.4 - Mend

@gamaze/hicortex 0.17.2 → 0.17.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/assets/context.html +68 -2
package/assets/dashboard.html +50 -0
package/assets/viz.html +35 -4
package/dist/cli.js +30 -0
package/dist/distiller.d.ts +13 -1
package/dist/distiller.js +56 -12
package/dist/mcp-server.js +19 -5
package/dist/prompts.js +33 -18
package/dist/state.d.ts +7 -0
package/dist/type-classify.d.ts +96 -0
package/dist/type-classify.js +277 -0
package/hermes-plugin/hicortex/config.py +34 -3
package/hermes-plugin/hicortex/provider.py +17 -0
package/package.json +1 -1

package/assets/context.html CHANGED Viewed

@@ -34,6 +34,7 @@
     --danger: #c0392b;
     --ok: #2f8f4e;
     --tab-active: #ffffff;
+    --nav-bg: #f6f7f9;
   }
   @media (prefers-color-scheme: dark) {
     :root {
@@ -47,6 +48,7 @@
       --danger: #e05555;
       --ok: #5fbf77;
       --tab-active: #0f1117;
+      --nav-bg: #010409;
     }
   }
   /* Explicit theme override wins over the media default in BOTH directions. */
@@ -54,11 +56,13 @@
     --bg: #ffffff; --panel: #f6f7f9; --panel-border: #d9dce2;
     --text: #1c1f26; --text-dim: #656d7a; --accent: #2f6fb0;
     --accent-text: #ffffff; --danger: #c0392b; --ok: #2f8f4e; --tab-active: #ffffff;
+    --nav-bg: #f6f7f9;
   }
   :root[data-theme="dark"] {
     --bg: #0f1117; --panel: #161a23; --panel-border: #262c3a;
     --text: #d5dae4; --text-dim: #8b93a5; --accent: #5b9dd9;
     --accent-text: #0b0d12; --danger: #e05555; --ok: #5fbf77; --tab-active: #0f1117;
+    --nav-bg: #010409;
   }
   * { box-sizing: border-box; margin: 0; padding: 0; }
@@ -165,9 +169,33 @@
     padding: 8px; font: inherit; margin-bottom: 10px;
   }
   #token-err { color: var(--danger); font-size: 13px; margin-top: 8px; display: none; }
+  /* ---- shared console nav (#249) ---- */
+  .hc-nav {
+    display: flex; align-items: center; gap: 16px;
+    height: 48px; padding: 0 18px; flex: none;
+    background: var(--nav-bg);
+    border-bottom: 1px solid var(--panel-border);
+    font-size: 14px;
+  }
+  .hc-nav-logo { color: var(--text); font-weight: 600; text-decoration: none; letter-spacing: 0.02em; }
+  .hc-nav-links { margin-left: auto; display: flex; align-items: center; gap: 16px; }
+  .hc-nav-links a { color: var(--text-dim); text-decoration: none; transition: color 0.12s; }
+  .hc-nav-links a:hover { color: var(--accent); }
+  .hc-nav-links a[data-nav-active] { color: var(--text); }
+  .hc-nav-disabled { color: var(--text-dim); opacity: 0.4; cursor: not-allowed; user-select: none; }
 </style>
 </head>
 <body>
+<nav class="hc-nav">
+  <a class="hc-nav-logo" href="/dashboard">Hicortex</a>
+  <div class="hc-nav-links">
+    <a href="/dashboard">Dashboard</a>
+    <a href="/viz">Graph</a>
+    <a href="/context/ui" data-nav-active>Context</a>
+    <span class="hc-nav-disabled" title="Coming soon — #250">Self-improvement</span>
+  </div>
+</nav>
 <header>
   <h1>Hicortex — context</h1>
   <label class="meta" for="scope">scope</label>
@@ -181,6 +209,11 @@
 </header>
 <main>
+  <p class="hint" style="margin:0 0 12px;color:var(--text-dim);font-size:13px;line-height:1.6">
+    <strong>User</strong> — who you are (persona, preferences). &nbsp;
+    <strong>Rules</strong> — how to work (operating principles, values). &nbsp;
+    <strong>Memory instructions</strong> — how to use Hicortex (product-managed, read-only).
+  </p>
   <div id="tabs">
     <div id="addwrap">
       <input type="text" id="addname" placeholder="new-section-name" autocomplete="off" spellcheck="false">
@@ -249,6 +282,22 @@
     }
   })();
+  // Shared console nav (#249): append ?token= to internal nav links on click
+  // so navigation between pages doesn't re-authenticate. Reads token from any
+  // page-scoped localStorage key (each page historically used its own).
+  document.querySelectorAll(".hc-nav-links a, .hc-nav-logo").forEach(function (a) {
+    a.addEventListener("click", function (e) {
+      var t = token
+        || localStorage.getItem("hicortexToken")
+        || localStorage.getItem("hicortex-dashboard-token");
+      if (!t) return;
+      e.preventDefault();
+      var u = new URL(a.getAttribute("href"), location.origin);
+      u.searchParams.set("token", t);
+      location.href = u.toString();
+    });
+  });
   function authHeaders(extra) {
     var h = extra ? Object.assign({}, extra) : {};
     if (token) h["Authorization"] = "Bearer " + token;
@@ -283,6 +332,17 @@
   var sections = {};        // name -> { saved: string, draft: string, isNew: bool }
   var order = [];           // tab order (section names)
   var active = null;        // active section name
+  // Display labels for known sections (the API key stays lowercase; the UI
+  // shows a friendlier name). Unknown sections display their raw name.
+  var DISPLAY_LABELS = {
+    "user": "User",
+    "rules": "Rules",
+    "memory": "Memory instructions",
+  };
+  // Preferred tab order — known sections first in this order, then any custom
+  // sections alphabetically.
+  var TAB_PRIORITY = ["user", "rules", "memory"];
   var afterAuth = null;     // action to retry after a successful token prompt
   // Per-agent scope (0.13). scope = null → the global set; otherwise an agent
@@ -325,7 +385,7 @@
       var inherited = scope && origins[name] === "global";
       b.className = "tab" + (name === active ? " active" : "") + (inherited ? " inherited" : "");
       b.type = "button";
-      b.appendChild(document.createTextNode(name));
+      b.appendChild(document.createTextNode(DISPLAY_LABELS[name] || name));
       if (inherited) {
         var inh = document.createElement("span");
         inh.className = "inh";
@@ -409,7 +469,13 @@
         if (scope === null && data.agents && typeof data.agents === "object") agents = data.agents;
         origins = (data.origins && typeof data.origins === "object") ? data.origins : {};
         var incoming = data.sections || {};
-        var names = Object.keys(incoming).sort();
+        var names = Object.keys(incoming).sort(function (a, b) {
+          var ai = TAB_PRIORITY.indexOf(a), bi = TAB_PRIORITY.indexOf(b);
+          if (ai >= 0 && bi >= 0) return ai - bi;
+          if (ai >= 0) return -1;
+          if (bi >= 0) return 1;
+          return a.localeCompare(b);
+        });
         sections = {};
         order = [];
         names.forEach(function (n) {

package/assets/dashboard.html CHANGED Viewed

@@ -41,6 +41,7 @@
       --accent-2: #2f8f4e;
       --warn: #b08030;
       --danger: #c0392b;
+      --nav-bg: #f6f7f9;
     }
   }
   * { box-sizing: border-box; margin: 0; padding: 0; }
@@ -89,9 +90,42 @@
   table.digest td.k { color: var(--text-dim); width: 180px; }
   .stage-pill { display: inline-block; padding: 1px 6px; border-radius: 10px; background: rgba(128,128,128,0.18); font-size: 11px; color: var(--text-dim); margin-right: 4px; }
   .empty { color: var(--text-dim); font-style: italic; padding: 12px 0; }
+  /* ---- shared console nav (#249) ---- */
+  .hc-nav {
+    position: sticky; top: 0; z-index: 50;
+    display: flex; align-items: center; gap: 16px;
+    height: 48px; padding: 0 20px;
+    margin: -20px -20px 20px;
+    background: var(--nav-bg, #010409);
+    border-bottom: 1px solid var(--panel-border);
+    font-size: 14px;
+  }
+  .hc-nav-logo {
+    color: var(--text); font-weight: 600; text-decoration: none;
+    letter-spacing: 0.02em;
+  }
+  .hc-nav-links { margin-left: auto; display: flex; align-items: center; gap: 16px; }
+  .hc-nav-links a {
+    color: var(--text-dim); text-decoration: none; transition: color 0.12s;
+  }
+  .hc-nav-links a:hover { color: var(--accent); }
+  .hc-nav-links a[data-nav-active] { color: var(--text); }
+  .hc-nav-disabled {
+    color: var(--text-dim); opacity: 0.4; cursor: not-allowed; user-select: none;
+  }
 </style>
 </head>
 <body>
+<nav class="hc-nav">
+  <a class="hc-nav-logo" href="/dashboard">Hicortex</a>
+  <div class="hc-nav-links">
+    <a href="/dashboard" data-nav-active>Dashboard</a>
+    <a href="/viz">Graph</a>
+    <a href="/context/ui">Context</a>
+    <span class="hc-nav-disabled" title="Coming soon — #250">Self-improvement</span>
+  </div>
+</nav>
 <h1>Hicortex — memory dashboard</h1>
 <div class="sub">View-only analytics. All metrics derived from the live corpus + nightly snapshots.</div>
@@ -506,6 +540,22 @@ async function load() {
 }
 document.addEventListener("DOMContentLoaded", () => {
+  // Shared console nav (#249): append ?token= to internal nav links on click
+  // so navigation between pages doesn't re-authenticate. Reads the token from
+  // any of the page-scoped localStorage keys (each page historically used its
+  // own key) — keeps the snippet identical across the three served pages.
+  document.querySelectorAll(".hc-nav-links a, .hc-nav-logo").forEach(function (a) {
+    a.addEventListener("click", function (e) {
+      var t = token
+        || localStorage.getItem("hicortexToken")
+        || localStorage.getItem("hicortex-dashboard-token");
+      if (!t) return;
+      e.preventDefault();
+      var u = new URL(a.getAttribute("href"), location.origin);
+      u.searchParams.set("token", t);
+      location.href = u.toString();
+    });
+  });
   // Seed the date picker to the digest date from the first load (today).
   $("reload").addEventListener("click", load);
   $("range").addEventListener("change", load);

package/assets/viz.html CHANGED Viewed

@@ -55,17 +55,26 @@
   #topbar {
     position: fixed; top: 0; left: 0; right: 0;
     display: flex; align-items: center; gap: 10px;
-    padding: 8px 12px;
+    height: 48px;
+    padding: 0 12px;
     background: rgba(22, 26, 35, 0.94);
     border-bottom: 1px solid var(--panel-border);
     z-index: 10;
   }
   #topbar h1 { font-size: 14px; font-weight: 600; white-space: nowrap; }
-  #meta { color: var(--text-dim); margin-left: auto; white-space: nowrap; }
+  #meta { color: var(--text-dim); white-space: nowrap; margin-left: auto; }
+  /* ---- shared console nav links (#249), integrated into the viz topbar ---- */
+  .hc-nav-logo { color: var(--text); text-decoration: none; letter-spacing: 0.02em; }
+  .hc-nav-links { margin-left: 16px; display: flex; align-items: center; gap: 16px; font-size: 14px; }
+  .hc-nav-links a { color: var(--text-dim); text-decoration: none; transition: color 0.12s; }
+  .hc-nav-links a:hover { color: var(--accent); }
+  .hc-nav-links a[data-nav-active] { color: var(--text); }
+  .hc-nav-disabled { color: var(--text-dim); opacity: 0.4; cursor: not-allowed; user-select: none; }
   /* ---- left control panel ---- */
   #panel {
-    position: fixed; top: 46px; left: 12px; width: 236px;
+    position: fixed; top: 48px; left: 12px; width: 236px;
     background: rgba(22, 26, 35, 0.94);
     border: 1px solid var(--panel-border); border-radius: 8px;
     padding: 12px; z-index: 10;
@@ -235,8 +244,14 @@
 <div id="graph-2d"></div>
 <div id="topbar">
-  <h1>Hicortex — knowledge graph</h1>
+  <h1 class="hc-nav-logo"><a href="/dashboard" style="color:inherit;text-decoration:none">Hicortex</a></h1>
   <span id="meta"></span>
+  <nav class="hc-nav-links">
+    <a href="/dashboard">Dashboard</a>
+    <a href="/viz" data-nav-active>Graph</a>
+    <a href="/context/ui">Context</a>
+    <span class="hc-nav-disabled" title="Coming soon — #250">Self-improvement</span>
+  </nav>
 </div>
 <div id="panel">
@@ -343,6 +358,22 @@
     }
   })();
+  // Shared console nav (#249): append ?token= to internal nav links on click
+  // so navigation between pages doesn't re-authenticate. Reads token from any
+  // page-scoped localStorage key (each page historically used its own).
+  document.querySelectorAll(".hc-nav-links a, .hc-nav-logo").forEach(function (a) {
+    a.addEventListener("click", function (e) {
+      var t = token
+        || localStorage.getItem("hicortexToken")
+        || localStorage.getItem("hicortex-dashboard-token");
+      if (!t) return;
+      e.preventDefault();
+      var u = new URL(a.getAttribute("href"), location.origin);
+      u.searchParams.set("token", t);
+      location.href = u.toString();
+    });
+  });
   // =========================================================================
   // DOM references
   // =========================================================================

package/dist/cli.js CHANGED Viewed

@@ -158,6 +158,32 @@ switch (command) {
         });
         break;
     }
+    case "classify-types": {
+        const args = process.argv.slice(3);
+        const intFlag = (name) => {
+            const idx = args.indexOf(name);
+            if (idx === -1)
+                return undefined;
+            const val = parseInt(args[idx + 1], 10);
+            if (isNaN(val)) {
+                console.error(`[hicortex] classify-types: ${name} requires an integer value`);
+                process.exit(1);
+            }
+            return val;
+        };
+        const classifyTypeOptions = {
+            all: args.includes("--all"),
+            reset: args.includes("--reset"),
+            batchSize: intFlag("--batch"),
+        };
+        import("./type-classify.js").then(({ runClassifyTypes }) => {
+            runClassifyTypes(classifyTypeOptions).catch((err) => {
+                console.error(err instanceof Error ? err.message : `[hicortex] classify-types failed: ${err}`);
+                process.exit(1);
+            });
+        });
+        break;
+    }
     case "dedup": {
         const args = process.argv.slice(3);
         let threshold;
@@ -279,6 +305,7 @@ Commands:
   relink          Resumable link-discovery pass over the ENTIRE corpus (server mode)
   dedup           Cluster + merge near-duplicate memories (server mode; dry run by default)
   classify-domains  Backfill content-based domain tags over the corpus (server mode, needs config.domains)
+  classify-types    Backfill episode→fact/decision type tags over the corpus (server mode)
   lessons-context Fetch lessons and print Markdown to stdout (CC SessionStart hook)
   recall-hook    Pushed recall index for the current prompt (CC UserPromptSubmit/SessionStart hook)
   context         Standing context layer (show|edit) against the configured server
@@ -303,6 +330,9 @@ Options:
   classify-domains --all    Reclassify every memory (default: only NULL/stale-domain rows)
   classify-domains --batch <n>  Memories per batch (default: 200)
   classify-domains --reset  Restart from the beginning (ignore saved cursor)
+  classify-types --all      Reclassify every memory (default: only episodes)
+  classify-types --batch <n>  Memories per batch (default: 200)
+  classify-types --reset    Restart from the beginning (ignore saved cursor)
   context show [name]       Print all context sections, or just <name> (raw, pipeable)
   context edit <name>       Edit a section in $EDITOR; PUT only if changed
   context … --agent <id>    Target a per-agent scope instead of the global set

package/dist/distiller.d.ts CHANGED Viewed

@@ -39,7 +39,7 @@ export declare function extractConversationText(messages: unknown[], redactionCo
  * discarded (full text). Callers use it to build a durable audit trail (#156);
  * omitting it leaves gate behaviour unchanged.
  */
-export declare function distillSession(llm: LlmClient, conversation: string, projectName: string, date: string, chunkSizeChars?: number, droppedOut?: string[]): Promise<string[]>;
+export declare function distillSession(llm: LlmClient, conversation: string, projectName: string, date: string, chunkSizeChars?: number, droppedOut?: string[]): Promise<DistilledEntry[]>;
 /**
  * Reject ONLY structurally-empty distiller fragments before they become
  * memories (#156). The distiller occasionally emits leftovers that parse into
@@ -62,3 +62,15 @@ export declare function distillSession(llm: LlmClient, conversation: string, pro
  * survive. Stripping affects only this gate's decision, never stored text.
  */
 export declare function hasMinimalSubstance(entry: string): boolean;
+/**
+ * A parsed distillation entry: the stored content (type tag STRIPPED) plus the
+ * classified memory_type. `memoryType` is one of "episode" | "fact" |
+ * "decision" — the three distillation-time types. "lesson" is deliberately
+ * absent: lessons are the reflection stage's product, never distillation's
+ * (#216). A missing/unknown tag defaults to "episode" so older distiller
+ * output (pre-#216, no tag) stays backward-compatible.
+ */
+export interface DistilledEntry {
+    content: string;
+    memoryType: "episode" | "fact" | "decision";
+}

package/dist/distiller.js CHANGED Viewed

@@ -265,8 +265,10 @@ async function distillSession(llm, conversation, projectName, date, chunkSizeCha
             if (droppedOut)
                 droppedOut.push(...dropped);
             for (const entry of entries) {
-                // Deduplicate by normalized content
-                const key = entry.toLowerCase().replace(/\s+/g, " ").slice(0, 100);
+                // Deduplicate by normalized content (type tag does not participate —
+                // two chunks extracting the same fact should collapse regardless of
+                // whether one tagged it [F] and the other [E]).
+                const key = entry.content.toLowerCase().replace(/\s+/g, " ").slice(0, 100);
                 if (!seen.has(key)) {
                     seen.add(key);
                     allEntries.push(entry);
@@ -323,14 +325,21 @@ async function distillChunk(llm, transcript, projectName, date) {
     // sometimes ignore constraints (cf. the prior max-15-bullet failure). Count
     // entries that still look actor-led or bracket-led so a format regression
     // shows in nightly logs, not months later in the next eval. Non-blocking.
-    const offTopic = parsed.filter((e) => /^\s*(user|ai|the user|assistant)\b/i.test(e) || /^\s*\[/.test(e)).length;
+    // Note: the type tag ([E]/[F]/[D]) is already stripped by the parser, so a
+    // leading bracket here means a payload-bracket or a category-first regression.
+    const offTopic = parsed.filter((e) => /^\s*(user|ai|the user|assistant)\b/i.test(e.content) || /^\s*\[/.test(e.content)).length;
     if (parsed.length > 0 && offTopic > 0) {
         console.log(`[hicortex]     topic-first check: ${offTopic}/${parsed.length} entries look actor/bracket-led (prompt may be ignored)`);
     }
     const entries = [];
     const dropped = [];
     for (const entry of parsed) {
-        (hasMinimalSubstance(entry) ? entries : dropped).push(entry);
+        if (hasMinimalSubstance(entry.content)) {
+            entries.push(entry);
+        }
+        else {
+            dropped.push(entry.content);
+        }
     }
     if (dropped.length > 0) {
         for (const d of dropped) {
@@ -416,8 +425,31 @@ function hasMinimalSubstance(entry) {
     return true;
 }
 /**
- * Parse distilled markdown into individual memory entry strings.
- * Each section item becomes a separate memory.
+ * Map a single-letter type tag to the stored memory_type. Unknown/absent →
+ * episode (the pre-#216 default). `[L]` is explicitly rejected → episode: the
+ * distiller must NEVER emit lessons (that's the reflection stage's job), so a
+ * model that emits `[L]` is wrong and we do not propagate it as a lesson.
+ */
+function typeFromTag(letter) {
+    switch (letter) {
+        case "F":
+        case "f":
+            return "fact";
+        case "D":
+        case "d":
+            return "decision";
+        // E, e, L, l (rejected), undefined, or anything else → episode.
+        default:
+            return "episode";
+    }
+}
+/**
+ * Parse distilled markdown into individual memory entries with type tags.
+ * Each bullet becomes a separate memory. The leading `[E]`/`[F]`/`[D]` type
+ * tag is extracted (→ memoryType), stripped from the stored content, and
+ * passed to `insertMemory` via the `memoryType` option (#216). Bullets with
+ * no tag default to "episode" (backward compatible with pre-#216 distiller
+ * output that never carried a tag).
  */
 function parseDistilledEntries(markdown) {
     const entries = [];
@@ -425,11 +457,10 @@ function parseDistilledEntries(markdown) {
     for (const line of lines) {
         const trimmed = line.trim();
         // Skip all markdown headers (session title, section headings). Sections
-        // are NOT prefixed onto entries: each bullet already
-        // starts with its [SUBJECT] (topic-first, enforced by prompts.ts), and
-        // prepending "[Section]" re-introduced the category-first prefix the
-        // 2026-08-02 corpus rewrite removed. The section label is unused
-        // downstream (distilled memories all store memory_type='episode').
+        // are NOT prefixed onto entries: each bullet already starts with its type
+        // tag + [SUBJECT] (topic-first, enforced by prompts.ts), and prepending
+        // "[Section]" re-introduced the category-first prefix the 2026-08-02
+        // corpus rewrite removed.
         if (trimmed.startsWith("# ") ||
             trimmed.startsWith("## ") ||
             trimmed.startsWith("### ")) {
@@ -437,7 +468,20 @@ function parseDistilledEntries(markdown) {
         }
         // Bullet items are individual, already topic-first memories.
         if (trimmed.startsWith("- ") && trimmed.length > 5) {
-            entries.push(trimmed.slice(2));
+            const body = trimmed.slice(2);
+            // Extract an optional leading single-letter type tag: "[E]", "[F]",
+            // "[D]" (case-insensitive). The tag must be the very first token of the
+            // bullet — a bracket that appears later is payload, not a type tag.
+            const tagMatch = body.match(/^\[([EFDefdLl])\]\s*/);
+            if (tagMatch) {
+                const memoryType = typeFromTag(tagMatch[1].toUpperCase());
+                entries.push({ content: body.slice(tagMatch[0].length), memoryType });
+            }
+            else {
+                // No tag → episode (pre-#216 distiller output, or a model that
+                // skipped the tag). Keep the content verbatim.
+                entries.push({ content: body, memoryType: "episode" });
+            }
         }
     }
     return entries;

package/dist/mcp-server.js CHANGED Viewed

@@ -546,6 +546,11 @@ async function startServer(options = {}) {
     console.log(authToken
         ? `[hicortex] Bearer token auth enabled`
         : `[hicortex] No auth token configured — remote access DISABLED (localhost only). Run init to generate a token.`);
+    // Root → dashboard redirect (#249). Registered BEFORE the auth middleware so
+    // the redirect itself is public — it carries no data; the destination
+    // /dashboard has its own shell-exemption pattern. Gives the console one entry
+    // point: http://<host>:8787/ → /dashboard.
+    app.get("/", (_req, res) => res.redirect("/dashboard"));
     app.use((0, viz_js_1.createAuthMiddleware)(authToken));
     // SSE transport management — each connection gets its own McpServer instance
     const transports = new Map();
@@ -885,9 +890,14 @@ async function startServer(options = {}) {
             const toStore = [];
             for (let i = 0; i < entries.length; i++) {
                 const entry = entries[i];
-                if (typeof entry !== "string" || !entry.trim())
+                if (typeof entry !== "object" || !entry.content || !entry.content.trim())
                     continue;
-                toStore.push({ entry, embedding: await (0, embedder_js_1.embed)(entry), i });
+                toStore.push({
+                    content: entry.content,
+                    memoryType: entry.memoryType,
+                    embedding: await (0, embedder_js_1.embed)(entry.content),
+                    i,
+                });
             }
             // Phase 2 — insert all chunks in ONE transaction (fix 4). A segment's
             // chunks are all-or-nothing: any insert failure rolls back the whole set
@@ -896,8 +906,8 @@ async function startServer(options = {}) {
             // legacy whole-session path too — same loop.)
             const insertAll = db.transaction(() => {
                 const out = [];
-                for (const { entry, embedding, i } of toStore) {
-                    out.push(storage.insertMemory(db, entry, embedding, {
+                for (const { content, memoryType, embedding, i } of toStore) {
+                    out.push(storage.insertMemory(db, content, embedding, {
                         sourceAgent: source_agent ?? "unknown",
                         // Attribution + provenance only (0.16.x): client-declared, never
                         // filtered. Default null for older clients that don't send them.
@@ -907,7 +917,11 @@ async function startServer(options = {}) {
                         // matches the dedup checks above, so a re-run is idempotent.
                         sourceSession: sourcePrefix ? `${sourcePrefix}#${i}` : undefined,
                         project: project ?? undefined,
-                        memoryType: "episode",
+                        // #216: the distiller now classifies each entry as
+                        // episode/fact/decision via the [E]/[F]/[D] tag parsed in
+                        // distiller.ts. Pre-#216 distiller output (no tag) defaults to
+                        // episode 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.
                         privacy: typeof privacy === "string" ? privacy : null,

package/dist/prompts.js CHANGED Viewed

@@ -119,38 +119,53 @@ EXTRACT into this markdown format:
 # Session Memory: ${date} - ${projectName}
 ### Decisions Made
-- [SUBJECT]: [decision] — [reasoning] (${date})
+- [D] [SUBJECT]: [decision] — [reasoning] (${date})
 ### Facts Learned
-- [SUBJECT]: [fact] — [context/source] (${date})
+- [F] [SUBJECT]: [fact] — [context/source] (${date})
 ### Problems & Solutions
-- [SUBJECT]: [problem] → [solution that worked] (${date})
+- [E] [SUBJECT]: [problem] → [solution that worked] (${date})
 ### Project State Changes
-- [SUBJECT]: [what changed], [from → to] (${date})
+- [D] [SUBJECT]: [what changed], [from → to] (${date})
 ### Key Entities & Relationships
-- [entity A] → [relationship] → [entity B] (${date})
+- [F] [entity A] → [relationship] → [entity B] (${date})
 ### Corrections & Rejections
-- [SUBJECT]: [what AI proposed] → [why rejected/corrected] → [what user wanted instead] (${date})
+- [E] [SUBJECT]: [what AI proposed] → [why rejected/corrected] → [what user wanted instead] (${date})
   (Include: tool use denials, "no/wrong/redo", style feedback, approach rejections,
    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
+  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
+  :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
+  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 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.
+The type tag goes BEFORE the subject, never as a section/category bracket.
 TOPIC-FIRST RULE (critical — read carefully):
-Every item MUST begin with its [SUBJECT]: the concrete thing it is about — the
-system, file, component, decision area, or entity. The subject is what a future
-reader would search for.
-- Write:  "Electrical load calculation: don't bundle unknown loads into one figure — user rejected the estimate"
-- NOT:    "User rejected AI's bundling of unknown loads"
-- Write:  "Nightly capture (Hermes): cron sessions are excluded — source='cron' is skipped before distillation"
-- NOT:    "Discovered that cron sessions are filtered out"
-Reason: each item's first words 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 matches
-every emotionally-similar prompt and no topically-relevant one. Front-load the
-subject; put reaction, intensity and reasoning AFTER it.
+Every item MUST begin with its [SUBJECT] (right after the type tag): the
+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"
+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
+matches every emotionally-similar prompt and no topically-relevant one. Front-load
+the subject; put reaction, intensity and reasoning AFTER it.
 RULES:
 - Extract MAX 20 items total (quality over quantity)

package/dist/state.d.ts CHANGED Viewed

@@ -60,6 +60,13 @@ export interface HicortexState {
      * gradually over many nights.
      */
     supersessionCursor?: number;
+    /**
+     * Resume cursor for `hicortex classify-types` (#216) — highest memories.rowid
+     * whose batch has been fully committed. Absent/0 = never run (or reset).
+     * Same discipline as domainCursor: advances per committed batch so an
+     * interruption never loses more than the in-flight batch.
+     */
+    typeCursor?: number;
     /**
      * LLM token usage accrued this billing period (#246). Period reset is
      * monthly: when `periodStart` is in a previous calendar month, the totals

package/dist/type-classify.d.ts ADDED Viewed

@@ -0,0 +1,96 @@
+/**
+ * `hicortex classify-types` — deliberate, resumable episode→fact/decision
+ * 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
+ * `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. For each memory, ONE constrained LLM call asks
+ * the model to classify the content as episode / fact / decision. 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 produced here: the reflection stage owns them. A model that
+ * replies "lesson" is treated as unparseable (the memory keeps its current type
+ * and is retried next run via the cursor).
+ *
+ * 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. */
+    all?: boolean;
+    /** Memories per batch (default 200). Cursor advances per committed batch. */
+    batchSize?: number;
+    /** Ignore the saved cursor and restart from rowid 0. */
+    reset?: boolean;
+    /** DB path override (tests). Defaults to resolveDbPath(). */
+    dbPath?: string;
+    /** State dir override (tests). Defaults to ~/.hicortex. */
+    stateDir?: string;
+    /** LLM override (tests). Bypasses config resolution. */
+    llm?: LlmClient;
+    /** Config override (tests). Defaults to reading stateDir/config.json. */
+    config?: Record<string, unknown> | null;
+}
+export interface ClassifyTypesReport {
+    /** Memories examined in this invocation. */
+    scanned: number;
+    /** Memories whose memory_type was changed. */
+    reclassified: number;
+    /** Episodes confirmed as episode (no change). */
+    unchanged: number;
+    /** Memories skipped due to an infra error (LLM threw twice). */
+    failed: number;
+    /** Batches processed. */
+    batches: number;
+    /** Cursor after this run. */
+    cursor: number;
+    /** Whether the run aborted early on an infra error. */
+    aborted: boolean;
+    /** Final per-type counts (whole corpus, post-run). */
+    byType: Record<string, number>;
+}
+/**
+ * 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.
+ */
+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.
+ *
+ * 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): "episode" | "fact" | "decision" | null;
+/**
+ * Classify one memory's type. Two attempts (one call, one retry on a throw OR
+ * an unparseable reply). Returns the validated type, or null on infra error
+ * (caller leaves the memory untouched and retries via the cursor next run).
+ */
+export declare function classifyMemoryType(content: string, llm: LlmClient): Promise<"episode" | "fact" | "decision" | null>;
+/**
+ * Run the classify-types pass. Returns a structured report.
+ * Throws on unrecoverable setup errors (client mode, no LLM) — the cursor
+ * always reflects the last committed batch.
+ */
+export declare function runClassifyTypes(options?: ClassifyTypesOptions): Promise<ClassifyTypesReport>;

package/dist/type-classify.js ADDED Viewed

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * `hicortex classify-types` — deliberate, resumable episode→fact/decision
+ * 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
+ * `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. For each memory, ONE constrained LLM call asks
+ * the model to classify the content as episode / fact / decision. 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 produced here: the reflection stage owns them. A model that
+ * replies "lesson" is treated as unparseable (the memory keeps its current type
+ * and is retried next run via the cursor).
+ *
+ * This command does NOT use the consolidation budget — it is a standalone CLI,
+ * not a nightly stage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTypeClassifyPrompt = buildTypeClassifyPrompt;
+exports.parseTypeReply = parseTypeReply;
+exports.classifyMemoryType = classifyMemoryType;
+exports.runClassifyTypes = runClassifyTypes;
+const paths_js_1 = require("./paths.js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const db_js_1 = require("./db.js");
+const state_js_1 = require("./state.js");
+const llm_js_1 = require("./llm.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"]);
+function readConfig(stateDir) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(stateDir, "config.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 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.
+ */
+function buildTypeClassifyPrompt(content) {
+    const truncated = content.length > CLASSIFY_CONTENT_MAX_CHARS
+        ? content.slice(0, CLASSIFY_CONTENT_MAX_CHARS) + "…"
+        : content;
+    return (`You are classifying a single memory by its TYPE.\n\n` +
+        `TYPES:\n` +
+        `- episode: 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` +
+        `MEMORY:\n${truncated}\n\n` +
+        `Reply with ONLY one word: episode, fact, or decision. No prose, no punctuation.`);
+}
+/**
+ * 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.
+ *
+ * Returns null on anything unparseable or out-of-vocabulary so the caller can
+ * retry once (matching classify-domains' two-attempt discipline).
+ */
+function parseTypeReply(reply) {
+    if (!reply)
+        return null;
+    let cleaned = reply.trim();
+    // Take the first non-empty line — models sometimes add a justification below.
+    const firstLine = cleaned.split(/\r?\n/).map((l) => l.trim()).find((l) => l.length > 0);
+    if (firstLine)
+        cleaned = firstLine;
+    // Strip a leading label like "Type:" / "Answer:".
+    cleaned = cleaned.replace(/^(type|answer|classification)\s*[:\-]\s*/i, "");
+    // Strip markdown emphasis, surrounding quotes/backticks, trailing punctuation.
+    cleaned = cleaned
+        .replace(/^[*_`"'\s]+/, "")
+        .replace(/[*_`"'.\s]+$/, "")
+        .trim()
+        .toLowerCase();
+    if (VALID_TYPES.has(cleaned)) {
+        return cleaned;
+    }
+    return null;
+}
+/**
+ * Classify one memory's type. Two attempts (one call, one retry on a throw OR
+ * an unparseable reply). Returns the validated type, or null on infra error
+ * (caller leaves the memory untouched and retries via the cursor next run).
+ */
+async function classifyMemoryType(content, llm) {
+    const prompt = buildTypeClassifyPrompt(content);
+    for (let attempt = 0; attempt < 2; attempt++) {
+        let raw;
+        try {
+            // ~8 tokens covers a single word + a little headroom.
+            const r = await llm.completeClassify(prompt, 8);
+            raw = r.text;
+        }
+        catch (err) {
+            if (attempt === 0)
+                continue; // retry once
+            console.warn(`[hicortex] type classify LLM error: ${err instanceof Error ? err.message : String(err)} — aborting this memory (will retry)`);
+            return null; // infra error → abort untouched
+        }
+        const parsed = parseTypeReply(raw);
+        if (parsed)
+            return parsed;
+        if (attempt === 0) {
+            console.warn(`[hicortex] type classify: unparseable reply "${raw.slice(0, 60)}" — retrying once`);
+        }
+    }
+    // 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
+    // silently overwrite an existing type. Return null so the caller records a
+    // failed classification and the cursor still advances past this row.
+    return null;
+}
+/**
+ * Run the classify-types pass. Returns a structured report.
+ * Throws on unrecoverable setup errors (client mode, no LLM) — the cursor
+ * always reflects the last committed batch.
+ */
+async function runClassifyTypes(options = {}) {
+    const batchSize = options.batchSize ?? 200;
+    const stateDir = options.stateDir ?? HICORTEX_HOME;
+    const all = options.all ?? false;
+    if (!Number.isInteger(batchSize) || batchSize < 1) {
+        throw new Error(`[hicortex] classify-types: invalid --batch value: ${options.batchSize}`);
+    }
+    const config = options.config !== undefined ? options.config : readConfig(stateDir);
+    // Server-mode only — client installs have no local DB.
+    if (config?.mode === "client") {
+        throw new Error("[hicortex] classify-types is server-mode only (it needs the local DB). " +
+            `This machine is a client of ${config.serverUrl ?? "a remote server"} — run it on the server.`);
+    }
+    // Resolve the LLM (one model serves all phases — #231).
+    let llm;
+    if (options.llm) {
+        llm = options.llm;
+    }
+    else {
+        const resolved = (0, llm_js_1.resolveSavedLlmConfig)(config);
+        if (!resolved.config) {
+            throw new Error("[hicortex] classify-types: no LLM configured — run `npx @gamaze/hicortex init`.");
+        }
+        llm = new llm_js_1.LlmClient(resolved.config);
+    }
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
+    const db = (0, db_js_1.initDb)(dbPath);
+    const report = {
+        scanned: 0,
+        reclassified: 0,
+        unchanged: 0,
+        failed: 0,
+        batches: 0,
+        cursor: 0,
+        aborted: false,
+        byType: {},
+    };
+    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"}, ` +
+            `batch ${batchSize}, cursor ${cursor}${options.reset ? " (reset)" : ""}`);
+        // Scope filter: default = episodes only; --all = everything.
+        const scopeSql = all ? "rowid > ?" : "rowid > ? AND memory_type = 'episode'";
+        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
+        // current batch's already-classified writes, commit, advance cursor to the
+        // last successfully-classified row, then stop.
+        let infraAbort = false;
+        for (;;) {
+            const params = [cursor, batchSize];
+            const rows = batchStmt.all(...params);
+            if (rows.length === 0)
+                break;
+            let batchReclassified = 0;
+            let batchUnchanged = 0;
+            let scannedInBatch = 0;
+            let failedInBatch = 0;
+            // Highest rowid we can safely advance the cursor to (last row we fully
+            // resolved — reclassified or confirmed — before any infra abort).
+            let committedRowid = cursor;
+            // Classify (network) OUTSIDE the write transaction; collect results.
+            const writes = [];
+            for (const row of rows) {
+                const type = await classifyMemoryType(row.content, llm);
+                if (type === null) {
+                    // Infra error OR two unparseable replies — stop scanning; leave this
+                    // row untouched for retry. (Two unparseable replies is rare; treating
+                    // it as an abort rather than a skip means the cursor does not advance
+                    // past a possibly-systematically-broken row. Cheaper to re-run than
+                    // to silently lose classification for a whole batch.)
+                    infraAbort = true;
+                    failedInBatch++;
+                    break;
+                }
+                scannedInBatch++;
+                if (type === row.memory_type) {
+                    batchUnchanged++;
+                }
+                else {
+                    batchReclassified++;
+                }
+                writes.push({ id: row.id, type });
+                committedRowid = row.__rowid;
+            }
+            // Commit the resolved writes, then persist the cursor at the last fully
+            // resolved rowid (crash-safe + infra-abort-safe: a re-run resumes there).
+            const updateStmt = db.prepare("UPDATE memories SET memory_type = ? WHERE id = ?");
+            const tx = db.transaction(() => {
+                for (const w of writes)
+                    updateStmt.run(w.type, w.id);
+            });
+            tx();
+            (0, state_js_1.updateState)((s) => { s.typeCursor = committedRowid; }, stateDir);
+            report.scanned += scannedInBatch;
+            report.reclassified += batchReclassified;
+            report.unchanged += batchUnchanged;
+            report.failed += failedInBatch;
+            report.batches++;
+            report.cursor = committedRowid;
+            cursor = committedRowid;
+            console.log(`[hicortex]   batch ${report.batches}: classified ${scannedInBatch}, ` +
+                `reclassified ${batchReclassified}, unchanged ${batchUnchanged}, ` +
+                `failed ${failedInBatch} (cursor ${committedRowid})${infraAbort ? " [infra abort]" : ""}`);
+            if (infraAbort) {
+                report.aborted = true;
+                console.warn("[hicortex] classify-types ABORTED on a classify-endpoint error. " +
+                    "The failing memory is untouched; cursor at last committed batch — re-run when the endpoint is back up.");
+                break;
+            }
+        }
+        // Final per-type counts across the whole corpus.
+        const counts = db
+            .prepare(`SELECT memory_type, COUNT(*) AS cnt FROM memories
+         WHERE memory_type IS NOT NULL GROUP BY memory_type ORDER BY cnt DESC`)
+            .all();
+        for (const c of counts)
+            report.byType[c.memory_type] = c.cnt;
+        const breakdown = counts.map((c) => `${c.memory_type}=${c.cnt}`).join(", ") || "none";
+        console.log(`[hicortex] classify-types ${report.aborted ? "ABORTED" : "complete"}: ` +
+            `${report.scanned} classified, ${report.reclassified} reclassified, ` +
+            `${report.unchanged} unchanged, ${report.failed} infra-skipped`);
+        console.log(`[hicortex]   by type: ${breakdown}`);
+        return report;
+    }
+    finally {
+        db.close();
+    }
+}

package/hermes-plugin/hicortex/config.py CHANGED Viewed

@@ -152,10 +152,41 @@ def save_config(values: Dict[str, Any], hermes_home: str) -> None:
     Called by `hermes memory setup` after collecting user inputs. Secret fields
     (hicortex_auth_token) are routed to the env store by Hermes, not written here.
+    #243: Does NOT clobber existing values with schema defaults. When the form
+    sends a value that matches the schema default for a field AND the existing
+    config.json already has a non-default value, the existing value is kept —
+    so re-opening the dashboard and clicking Save without editing doesn't
+    silently overwrite a remote URL with localhost.
     """
     path = _config_path(hermes_home)
     os.makedirs(os.path.dirname(path), exist_ok=True)
-    # Don't persist secrets to the JSON file — Hermes stores them separately.
-    safe = {k: v for k, v in values.items() if k != "hicortex_auth_token"}
+    # Load existing file values (merge target).
+    existing: Dict[str, Any] = {}
+    if os.path.exists(path):
+        try:
+            with open(path, encoding="utf-8") as f:
+                existing = json.load(f) or {}
+        except Exception:
+            existing = {}
+    # Build a map of schema defaults for the clobber guard.
+    defaults = {f["key"]: f.get("default") for f in CONFIG_SCHEMA if "default" in f}
+    # Merge: for each incoming value, skip it if (a) it equals the schema
+    # default AND (b) the existing config has a different non-default value.
+    # This prevents the dashboard's default-populated form from clobbering a
+    # real remote URL with localhost on a no-op Save.
+    merged = dict(existing)
+    for k, v in values.items():
+        if k == "hicortex_auth_token":
+            continue  # secrets handled by Hermes env store, never written here
+        if v == defaults.get(k) and existing.get(k, defaults.get(k)) != defaults.get(k):
+            # Incoming value is the schema default but existing is NOT — keep existing.
+            logger.debug("hicortex: save_config preserving existing %s=%s (form sent default %s)", k, existing.get(k), v)
+            continue
+        merged[k] = v
     with open(path, "w", encoding="utf-8") as f:
-        json.dump(safe, f, indent=2)
+        json.dump(merged, f, indent=2)

package/hermes-plugin/hicortex/provider.py CHANGED Viewed

@@ -753,6 +753,23 @@ class HicortexProvider(MemoryProvider):
     def get_config_schema(self) -> List[Dict[str, Any]]:
         return CONFIG_SCHEMA
+    def get_config(self) -> Dict[str, Any]:
+        """Return the live, effective config values (file ← env ← defaults).
+        Called by the Hermes dashboard to populate the settings form with
+        CURRENT values — not schema defaults. Without this, the form always
+        shows localhost regardless of what config.json/.env actually contain
+        (#243).
+        Secret fields (hicortex_auth_token) are redacted — the dashboard
+        should never receive the raw token. If the operator needs to change
+        it, they re-type it; save_config handles the write.
+        """
+        cfg = load_config()
+        if cfg.get("hicortex_auth_token"):
+            cfg["hicortex_auth_token"] = "***"
+        return cfg
     def save_config(self, values: Dict[str, Any], hermes_home: str) -> None:
         from .config import save_config as _save

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@gamaze/hicortex",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "description": "Self-learning memory for AI agents — experience captured automatically, distilled into lessons overnight, shared across your whole fleet. Works with Hermes, OpenClaw, Claude Code, and Pi.",
   "main": "dist/index.js",
   "bin": {