@gamaze/hicortex 0.10.1 → 0.11.1

package/dist/mcp-server.js

@@ -60,6 +60,7 @@ const state_js_1 = require("./state.js");
 const embedder_js_1 = require("./embedder.js");
 const storage = __importStar(require("./storage.js"));
 const graph_js_1 = require("./graph.js");
+const viz_js_1 = require("./viz.js");
 const retrieval = __importStar(require("./retrieval.js"));
 const seed_lesson_js_1 = require("./seed-lesson.js");
 const distiller_js_1 = require("./distiller.js");
@@ -227,9 +228,17 @@ function createMcpServer() {
         const state = (0, state_js_1.loadState)(stateDir);
         const moduleIndex = state.moduleIndex;
         if (moduleIndex && moduleIndex.domains.length > 0) {
-            const text = moduleIndex.domains.map((d) => `**${d.name}** (${d.memoryCount} memories, ${d.lessonCount} lessons)\n` +
-                `  Projects: ${d.projects.join(", ")}` +
-                (d.keywords.length > 0 ? `\n  Keywords: ${d.keywords.join(", ")}` : "")).join("\n\n");
+            const text = moduleIndex.domains.map((d) => {
+                const head = `**${d.name}** (${d.memoryCount} memories, ${d.lessonCount} lessons)`;
+                // 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) {
+                    return `${head}\n  ${d.description}`;
+                }
+                return head +
+                    (d.projects.length > 0 ? `\n  Projects: ${d.projects.join(", ")}` : "") +
+                    (d.keywords.length > 0 ? `\n  Keywords: ${d.keywords.join(", ")}` : "");
+            }).join("\n\n");
             return { content: [{ type: "text", text }] };
         }
         // Fallback: flat project counts
@@ -248,7 +257,7 @@ function createMcpServer() {
         target_id: zod_1.z.string().optional().describe("Target memory ID (required for path operation)"),
         limit: zod_1.z.coerce.number().optional().describe("Max results (default 10)"),
         domain: zod_1.z.string().optional().describe("Filter hubs by domain"),
-        relationship: zod_1.z.string().optional().describe("Filter neighbors by relationship type (e.g., CONTRADICTS, SUPERSEDES, derives)"),
+        relationship: zod_1.z.string().optional().describe("Filter neighbors by relationship type (e.g., extends, relates_to; legacy data may also have CONTRADICTS, SUPERSEDES, updates)"),
     }, async ({ operation, id, target_id, limit: resultLimit, domain: filterDomain, relationship: filterRelationship }) => {
         if (!db)
             return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
@@ -437,23 +446,12 @@ async function startServer(options = {}) {
     // localhost bypass. With no token configured, remote requests are REJECTED
     // (not open): the default bind is 0.0.0.0, so "no token = no auth" would
     // expose the whole memory store to the network.
+    // Extracted to viz.ts (createAuthMiddleware) so the middleware is
+    // unit-testable; includes the narrow GET /viz?token= browser handoff (#124).
     console.log(authToken
         ? `[hicortex] Bearer token auth enabled`
         : `[hicortex] No auth token configured — remote access DISABLED (localhost only). Run init to generate a token.`);
-    app.use((req, res, next) => {
-        if (req.path === "/health")
-            return next();
-        const ip = req.ip ?? req.socket.remoteAddress ?? "";
-        if (ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1")
-            return next();
-        if (authToken && req.headers.authorization === `Bearer ${authToken}`)
-            return next();
-        res.status(401).json({
-            error: authToken
-                ? "Unauthorized"
-                : "No auth token configured on this server — run `npx @gamaze/hicortex init` on the server, then connect with its token.",
-        });
-    });
+    app.use((0, viz_js_1.createAuthMiddleware)(authToken));
     // SSE transport management — each connection gets its own McpServer instance
     const transports = new Map();
     // Health endpoint
@@ -762,15 +760,27 @@ async function startServer(options = {}) {
     // -------------------------------------------------------------------------
     // REST /index — knowledge domain index (same payload as hicortex_index MCP).
     //
-    // NOTE for #124: this is the JSON surface that /viz will later consume.
-    // Keep the response shape clean: {domains} or {projects} fallback.
+    // NOTE (#124): /viz consumes this JSON surface. Keep the response shape
+    // clean: {domains} or {projects} fallback.
     // -------------------------------------------------------------------------
     app.get("/index", (_req, res) => {
         try {
             const state = (0, state_js_1.loadState)(stateDir);
             const moduleIndex = state.moduleIndex;
             if (moduleIndex && moduleIndex.domains && moduleIndex.domains.length > 0) {
-                res.json({ domains: moduleIndex.domains });
+                // domains[].memoryCount = PRIMARY-tag counts (unchanged). tagCounts is
+                // additive: total assignments per tag across memory_tags (multi-label
+                // breadth, incl. secondary tags). Absent when no tags exist yet.
+                let tagCounts;
+                if (db) {
+                    const tagRows = db.prepare("SELECT tag, COUNT(*) as cnt FROM memory_tags GROUP BY tag ORDER BY cnt DESC").all();
+                    if (tagRows.length > 0) {
+                        tagCounts = {};
+                        for (const r of tagRows)
+                            tagCounts[r.tag] = r.cnt;
+                    }
+                }
+                res.json(tagCounts ? { domains: moduleIndex.domains, tagCounts } : { domains: moduleIndex.domains });
                 return;
             }
             // Fallback: flat project counts when moduleIndex is not yet built
@@ -788,15 +798,17 @@ async function startServer(options = {}) {
     // -------------------------------------------------------------------------
     // REST /graph — knowledge graph query (same operations as hicortex_graph MCP).
     //
-    // Supported ops: neighbors, hubs, path
+    // Supported ops: neighbors, hubs, path, export
     //   GET /graph?op=neighbors&id=<id>&limit=10&relationship=<rel>
     //   GET /graph?op=hubs&limit=10&domain=<domain>
     //   GET /graph?op=path&id=<from>&target_id=<to>
+    //   GET /graph?op=export&domain=&type=&tag=&minStrength=&limit=  (#124: /viz data;
+    //     tag= filters to nodes CARRYING the tag at any weight — graded-schema spec)
     //
-    // NOTE for #124 (/viz): this endpoint IS the JSON surface that /viz will
-    // reuse for its graph visualisation. The response shape is intentionally
-    // clean ({results} for neighbors/path, {hubs} for hubs) so /viz can consume
-    // it without transformation. Do not add MCP-style text formatting here.
+    // NOTE (#124): this endpoint is the JSON surface consumed by /viz — op=export
+    // returns the full {nodes, edges, domains, types, meta} payload the page
+    // renders. The response shapes are intentionally clean ({results} for
+    // neighbors/path, {hubs} for hubs) — do not add MCP-style text formatting.
     // -------------------------------------------------------------------------
     app.get("/graph", (req, res) => {
         if (!db) {
@@ -804,13 +816,15 @@ async function startServer(options = {}) {
             return;
         }
         const op = typeof req.query.op === "string" ? req.query.op : "";
-        const VALID_OPS = ["neighbors", "hubs", "path"];
+        const VALID_OPS = ["neighbors", "hubs", "path", "export"];
         if (!VALID_OPS.includes(op)) {
             res.status(400).json({ error: `Invalid op: must be one of ${VALID_OPS.join(", ")}` });
             return;
         }
         const rawLimit = req.query.limit ? Number(req.query.limit) : undefined;
-        const resultLimit = rawLimit && Number.isFinite(rawLimit) ? rawLimit : 10;
+        // Floor + minimum 1: negative/fractional values would otherwise reach SQL
+        // LIMIT (negative = unlimited in SQLite; fractional = binding error).
+        const resultLimit = rawLimit && Number.isFinite(rawLimit) && rawLimit >= 1 ? Math.floor(rawLimit) : 10;
         const filterDomain = typeof req.query.domain === "string" && req.query.domain ? req.query.domain : undefined;
         const filterRelationship = typeof req.query.relationship === "string" && req.query.relationship ? req.query.relationship : undefined;
         try {
@@ -854,11 +868,54 @@ async function startServer(options = {}) {
                 res.json({ path: path ?? null });
                 return;
             }
+            if (op === "export") {
+                const filterType = typeof req.query.type === "string" && req.query.type ? req.query.type : undefined;
+                const filterTag = typeof req.query.tag === "string" && req.query.tag ? req.query.tag : undefined;
+                let minStrength;
+                if (req.query.minStrength !== undefined) {
+                    const v = Number(req.query.minStrength);
+                    if (!Number.isFinite(v) || v < 0 || v > 1) {
+                        res.status(400).json({ error: "minStrength must be a number between 0 and 1" });
+                        return;
+                    }
+                    minStrength = v;
+                }
+                // Export has its own default (EXPORT_DEFAULT_LIMIT) — the shared
+                // resultLimit default of 10 is for neighbors/hubs. exportGraph clamps
+                // to EXPORT_MAX_LIMIT.
+                const exportLimit = rawLimit && Number.isFinite(rawLimit) ? rawLimit : graph_js_1.EXPORT_DEFAULT_LIMIT;
+                res.json((0, graph_js_1.exportGraph)(db, {
+                    domain: filterDomain,
+                    type: filterType,
+                    tag: filterTag,
+                    minStrength,
+                    limit: exportLimit,
+                }));
+                return;
+            }
         }
         catch (err) {
             res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
         }
     });
+    // -------------------------------------------------------------------------
+    // GET /viz — knowledge-graph visualization page (#124).
+    //
+    // Self-contained HTML (inline CSS/JS, zero external requests) served from
+    // assets/viz.html. Fetches /graph?op=export from its own origin. The page
+    // SHELL is public (exempted in createAuthMiddleware, like /health — it
+    // carries no data); the /graph data fetch is bearer-only. The page collects
+    // the token client-side: ?token= URL param (stripped on load) or an in-page
+    // prompt on 401, persisted in localStorage.
+    // -------------------------------------------------------------------------
+    app.get("/viz", (0, viz_js_1.vizHandler)());
+    // GET /viz/vendor/:file — pinned renderer bundles for the /viz page (#139).
+    //
+    // STRICT allowlist (VIZ_VENDOR_FILES in viz.ts): only the exact vendored
+    // filenames are served; everything else is 404. Public like the /viz shell
+    // (static third-party code from the npm tarball, no data) — the exemption
+    // lives in createAuthMiddleware next to the /viz one.
+    app.get("/viz/vendor/:file", (0, viz_js_1.vizVendorHandler)());
     // SSE endpoint — each connection gets its own McpServer + transport
     app.get("/sse", async (req, res) => {
         const transport = new sse_js_1.SSEServerTransport("/messages", res);
@@ -898,6 +955,7 @@ async function startServer(options = {}) {
         console.log(`[hicortex] MCP server listening on http://${host}:${port}`);
         console.log(`[hicortex] SSE endpoint: http://${host}:${port}/sse`);
         console.log(`[hicortex] Health: http://${host}:${port}/health`);
+        console.log(`[hicortex] Graph viz: http://${host}:${port}/viz`);
     });
     server.on("error", (err) => {
         if (err.code === "EADDRINUSE") {

package/dist/nightly-status.js

@@ -16,41 +16,22 @@ const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
 const node_child_process_1 = require("node:child_process");
 const db_js_1 = require("./db.js");
+const state_js_1 = require("./state.js");
 const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
-const LAST_RUN_PATH = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
 const CONFIG_PATH = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
-const STALE_THRESHOLD_HOURS = 30;
 async function showNightlyStatus() {
     console.log("Hicortex Nightly Pipeline Status");
     console.log("─".repeat(40));
     // Last run
-    let lastRun = null;
-    let lastRunStr = "never";
-    try {
-        const ts = (0, node_fs_1.readFileSync)(LAST_RUN_PATH, "utf-8").trim();
-        const d = new Date(ts);
-        if (!isNaN(d.getTime())) {
-            lastRun = d;
-            lastRunStr = ts;
-        }
-        else {
-            lastRunStr = `${ts} (invalid)`;
-        }
-    }
-    catch {
-        // No file
+    const lastRun = (0, state_js_1.describeLastNightly)(HICORTEX_HOME);
+    if (!lastRun) {
+        console.log("Last run:    never");
     }
-    if (lastRun) {
-        const ageMs = Date.now() - lastRun.getTime();
-        const ageHours = Math.round(ageMs / (60 * 60 * 1000));
-        const ageStr = ageHours < 1 ? "just now" :
-            ageHours < 24 ? `${ageHours}h ago` :
-                `${Math.round(ageHours / 24)}d ago`;
-        const isStale = ageHours > STALE_THRESHOLD_HOURS;
-        console.log(`Last run:    ${lastRunStr} (${ageStr})${isStale ? " ⚠ STALE" : ""}`);
+    else if (lastRun.invalid) {
+        console.log(`Last run:    ${lastRun.timestamp} (invalid)`);
     }
     else {
-        console.log(`Last run:    ${lastRunStr}`);
+        console.log(`Last run:    ${lastRun.timestamp} (${lastRun.ageStr})${lastRun.stale ? " ⚠ STALE" : ""}`);
     }
     // LLM config
     try {
@@ -148,8 +129,8 @@ async function showNightlyStatus() {
     const issues = [];
     if (!lastRun)
         issues.push("Pipeline has never run. Run: hicortex nightly");
-    else if (lastRun && (Date.now() - lastRun.getTime()) > STALE_THRESHOLD_HOURS * 60 * 60 * 1000) {
-        issues.push(`Pipeline hasn't run in ${STALE_THRESHOLD_HOURS}+ hours. Check timer.`);
+    else if (lastRun.stale) {
+        issues.push("Pipeline hasn't run in 30+ hours. Check timer.");
     }
     if (!timerActive)
         issues.push("No timer installed. Nightly pipeline won't run automatically.");

package/dist/nightly.js

@@ -60,6 +60,8 @@ const embedder_js_1 = require("./embedder.js");
 const storage = __importStar(require("./storage.js"));
 const distiller_js_1 = require("./distiller.js");
 const consolidate_js_1 = require("./consolidate.js");
+const domain_classify_js_1 = require("./domain-classify.js");
+const nofit_js_1 = require("./nofit.js");
 const transcript_reader_js_1 = require("./transcript-reader.js");
 const hermes_transcript_reader_js_1 = require("./hermes-transcript-reader.js");
 const pi_transcript_reader_js_1 = require("./pi-transcript-reader.js");
@@ -133,38 +135,11 @@ async function runNightly(options = {}) {
         // is handled by the running daemon over /distill — no local distill LLM needed.
         // No LLM → capture loop still runs (sessions POST to /distill, which will 503
         // transient-fail and hold the watermark), but consolidation is skipped.
-        let llmConfig = null;
-        if (savedConfig?.llmBackend === "claude-cli") {
-            const claudePath = (0, llm_js_1.findClaudeBinary)();
-            if (claudePath) {
-                llmConfig = (0, llm_js_1.claudeCliConfig)(claudePath);
-            }
-            else {
-                console.warn("[hicortex] claude-cli configured but binary not found — consolidation skipped");
-            }
-        }
-        else if (savedConfig?.llmBackend === "ollama") {
-            llmConfig = {
-                baseUrl: savedConfig.llmBaseUrl ?? "http://localhost:11434",
-                apiKey: "",
-                model: savedConfig.llmModel ?? "qwen3.5:4b",
-                reflectModel: savedConfig.reflectModel ?? savedConfig.llmModel ?? "qwen3.5:4b",
-                provider: "ollama",
-            };
-        }
-        else {
-            llmConfig = (0, llm_js_1.resolveExplicitLlmConfig)({
-                llmBaseUrl: savedConfig?.llmBaseUrl,
-                llmApiKey: savedConfig?.llmApiKey,
-                llmModel: savedConfig?.llmModel,
-                reflectModel: savedConfig?.reflectModel,
-            });
-        }
-        if (llmConfig && savedConfig?.reflectBaseUrl) {
-            llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
-            llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
-            llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
+        const resolved = (0, llm_js_1.resolveSavedLlmConfig)(savedConfig);
+        if (resolved.reason === "claude_binary_missing") {
+            console.warn("[hicortex] claude-cli configured but binary not found — consolidation skipped");
         }
+        const llmConfig = resolved.config;
         const llm = llmConfig ? new llm_js_1.LlmClient(llmConfig) : null;
         // Step 1: Read new transcripts (CC + Hermes + Pi + OpenClaw)
         const since = readLastRun();
@@ -278,8 +253,43 @@ async function runNightly(options = {}) {
                         skipReflection = true;
                     }
                 }
+                // Content-based domain classification (config-owned `domains`) uses
+                // the classify tier (classifyModel/classifyBaseUrl) when configured,
+                // else the reflect tier. Pre-flight the endpoint classification will
+                // ACTUALLY use (resolveClassifyProbeTarget is the shared source of
+                // truth with `hicortex classify-domains`). If it is down, content
+                // classification is NOT ready this run (strict — skip, don't fall
+                // back). When no `domains` list is configured, this is inert and the
+                // legacy project-grouping path runs.
+                const cfgDomains = (0, domain_classify_js_1.parseConfigDomains)(savedConfig);
+                let contentDomainsReady = true;
+                if (cfgDomains) {
+                    const classifyTarget = (0, llm_js_1.resolveClassifyProbeTarget)(llmConfig);
+                    if (classifyTarget?.tier === "reflect") {
+                        // Classification rides the reflect endpoint — reuse the probe above.
+                        contentDomainsReady = !skipReflection;
+                    }
+                    else if (classifyTarget) {
+                        const health = await (0, llm_js_1.probeOllamaModel)(classifyTarget.baseUrl, classifyTarget.model);
+                        if (!health.ok) {
+                            const reason = health.reason === "unreachable"
+                                ? `classify endpoint unreachable (${classifyTarget.baseUrl})`
+                                : `classify model not loaded (${classifyTarget.model} missing on ${classifyTarget.baseUrl})`;
+                            console.warn(`[hicortex] ${reason}`);
+                            contentDomainsReady = false;
+                        }
+                    }
+                    // classifyTarget === null → base endpoint or API provider, no probe.
+                    if (!contentDomainsReady) {
+                        console.warn("[hicortex] content-domain classification skipped — classification endpoint offline (strict)");
+                    }
+                }
                 console.log(`[hicortex] Running consolidation...`);
-                const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun, skipReflection);
+                const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun, skipReflection, undefined, {
+                    domains: cfgDomains,
+                    contentDomainsReady,
+                    weakPrimaryFloor: (0, nofit_js_1.resolveWeakPrimaryFloor)(savedConfig),
+                });
                 console.log(`[hicortex] Consolidation ${report.status} in ${report.elapsed_seconds}s` +
                     (report.stages.reflection ? ` (${report.stages.reflection.lessons_generated} lessons)` : ""));
             }

package/dist/nofit.d.ts

@@ -0,0 +1,111 @@
+/**
+ * No-fit lifecycle — weak-primary floor + no-association decay
+ * (owner amendment 07.07 to specs/2026-07-07-graded-schema-memory-tags.md).
+ *
+ * THE MODEL
+ * ---------
+ * "Unsorted" is a non-tag: the vocabulary carries NO fallback category, and a
+ * genuine LLM no-fit is an EMPTY tag set (domain-classify.ts returns
+ * {tags: []}). Every stored memory should still end up with a primary if it
+ * reasonably can, so on a no-fit the pipeline derives:
+ *
+ *   1. WEAK PRIMARY — argmax cosine of the memory embedding across ALL domain
+ *      prototypes (schema-prototypes.bestPrototypeMatch). If the best cosine
+ *      >= `weakPrimaryFloor`, the memory is tagged with that single domain
+ *      (the primary derives naturally via storage.setMemoryTags). It lives —
+ *      humbly, with one weak association.
+ *
+ *   2. NO ASSOCIATION — best cosine below the floor means the memory
+ *      associates with nothing the owner cares about. It is NOT tagged;
+ *      instead its base_strength is HALVED (floored at
+ *      NO_ASSOCIATION_MIN_STRENGTH) so the existing decay/prune stage
+ *      eventually removes it. domain stays NULL, which keeps the memory in
+ *      the nightly staleness scope: every subsequent run re-classifies it
+ *      (prototypes evolve — it may fit later) and re-halves ONLY when it is
+ *      still a no-fit below the floor.
+ *
+ * COLD-START SAFETY: prototypes are ALWAYS available before any no-fit
+ * evaluation — computeDomainPrototypes seeds every configured domain from its
+ * description embedding when it has <5 members, so a fresh install cannot
+ * produce a null prototype for a configured domain and therefore cannot
+ * mass-decay a new corpus. A missing MEMORY embedding routes to null (decay
+ * candidate), never to a false weak-primary.
+ *
+ * RESCUE PATHS (survivability):
+ *   - Access: storage.strengthenMemory bumps access_count — and
+ *     stageDecayPrune only ever considers access_count = 0 memories
+ *     (storage.getPruneCandidates), so a single recall permanently shields a
+ *     memory from pruning. Halving does not touch last_accessed/access_count.
+ *   - Re-classification: a later run whose LLM tags it, or whose evolved
+ *     prototypes clear the floor, gives it a (weak) primary — halving stops.
+ *     Its strength is NOT restored; only access does that job.
+ *
+ * PRUNE INTERACTION (verified against stageDecayPrune + effectiveStrength):
+ * prune fires when effectiveStrength < 0.01 for a >90-day-old, never-accessed
+ * memory. effectiveStrength has an asymptotic floor of base_strength² × 0.1,
+ * so at the default 0.5 a memory can NEVER prune (floor 0.025 > 0.01) —
+ * halving is what makes pruning reachable at all. From 0.5: four nightly
+ * halvings reach the 0.05 strength floor (0.25 → 0.125 → 0.0625 → 0.05); at
+ * 0.05 the decay curve crosses 0.01 roughly 143 days after last access.
+ */
+import type Database from "better-sqlite3";
+import type { DomainDef } from "./types.js";
+/**
+ * Default weak-primary floor: minimum cosine(memory embedding, best domain
+ * prototype) for a no-fit memory to earn a weak primary.
+ *
+ * TUNING: 0.45 is a starting point for bge-small-en-v1.5 embeddings — it
+ * should be tuned from the actual corpus weight distribution (e.g. inspect
+ * the memory_tags.weight histogram of LLM-tagged rows and set the floor
+ * near its lower tail). Override per install via `weakPrimaryFloor` in
+ * ~/.hicortex/config.json.
+ */
+export declare const DEFAULT_WEAK_PRIMARY_FLOOR = 0.45;
+/** Halving never takes base_strength below this (survivable, not zeroed). */
+export declare const NO_ASSOCIATION_MIN_STRENGTH = 0.05;
+/**
+ * Resolve the weak-primary floor from a raw config object. Accepts a finite
+ * number in (0, 1); anything else (absent, wrong type, out of range) falls
+ * back to DEFAULT_WEAK_PRIMARY_FLOOR with a warning for invalid values.
+ */
+export declare function resolveWeakPrimaryFloor(config: Record<string, unknown> | null | undefined): number;
+/** Outcome of resolving a no-fit memory against the domain prototypes. */
+export type NoFitResolution = {
+    kind: "weak_primary";
+    domain: string;
+    weight: number;
+} | {
+    kind: "no_association";
+    bestWeight: number | null;
+};
+/**
+ * Decide what happens to a no-fit memory (READ-ONLY — no writes, so callers
+ * batching writes into a transaction can decide during the scan phase):
+ * best prototype cosine >= floor → weak_primary; below the floor (or no
+ * embedding / no prototypes at all) → no_association.
+ */
+export declare function resolveNoFit(db: Database.Database, memoryId: string, domains: DomainDef[], prototypes: Map<string, Float32Array>, floor: number): NoFitResolution;
+/**
+ * Apply a weak primary: tag the memory with the single argmax domain (the
+ * primary derives naturally inside setMemoryTags). Logged distinctly so
+ * weak primaries are auditable apart from LLM-tagged rows.
+ */
+export declare function applyWeakPrimary(db: Database.Database, memoryId: string, domain: string, weight: number, compartments: Set<string>): void;
+/**
+ * Apply no-association decay to a no-fit-below-floor memory:
+ *   - clear any leftover memory_tags rows (e.g. a legacy "Unsorted" tag from
+ *     a domain since removed from the config) so refreshPrimaries cannot
+ *     resurrect a primary from them,
+ *   - set domain to NULL (keeps the memory in the nightly staleness scope —
+ *     re-attempted every run as prototypes evolve),
+ *   - HALVE base_strength, floored at NO_ASSOCIATION_MIN_STRENGTH.
+ *
+ * Does NOT touch last_accessed / access_count — access-strengthening remains
+ * the rescue path (prune only ever considers access_count = 0 memories).
+ * Called at most once per memory per run (each pipeline pass visits a memory
+ * exactly once), so a single run never double-halves.
+ */
+export declare function applyNoAssociationDecay(db: Database.Database, memoryId: string): {
+    previous: number;
+    next: number;
+};

package/dist/nofit.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * No-fit lifecycle — weak-primary floor + no-association decay
+ * (owner amendment 07.07 to specs/2026-07-07-graded-schema-memory-tags.md).
+ *
+ * THE MODEL
+ * ---------
+ * "Unsorted" is a non-tag: the vocabulary carries NO fallback category, and a
+ * genuine LLM no-fit is an EMPTY tag set (domain-classify.ts returns
+ * {tags: []}). Every stored memory should still end up with a primary if it
+ * reasonably can, so on a no-fit the pipeline derives:
+ *
+ *   1. WEAK PRIMARY — argmax cosine of the memory embedding across ALL domain
+ *      prototypes (schema-prototypes.bestPrototypeMatch). If the best cosine
+ *      >= `weakPrimaryFloor`, the memory is tagged with that single domain
+ *      (the primary derives naturally via storage.setMemoryTags). It lives —
+ *      humbly, with one weak association.
+ *
+ *   2. NO ASSOCIATION — best cosine below the floor means the memory
+ *      associates with nothing the owner cares about. It is NOT tagged;
+ *      instead its base_strength is HALVED (floored at
+ *      NO_ASSOCIATION_MIN_STRENGTH) so the existing decay/prune stage
+ *      eventually removes it. domain stays NULL, which keeps the memory in
+ *      the nightly staleness scope: every subsequent run re-classifies it
+ *      (prototypes evolve — it may fit later) and re-halves ONLY when it is
+ *      still a no-fit below the floor.
+ *
+ * COLD-START SAFETY: prototypes are ALWAYS available before any no-fit
+ * evaluation — computeDomainPrototypes seeds every configured domain from its
+ * description embedding when it has <5 members, so a fresh install cannot
+ * produce a null prototype for a configured domain and therefore cannot
+ * mass-decay a new corpus. A missing MEMORY embedding routes to null (decay
+ * candidate), never to a false weak-primary.
+ *
+ * RESCUE PATHS (survivability):
+ *   - Access: storage.strengthenMemory bumps access_count — and
+ *     stageDecayPrune only ever considers access_count = 0 memories
+ *     (storage.getPruneCandidates), so a single recall permanently shields a
+ *     memory from pruning. Halving does not touch last_accessed/access_count.
+ *   - Re-classification: a later run whose LLM tags it, or whose evolved
+ *     prototypes clear the floor, gives it a (weak) primary — halving stops.
+ *     Its strength is NOT restored; only access does that job.
+ *
+ * PRUNE INTERACTION (verified against stageDecayPrune + effectiveStrength):
+ * prune fires when effectiveStrength < 0.01 for a >90-day-old, never-accessed
+ * memory. effectiveStrength has an asymptotic floor of base_strength² × 0.1,
+ * so at the default 0.5 a memory can NEVER prune (floor 0.025 > 0.01) —
+ * halving is what makes pruning reachable at all. From 0.5: four nightly
+ * halvings reach the 0.05 strength floor (0.25 → 0.125 → 0.0625 → 0.05); at
+ * 0.05 the decay curve crosses 0.01 roughly 143 days after last access.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_ASSOCIATION_MIN_STRENGTH = exports.DEFAULT_WEAK_PRIMARY_FLOOR = void 0;
+exports.resolveWeakPrimaryFloor = resolveWeakPrimaryFloor;
+exports.resolveNoFit = resolveNoFit;
+exports.applyWeakPrimary = applyWeakPrimary;
+exports.applyNoAssociationDecay = applyNoAssociationDecay;
+const storage = __importStar(require("./storage.js"));
+const schema_prototypes_js_1 = require("./schema-prototypes.js");
+/**
+ * Default weak-primary floor: minimum cosine(memory embedding, best domain
+ * prototype) for a no-fit memory to earn a weak primary.
+ *
+ * TUNING: 0.45 is a starting point for bge-small-en-v1.5 embeddings — it
+ * should be tuned from the actual corpus weight distribution (e.g. inspect
+ * the memory_tags.weight histogram of LLM-tagged rows and set the floor
+ * near its lower tail). Override per install via `weakPrimaryFloor` in
+ * ~/.hicortex/config.json.
+ */
+exports.DEFAULT_WEAK_PRIMARY_FLOOR = 0.45;
+/** Halving never takes base_strength below this (survivable, not zeroed). */
+exports.NO_ASSOCIATION_MIN_STRENGTH = 0.05;
+/**
+ * Resolve the weak-primary floor from a raw config object. Accepts a finite
+ * number in (0, 1); anything else (absent, wrong type, out of range) falls
+ * back to DEFAULT_WEAK_PRIMARY_FLOOR with a warning for invalid values.
+ */
+function resolveWeakPrimaryFloor(config) {
+    const raw = config?.weakPrimaryFloor;
+    if (raw === undefined || raw === null)
+        return exports.DEFAULT_WEAK_PRIMARY_FLOOR;
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0 && raw < 1) {
+        return raw;
+    }
+    console.warn(`[hicortex] invalid weakPrimaryFloor in config (${JSON.stringify(raw)}) — ` +
+        `must be a number in (0, 1); using default ${exports.DEFAULT_WEAK_PRIMARY_FLOOR}`);
+    return exports.DEFAULT_WEAK_PRIMARY_FLOOR;
+}
+/**
+ * Decide what happens to a no-fit memory (READ-ONLY — no writes, so callers
+ * batching writes into a transaction can decide during the scan phase):
+ * best prototype cosine >= floor → weak_primary; below the floor (or no
+ * embedding / no prototypes at all) → no_association.
+ */
+function resolveNoFit(db, memoryId, domains, prototypes, floor) {
+    const best = (0, schema_prototypes_js_1.bestPrototypeMatch)(db, memoryId, domains, prototypes);
+    if (best && best.weight >= floor) {
+        return { kind: "weak_primary", domain: best.domain, weight: best.weight };
+    }
+    return { kind: "no_association", bestWeight: best?.weight ?? null };
+}
+/**
+ * Apply a weak primary: tag the memory with the single argmax domain (the
+ * primary derives naturally inside setMemoryTags). Logged distinctly so
+ * weak primaries are auditable apart from LLM-tagged rows.
+ */
+function applyWeakPrimary(db, memoryId, domain, weight, compartments) {
+    storage.setMemoryTags(db, memoryId, [domain], {
+        weights: { [domain]: weight },
+        compartments,
+    });
+    console.log(`[hicortex] weak-primary ${domain} w=${weight.toFixed(2)} for ${memoryId}`);
+}
+/**
+ * Apply no-association decay to a no-fit-below-floor memory:
+ *   - clear any leftover memory_tags rows (e.g. a legacy "Unsorted" tag from
+ *     a domain since removed from the config) so refreshPrimaries cannot
+ *     resurrect a primary from them,
+ *   - set domain to NULL (keeps the memory in the nightly staleness scope —
+ *     re-attempted every run as prototypes evolve),
+ *   - HALVE base_strength, floored at NO_ASSOCIATION_MIN_STRENGTH.
+ *
+ * Does NOT touch last_accessed / access_count — access-strengthening remains
+ * the rescue path (prune only ever considers access_count = 0 memories).
+ * Called at most once per memory per run (each pipeline pass visits a memory
+ * exactly once), so a single run never double-halves.
+ */
+function applyNoAssociationDecay(db, memoryId) {
+    const mem = storage.getMemory(db, memoryId);
+    if (!mem) {
+        throw new Error(`applyNoAssociationDecay: memory not found: ${memoryId}`);
+    }
+    const previous = mem.base_strength ?? 0.5;
+    const next = Math.max(exports.NO_ASSOCIATION_MIN_STRENGTH, previous / 2);
+    const tx = db.transaction(() => {
+        db.prepare("DELETE FROM memory_tags WHERE memory_id = ?").run(memoryId);
+        storage.updateMemory(db, memoryId, { base_strength: next, domain: null });
+    });
+    tx();
+    console.log(`[hicortex] no-association decay ${memoryId}: base_strength ` +
+        `${previous.toFixed(3)} → ${next.toFixed(3)} (below weak-primary floor)`);
+    return { previous, next };
+}

package/dist/prompts.d.ts

@@ -19,8 +19,3 @@ export declare function distillation(projectName: string, date: string, transcri
  * Used during consolidation (Pro only, one call per nightly when projects change).
  */
 export declare function domainCuration(projectLines: string): string;
-/**
- * Edge classification prompt. Presents memory pairs and asks the LLM to
- * choose the most specific relationship type for each.
- */
-export declare function edgeClassification(pairsBlock: string): string;