@gamaze/hicortex 0.7.0 → 0.10.0

package/dist/consolidate.js

@@ -43,6 +43,7 @@ exports.parseJsonLenient = parseJsonLenient;
 exports.runConsolidation = runConsolidation;
 exports.msUntilHour = msUntilHour;
 exports.scheduleConsolidation = scheduleConsolidation;
+const types_js_1 = require("./types.js");
 const retrieval_js_1 = require("./retrieval.js");
 const storage = __importStar(require("./storage.js"));
 const prompts_js_1 = require("./prompts.js");
@@ -267,13 +268,6 @@ async function stageReflection(db, memories, llm, budget, embedFn, dryRun) {
                 minor: 0.6,
             };
             try {
-                // Check memory cap before storing lesson
-                if ((0, features_js_1.memoryCapReached)(storage.countMemories(db))) {
-                    console.log(`[hicortex] Free tier limit (${(0, features_js_1.maxMemoriesAllowed)()} memories). ` +
-                        `Existing memories and lessons still work. New lessons won't be saved. ` +
-                        `Upgrade for unlimited usage: https://hicortex.gamaze.com/`);
-                    break;
-                }
                 const embedding = await embedFn(content);
                 // Contradiction check: find semantically similar existing lessons.
                 // If a very similar lesson exists, ask the LLM whether the new one
@@ -487,12 +481,17 @@ async function stageDomainCuration(db, llm, budget, dryRun, stateDir) {
     console.log(`[hicortex] Domain curation: ${domains.length} domains from ${projectRows.length} projects`);
     return { curated: true, domains: domains.length };
 }
-// ---------------------------------------------------------------------------
-// Stage 3: Link Discovery (vector similarity auto-link)
-// ---------------------------------------------------------------------------
-async function stageLinks(db, memories, embedFn, dryRun) {
+/** Batch size for LLM edge classification calls. */
+const EDGE_CLASSIFICATION_BATCH_SIZE = 8;
+/** Valid relationship type set for fast lookup. */
+const VALID_REL_SET = new Set(types_js_1.VALID_RELATIONSHIP_TYPES);
+async function stageLinks(db, memories, embedFn, dryRun, llm, budget) {
     let autoLinked = 0;
+    let llmClassified = 0;
+    let heuristicFallback = 0;
     let failed = 0;
+    // Phase A: Discovery — collect candidates via vector similarity
+    const candidates = [];
     for (const mem of memories) {
         try {
             const embedding = await embedFn(mem.content);
@@ -500,27 +499,78 @@ async function stageLinks(db, memories, embedFn, dryRun) {
             for (const neighbor of neighbors) {
                 const similarity = 1.0 - neighbor.distance;
                 if (similarity > CONSOLIDATE_LINK_THRESHOLD) {
-                    const relationship = classifyRelationship(mem, neighbor, similarity);
-                    if (!dryRun) {
-                        try {
-                            storage.addLink(db, mem.id, neighbor.id, relationship, similarity);
-                            autoLinked++;
+                    const heuristicType = classifyRelationship(mem, neighbor, similarity);
+                    candidates.push({ source: mem, target: neighbor, similarity, heuristicType });
+                }
+            }
+        }
+        catch {
+            failed++;
+        }
+    }
+    if (candidates.length === 0) {
+        return { auto_linked: 0, llm_classified: 0, heuristic_fallback: 0, failed };
+    }
+    // Phase B: LLM batch classification
+    // Build batches and classify with LLM where budget allows
+    const classifiedTypes = new Array(candidates.length);
+    for (let i = 0; i < candidates.length; i += EDGE_CLASSIFICATION_BATCH_SIZE) {
+        const batch = candidates.slice(i, i + EDGE_CLASSIFICATION_BATCH_SIZE);
+        // Attempt LLM classification if budget allows
+        if (budget.use("edge_classification")) {
+            try {
+                const pairsBlock = batch.map((c, idx) => {
+                    const srcContent = c.source.content.slice(0, 200);
+                    const tgtContent = c.target.content.slice(0, 200);
+                    return `[${idx}] SOURCE: ${c.source.memory_type} | ${c.source.project ?? "global"} | ${srcContent}\n    TARGET: ${c.target.memory_type} | ${c.target.project ?? "global"} | ${tgtContent}\n    similarity: ${c.similarity.toFixed(2)}`;
+                }).join("\n\n");
+                const prompt = (0, prompts_js_1.edgeClassification)(pairsBlock);
+                const raw = await llm.completeFast(prompt, 512);
+                const parsed = parseJsonLenient(raw, []);
+                if (Array.isArray(parsed) && parsed.length > 0) {
+                    for (let j = 0; j < batch.length; j++) {
+                        const llmType = parsed[j];
+                        if (typeof llmType === "string" && VALID_REL_SET.has(llmType)) {
+                            classifiedTypes[i + j] = llmType;
+                            llmClassified++;
                         }
-                        catch {
-                            failed++;
+                        else {
+                            // Invalid type from LLM — fall back to heuristic
+                            classifiedTypes[i + j] = batch[j].heuristicType;
+                            heuristicFallback++;
                         }
                     }
-                    else {
-                        autoLinked++;
-                    }
+                    continue;
                 }
             }
+            catch {
+                // LLM call failed — fall through to heuristic for this batch
+            }
         }
-        catch {
-            failed++;
+        // Budget exhausted or LLM failed — use heuristic for entire batch
+        for (let j = 0; j < batch.length; j++) {
+            classifiedTypes[i + j] = batch[j].heuristicType;
+            heuristicFallback++;
+        }
+    }
+    // Phase C: Store all classified links
+    for (let i = 0; i < candidates.length; i++) {
+        const c = candidates[i];
+        const relationship = classifiedTypes[i];
+        if (!dryRun) {
+            try {
+                storage.addLink(db, c.source.id, c.target.id, relationship, c.similarity);
+                autoLinked++;
+            }
+            catch {
+                failed++;
+            }
+        }
+        else {
+            autoLinked++;
         }
     }
-    return { auto_linked: autoLinked, failed };
+    return { auto_linked: autoLinked, llm_classified: llmClassified, heuristic_fallback: heuristicFallback, failed };
 }
 /**
  * Classify the relationship between two memories based on type, temporal ordering, and similarity.
@@ -660,8 +710,8 @@ async function runConsolidation(db, llm, embedFn, dryRun = false, skipReflection
         }
         // Stage 2.7: Domain Curation
         report.stages.domain_curation = await stageDomainCuration(db, llm, budget, dryRun, stateDir);
-        // Stage 3: Link Discovery
-        report.stages.links = await stageLinks(db, precheck.newMemories, embedFn, dryRun);
+        // Stage 3: Link Discovery (with LLM-assisted edge classification)
+        report.stages.links = await stageLinks(db, precheck.newMemories, embedFn, dryRun, llm, budget);
         // Stage 3.5: Hub Detection — boost highly-connected memories
         report.stages.hub_boost = stageHubBoost(db, dryRun);
         // Stage 4: Decay & Prune

package/dist/db.js

@@ -226,6 +226,30 @@ const MIGRATIONS = [
             db.exec("CREATE INDEX IF NOT EXISTS idx_memories_domain ON memories(domain)");
         },
     },
+    {
+        version: 4,
+        name: "unique_source_session",
+        up: (db) => {
+            // De-duplicate any pre-existing source_session values (e.g. from the
+            // /ingest + /distill race before this migration): keep the oldest row per
+            // source_session, NULL the rest so they lose their dedup key (the memory
+            // itself is preserved). Then add a UNIQUE partial index so the server can
+            // idempotently re-distill a segment without double-inserting.
+            db.exec(`
+        UPDATE memories SET source_session = NULL
+        WHERE rowid NOT IN (
+          SELECT MIN(rowid) FROM memories
+          WHERE source_session IS NOT NULL
+          GROUP BY source_session
+        )
+        AND source_session IS NOT NULL
+      `);
+            db.exec(`
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_source_session_unique
+          ON memories(source_session) WHERE source_session IS NOT NULL
+      `);
+        },
+    },
 ];
 /**
  * Run all pending migrations against the database.

package/dist/embedder.d.ts

@@ -6,6 +6,17 @@
  * installed. The model is lazy-loaded on first call.
  */
 export declare const EMBEDDING_DIMENSIONS = 384;
+/**
+ * Resolve the directory where @huggingface/transformers caches model weights.
+ *
+ * Exported as a pure function so it can be unit-tested without mocking the
+ * dynamic import. The default (`~/.hicortex/models`) is stable across package
+ * upgrades and writable by the installing user even under global npm installs
+ * (where the package dir is root-owned).
+ *
+ * @param home Override for the user home directory (used in tests).
+ */
+export declare function resolveModelCacheDir(home?: string): string;
 /**
  * Embed a single text string. Returns a Float32Array of 384 dimensions.
  */

package/dist/embedder.js

@@ -8,14 +8,31 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMBEDDING_DIMENSIONS = void 0;
+exports.resolveModelCacheDir = resolveModelCacheDir;
 exports.embed = embed;
 exports.embedBatch = embedBatch;
 exports.dimensions = dimensions;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 exports.EMBEDDING_DIMENSIONS = 384;
 const MODEL_NAME = "Xenova/bge-small-en-v1.5";
 // Pipeline is lazy-loaded on first use
 let pipeline = null;
 let initPromise = null;
+/**
+ * Resolve the directory where @huggingface/transformers caches model weights.
+ *
+ * Exported as a pure function so it can be unit-tested without mocking the
+ * dynamic import. The default (`~/.hicortex/models`) is stable across package
+ * upgrades and writable by the installing user even under global npm installs
+ * (where the package dir is root-owned).
+ *
+ * @param home Override for the user home directory (used in tests).
+ */
+function resolveModelCacheDir(home) {
+    return (0, node_path_1.join)(home ?? (0, node_os_1.homedir)(), ".hicortex", "models");
+}
 /**
  * Initialize the embedding pipeline (called lazily on first embed call).
  * Throws with a clear error if @huggingface/transformers is not available.
@@ -32,6 +49,16 @@ async function ensureInit() {
             // Dynamic import — package may not be installed (it's optional)
             // eslint-disable-next-line @typescript-eslint/no-require-imports
             const transformers = await Function('return import("@huggingface/transformers")')();
+            // Point the model cache at a stable user-writable directory so the
+            // ~130 MB weights survive package upgrades and work under global installs
+            // (the package dir is root-owned; defaulting to it causes EACCES).
+            const cacheDir = resolveModelCacheDir();
+            (0, node_fs_1.mkdirSync)(cacheDir, { recursive: true });
+            const env = transformers.env ?? transformers.default?.env;
+            if (env) {
+                env.cacheDir = cacheDir;
+            }
+            console.log(`[hicortex] Model cache: ${cacheDir}`);
             const pipelineFn = transformers.pipeline ?? transformers.default?.pipeline;
             if (!pipelineFn) {
                 throw new Error("Could not find pipeline function in @huggingface/transformers");

package/dist/extensions.d.ts

@@ -1,39 +1,37 @@
 /**
- * Extension interfaces for the OSS/Pro split.
+ * Extension interfaces + default implementations.
  *
- * The OSS client defines these interfaces and ships default implementations
- * (the current behaviour). Pro features (in src/pro/, never published) provide
- * alternative implementations that are loaded at runtime via dynamic import,
- * gated by the license check in features.ts.
+ * Originally the seam for the OSS/Pro split (Pro retired in #122 — the
+ * product is fully featured for everyone). The interfaces and the
+ * setExtensions() override hook remain so alternative implementations can
+ * still be swapped in (tests, future experiments).
  *
- * Why these specific interfaces:
+ *   LessonSelector — lesson selection sites:
+ *     lessons-context.ts:fetchLessonsContext (CC SessionStart hook),
+ *     index.ts:before_agent_start (OC in-process plugin).
+ *     The default is the domain-aware scoring selector (lesson-selection.ts):
+ *     ranks lessons by project match + domain affinity + recency +
+ *     base_strength + access affinity, with prefix-based dedup. Restored
+ *     into core in #123 after being deleted with the Pro loader in #122.
  *
- *   LessonSelector — there are exactly 3 lesson selection sites in the OSS
- *     code (claude-md.ts:injectLessons, index.ts:before_agent_start,
- *     nightly.ts:injectLessonsFromServer). All three currently do
- *     `lessons.slice(0, maxLessons)` after a DB or HTTP fetch. The Pro
- *     selector ranks lessons against project context, recency, and
- *     effectiveness scores instead of dumb-truncating.
- *
- *   PromptStrategy — the current prompts.ts exports three pure functions
- *     (distillation, reflection, importanceScoring). The Pro variant has
- *     prescriptive prompts (`when X do Y` format) and re-trained reflection
- *     that produces a richer schema. The strategy bundles the prompt WITH
- *     its parser so a Pro prompt with a different output schema cannot
- *     silently fail when the OSS consumer parses it with the wrong shape.
+ *   PromptStrategy — prompts.ts exports three pure functions
+ *     (distillation, reflection, importanceScoring). The strategy bundles
+ *     the prompt WITH its parser so a prompt with a different output schema
+ *     cannot silently fail when the consumer parses it with the wrong shape.
  *
  * NOT in this file (deliberately deferred):
  *   - ContextAssembler — over-abstracted; the real seam is buildProjectContext
  *     in claude-md.ts, not the whole assembler. Will add when needed.
- *   - LessonValidator — speculative; no validation exists today. Will add
- *     when the first Pro use case demands it.
+ *   - LessonValidator — speculative; no validation exists today.
  */
 import type { ModuleIndex } from "./types.js";
 /**
  * Minimum fields a lesson must have for the selector to work.
  *
- * The default selector only needs `content`. Pro selectors may need more
- * (project for in-project weighting, base_strength for ranking, etc.).
+ * Only `content` is required. The default (domain-aware) selector uses the
+ * optional fields when present — project for in-project/domain weighting,
+ * created_at for recency, base_strength for importance, access_count for
+ * proven-usefulness — and falls back to neutral scores when absent.
  *
  * Memory satisfies this interface (it's a structural subset), and the
  * client-mode HTTP shape `{content, created_at, base_strength, access_count}`
@@ -52,20 +50,21 @@ export interface SelectableLesson {
 export interface LessonSelectorContext {
     /** Maximum number of lessons to return. Caller decides this from features.lessonsLimit(). */
     maxLessons: number;
-    /** Current project, if known. Pro selectors weight in-project lessons higher. */
+    /** Current project, if known. The default selector weights in-project lessons higher. */
     project?: string | null;
-    /** Optional: agent id, for cross-agent learning context (Pro). */
+    /** Optional: agent id, for cross-agent learning context. */
     agentId?: string;
-    /** Optional: current task description, for relevance scoring (Pro). */
+    /** Optional: current task description, for relevance scoring. */
     currentTask?: string;
-    /** MODULE_INDEX for domain-aware lesson selection (Pro). */
+    /** MODULE_INDEX for domain-aware lesson selection (same-domain projects score 0.5). */
     moduleIndex?: ModuleIndex;
 }
 export interface LessonSelector {
     /**
      * Pick `ctx.maxLessons` lessons from the candidate pool.
-     * Default impl: take the first N (caller passes them in priority order).
-     * Pro impl: rank by relevance to ctx.project / ctx.currentTask / effectiveness.
+     * Default impl: domain-aware scoring (lesson-selection.ts) — ranks by
+     * project match, domain affinity, recency, base_strength, and access
+     * affinity, with prefix-based dedup.
      *
      * Generic so the output type matches the input type — Memory[] in returns
      * Memory[] out, partial-shape in returns partial-shape out.
@@ -73,8 +72,13 @@ export interface LessonSelector {
     select<T extends SelectableLesson>(lessons: T[], ctx: LessonSelectorContext): T[] | Promise<T[]>;
 }
 /**
- * Default LessonSelector — preserves current OSS behaviour exactly.
- * `slice(0, maxLessons)` over the candidate pool, no re-ranking.
+ * Default LessonSelector — the domain-aware scoring selector.
+ *
+ * Ranks lessons by project match (1.0 exact / 0.5 same-domain via moduleIndex
+ * / 0.3 global), recency (30-day half-life), base_strength, and access
+ * affinity; dedups near-identical lessons by normalized prefix. When lessons
+ * carry no metadata, all scores tie and stable sort preserves input order
+ * (equivalent to the old slice(0, N) behaviour).
  */
 export declare const defaultLessonSelector: LessonSelector;
 /** Output schema produced by the reflection prompt and consumed by consolidate.ts. */
@@ -108,69 +112,18 @@ export interface PromptStrategy {
 }
 export declare const defaultPromptStrategy: PromptStrategy;
 /**
- * Holder for the active extension implementations. The OSS client always uses
- * the defaults; Pro features (in src/pro/, loaded via dynamic import) replace
- * these at boot if a valid license is present.
- *
- * Wiring will happen via setExtensions() called from src/pro/ after license
- * validation (not yet implemented in OSS). Until Pro code exists and is loaded,
- * every call site uses the defaults — zero behavioural change for OSS users.
+ * Holder for the active extension implementations. Every install uses the
+ * defaults; setExtensions() remains as an override hook for tests and future
+ * alternative implementations.
  */
 declare let activeExtensions: {
     selector: LessonSelector;
     prompts: PromptStrategy;
 };
-/** Replace the active extensions (called from features.ts when Pro loads). */
+/** Replace the active extensions (override hook — tests, experiments). */
 export declare function setExtensions(ext: Partial<typeof activeExtensions>): void;
-/** Get the active LessonSelector (default unless Pro is loaded). */
+/** Get the active LessonSelector. */
 export declare function getLessonSelector(): LessonSelector;
-/** Get the active PromptStrategy (default unless Pro is loaded). */
+/** Get the active PromptStrategy. */
 export declare function getPromptStrategy(): PromptStrategy;
-/**
- * The object passed to a Pro package's `activate()` function at boot.
- * Pro packages receive this to register their extensions and access OSS
- * runtime APIs they need.
- *
- * Design rationale: Pro code never STATICALLY imports from the OSS client.
- * All runtime access is through this context object. This has two benefits:
- *   1. Pro bundles are self-contained — they don't have `require("../...")`
- *      calls that would break when the tarball is installed to
- *      ~/.hicortex/pro/ at runtime.
- *   2. Pro code can only access what the OSS client exposes here, so the
- *      blast radius of a malicious/buggy Pro release is contained.
- *
- * Type-only imports of `LessonSelector`, `PromptStrategy` etc. in Pro code
- * are fine — they're erased at compile time and produce no runtime imports.
- */
-export interface ProActivationContext {
-    /** Register a lesson selector implementation. */
-    setSelector(selector: LessonSelector): void;
-    /** Register a prompt strategy implementation. */
-    setPrompts(prompts: PromptStrategy): void;
-    /** The version of the OSS host (from package.json). Pro can use this
-     *  to gate features against host compatibility. */
-    hostVersion: string;
-    /** Log through the OSS logging surface so Pro logs get the [hicortex]
-     *  prefix and unified formatting. */
-    log(message: string): void;
-}
-/**
- * The shape Pro packages must export as their default export.
- * See `packages/hicortex/src/pro/index.ts` for the reference impl.
- */
-export interface ProPackage {
-    /** Called once at OSS boot if a Pro license is valid and the Pro
-     *  tarball has been downloaded + extracted. Should register extensions
-     *  via the context and return. Errors abort Pro activation but do not
-     *  abort the OSS host. */
-    activate(ctx: ProActivationContext): void | Promise<void>;
-}
-/**
- * Build an activation context for a Pro package. Called from the Pro
- * loader in features.ts / pro-loader.ts.
- *
- * Keep this function small — it's the ONLY surface a Pro package gets.
- * Expanding it expands the attack surface, so add fields deliberately.
- */
-export declare function createProActivationContext(hostVersion: string): ProActivationContext;
 export {};

package/dist/extensions.js

@@ -1,49 +1,49 @@
 "use strict";
 /**
- * Extension interfaces for the OSS/Pro split.
+ * Extension interfaces + default implementations.
  *
- * The OSS client defines these interfaces and ships default implementations
- * (the current behaviour). Pro features (in src/pro/, never published) provide
- * alternative implementations that are loaded at runtime via dynamic import,
- * gated by the license check in features.ts.
+ * Originally the seam for the OSS/Pro split (Pro retired in #122 — the
+ * product is fully featured for everyone). The interfaces and the
+ * setExtensions() override hook remain so alternative implementations can
+ * still be swapped in (tests, future experiments).
  *
- * Why these specific interfaces:
+ *   LessonSelector — lesson selection sites:
+ *     lessons-context.ts:fetchLessonsContext (CC SessionStart hook),
+ *     index.ts:before_agent_start (OC in-process plugin).
+ *     The default is the domain-aware scoring selector (lesson-selection.ts):
+ *     ranks lessons by project match + domain affinity + recency +
+ *     base_strength + access affinity, with prefix-based dedup. Restored
+ *     into core in #123 after being deleted with the Pro loader in #122.
  *
- *   LessonSelector — there are exactly 3 lesson selection sites in the OSS
- *     code (claude-md.ts:injectLessons, index.ts:before_agent_start,
- *     nightly.ts:injectLessonsFromServer). All three currently do
- *     `lessons.slice(0, maxLessons)` after a DB or HTTP fetch. The Pro
- *     selector ranks lessons against project context, recency, and
- *     effectiveness scores instead of dumb-truncating.
- *
- *   PromptStrategy — the current prompts.ts exports three pure functions
- *     (distillation, reflection, importanceScoring). The Pro variant has
- *     prescriptive prompts (`when X do Y` format) and re-trained reflection
- *     that produces a richer schema. The strategy bundles the prompt WITH
- *     its parser so a Pro prompt with a different output schema cannot
- *     silently fail when the OSS consumer parses it with the wrong shape.
+ *   PromptStrategy — prompts.ts exports three pure functions
+ *     (distillation, reflection, importanceScoring). The strategy bundles
+ *     the prompt WITH its parser so a prompt with a different output schema
+ *     cannot silently fail when the consumer parses it with the wrong shape.
  *
  * NOT in this file (deliberately deferred):
  *   - ContextAssembler — over-abstracted; the real seam is buildProjectContext
  *     in claude-md.ts, not the whole assembler. Will add when needed.
- *   - LessonValidator — speculative; no validation exists today. Will add
- *     when the first Pro use case demands it.
+ *   - LessonValidator — speculative; no validation exists today.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultPromptStrategy = exports.defaultLessonSelector = void 0;
 exports.setExtensions = setExtensions;
 exports.getLessonSelector = getLessonSelector;
 exports.getPromptStrategy = getPromptStrategy;
-exports.createProActivationContext = createProActivationContext;
+// The domain-aware scoring selector is THE default for every install.
+// (lesson-selection.ts only imports types from this file, so there is no
+// runtime import cycle — `import type` is erased at compile time.)
+const lesson_selection_js_1 = require("./lesson-selection.js");
 /**
- * Default LessonSelector — preserves current OSS behaviour exactly.
- * `slice(0, maxLessons)` over the candidate pool, no re-ranking.
+ * Default LessonSelector — the domain-aware scoring selector.
+ *
+ * Ranks lessons by project match (1.0 exact / 0.5 same-domain via moduleIndex
+ * / 0.3 global), recency (30-day half-life), base_strength, and access
+ * affinity; dedups near-identical lessons by normalized prefix. When lessons
+ * carry no metadata, all scores tie and stable sort preserves input order
+ * (equivalent to the old slice(0, N) behaviour).
  */
-exports.defaultLessonSelector = {
-    select(lessons, ctx) {
-        return lessons.slice(0, ctx.maxLessons);
-    },
-};
+exports.defaultLessonSelector = lesson_selection_js_1.domainAwareLessonSelector;
 // ---------------------------------------------------------------------------
 // Default PromptStrategy — wraps the current prompts.ts and the lenient JSON
 // parser from consolidate.ts. Preserves current OSS behaviour exactly.
@@ -126,51 +126,26 @@ exports.defaultPromptStrategy = {
     },
 };
 // ---------------------------------------------------------------------------
-// Loader — used by call sites to get either the OSS default or a Pro override
+// Loader — used by call sites to get the active implementations
 // ---------------------------------------------------------------------------
 /**
- * Holder for the active extension implementations. The OSS client always uses
- * the defaults; Pro features (in src/pro/, loaded via dynamic import) replace
- * these at boot if a valid license is present.
- *
- * Wiring will happen via setExtensions() called from src/pro/ after license
- * validation (not yet implemented in OSS). Until Pro code exists and is loaded,
- * every call site uses the defaults — zero behavioural change for OSS users.
+ * Holder for the active extension implementations. Every install uses the
+ * defaults; setExtensions() remains as an override hook for tests and future
+ * alternative implementations.
  */
 let activeExtensions = {
     selector: exports.defaultLessonSelector,
     prompts: exports.defaultPromptStrategy,
 };
-/** Replace the active extensions (called from features.ts when Pro loads). */
+/** Replace the active extensions (override hook — tests, experiments). */
 function setExtensions(ext) {
     activeExtensions = { ...activeExtensions, ...ext };
 }
-/** Get the active LessonSelector (default unless Pro is loaded). */
+/** Get the active LessonSelector. */
 function getLessonSelector() {
     return activeExtensions.selector;
 }
-/** Get the active PromptStrategy (default unless Pro is loaded). */
+/** Get the active PromptStrategy. */
 function getPromptStrategy() {
     return activeExtensions.prompts;
 }
-/**
- * Build an activation context for a Pro package. Called from the Pro
- * loader in features.ts / pro-loader.ts.
- *
- * Keep this function small — it's the ONLY surface a Pro package gets.
- * Expanding it expands the attack surface, so add fields deliberately.
- */
-function createProActivationContext(hostVersion) {
-    return {
-        setSelector(selector) {
-            activeExtensions = { ...activeExtensions, selector };
-        },
-        setPrompts(prompts) {
-            activeExtensions = { ...activeExtensions, prompts };
-        },
-        hostVersion,
-        log(message) {
-            console.log(`[hicortex][pro] ${message}`);
-        },
-    };
-}

package/dist/features.d.ts

@@ -1,37 +1,33 @@
 /**
- * Centralized feature gating — single source of truth for tier-dependent values.
+ * Feature gating — all gates removed as of 0.10.0.
  *
- * Why this exists:
- *   - getFeatures() in license.ts was sync but validateLicense was async, creating
- *     a race where Pro users got free-tier features during the validation window.
- *   - License checks were scattered across 8+ call sites with subtly different
- *     handling (e.g., consolidate.ts:308 had a dynamic import in a hot loop to
- *     dodge a circular import).
+ * Personal and noncommercial use is fully featured under the
+ * PolyForm Noncommercial License. Commercial use requires a per-seat
+ * license (see COMMERCIAL.md). There is no technical feature gating;
+ * the license key's only remaining role is the "licensed to <org>"
+ * display in `hicortex status`.
  *
- * All feature decisions now flow through this module. Call initFeatures() once at
- * process boot before serving any requests; sync getters become deterministic.
+ * The functions below are kept as trivial wrappers so call sites
+ * compile without churn. They will be removed entirely in a future
+ * cleanup pass once callers have been audited.
  */
 import type { LicenseInfo } from "./types.js";
 /**
- * Initialize the feature cache. Call ONCE at process boot before any feature
- * gating queries. Race fix:
- *   1. Synchronously load persisted tier from disk (instant, deterministic)
- *   2. If no persisted tier and we have a key, AWAIT first validation
- *   3. If persisted tier exists, kick off background re-validation
- *
- * After this returns, sync getters (isPro, lessonsLimit, etc.) are deterministic
- * and reflect the user's actual tier — no more "free during validation window".
+ * Initialize license display. Call ONCE at process boot.
+ * No feature gates are applied regardless of the validation result.
  */
-export declare function initFeatures(licenseKey: string | undefined, stateDir?: string, hostVersion?: string): Promise<void>;
-/** Are we on a paid tier (Pro, Team, Lifetime)? */
+export declare function initFeatures(licenseKey: string | undefined, stateDir?: string, _hostVersion?: string): Promise<void>;
+/** Returns the validated license info if a key was supplied and validated. */
+export declare function getValidatedLicense(): LicenseInfo | null;
+/** Always false — no memory cap. */
 export declare function isPro(): boolean;
-/** Memory count cap. -1 = unlimited (paid). */
+/** Always -1 (unlimited). */
 export declare function maxMemoriesAllowed(): number;
-/** Has the memory cap been hit? Pass current count from caller. */
-export declare function memoryCapReached(currentCount: number): boolean;
-/** Number of lessons to inject into CLAUDE.md / before_agent_start. */
+/** Always false — no cap is ever reached. */
+export declare function memoryCapReached(_currentCount: number): boolean;
+/** Always 20. */
 export declare function lessonsLimit(): number;
-/** Is remote /ingest allowed? Free + Team yes, Pro (single-machine) no. */
+/** Always true — remote ingest is always allowed. */
 export declare function remoteIngestAllowed(): boolean;
-/** Direct read of the underlying features (for callers that need the full record). */
+/** Direct read of the underlying features record. */
 export declare function getCurrentFeatures(): LicenseInfo["features"];