@gamaze/hicortex 0.7.1 → 0.10.1

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"];

package/dist/features.js

@@ -1,19 +1,20 @@
 "use strict";
 /**
- * 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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initFeatures = initFeatures;
+exports.getValidatedLicense = getValidatedLicense;
 exports.isPro = isPro;
 exports.maxMemoriesAllowed = maxMemoriesAllowed;
 exports.memoryCapReached = memoryCapReached;
@@ -25,117 +26,80 @@ const node_os_1 = require("node:os");
 const license_js_1 = require("./license.js");
 const state_js_1 = require("./state.js");
 const DEFAULT_STATE_DIR = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
-const FREE_FEATURES = {
+// A single canonical "full" feature set — no tiers.
+const FULL_FEATURES = {
     reflection: true,
     vectorSearch: true,
-    maxMemories: 250,
+    maxMemories: -1,
     crossAgent: true,
     remoteIngest: true,
 };
-let currentFeatures = FREE_FEATURES;
+let currentFeatures = FULL_FEATURES;
 let initialized = false;
+// Validated license info for display purposes only (no feature gating).
+let validatedLicenseInfo = null;
 function persistTier(stateDir, info) {
     (0, state_js_1.updateState)((s) => {
         s.tier = {
             tier: info.tier,
             validatedAt: new Date().toISOString(),
-            features: info.features,
+            features: FULL_FEATURES,
         };
         return s;
     }, stateDir);
 }
 /**
- * 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.
  */
-async function initFeatures(licenseKey, stateDir = DEFAULT_STATE_DIR, hostVersion = "0.0.0") {
+async function initFeatures(licenseKey, stateDir = DEFAULT_STATE_DIR, _hostVersion = "0.0.0") {
     if (initialized)
         return;
     initialized = true;
-    // Step 1: Load persisted tier from state.json (instant)
-    const persisted = (0, state_js_1.loadState)(stateDir).tier;
-    if (persisted) {
-        currentFeatures = persisted.features;
-    }
-    else {
-        currentFeatures = FREE_FEATURES;
-    }
-    // Step 2: No key → free tier, done. Pro loader is only run for paid tiers.
+    currentFeatures = FULL_FEATURES;
     if (!licenseKey)
         return;
-    // Step 3: Validate
-    if (!persisted) {
-        // First-time: AWAIT validation so the very first request sees the right tier
-        try {
-            const info = await (0, license_js_1.validateLicense)(licenseKey, stateDir);
-            currentFeatures = info.features;
-            if (info.valid) {
-                persistTier(stateDir, info);
-            }
-        }
-        catch {
-            // Validation failed (network, etc.) — stay on free
+    // Validate the key for display purposes only — a failure keeps the server
+    // fully functional.
+    try {
+        const info = await (0, license_js_1.validateLicense)(licenseKey, stateDir);
+        validatedLicenseInfo = info;
+        if (info.valid) {
+            persistTier(stateDir, info);
         }
     }
-    else {
-        // Already have a persisted tier; re-validate in background
-        (0, license_js_1.validateLicense)(licenseKey, stateDir)
-            .then((info) => {
-            currentFeatures = info.features;
-            if (info.valid) {
-                persistTier(stateDir, info);
-            }
-        })
-            .catch(() => {
-            // Keep persisted features
-        });
-    }
-    // Step 4: If the current tier is paid, try to load the Pro extension bundle.
-    // This is best-effort — if loading fails (network, missing tarball, bad
-    // extraction, Pro package throws on activate), OSS defaults remain in effect
-    // and the host keeps running. No user-visible crash.
-    if (isPro()) {
-        try {
-            const { loadPro } = await import("./pro-loader.js");
-            await loadPro(licenseKey, stateDir, hostVersion);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            console.warn(`[hicortex][pro] Pro loader failed to import: ${msg}`);
-        }
+    catch {
+        // Non-fatal — continue fully functional without a validated display tier
     }
 }
+/** Returns the validated license info if a key was supplied and validated. */
+function getValidatedLicense() {
+    return validatedLicenseInfo;
+}
 // ---------------------------------------------------------------------------
-// Public API — sync getters used everywhere in the codebase
+// Public API — kept for call-site compatibility; all return "fully unlocked"
 // ---------------------------------------------------------------------------
-/** Are we on a paid tier (Pro, Team, Lifetime)? */
+/** Always false — no memory cap. */
 function isPro() {
-    return currentFeatures.maxMemories === -1;
+    return true;
 }
-/** Memory count cap. -1 = unlimited (paid). */
+/** Always -1 (unlimited). */
 function maxMemoriesAllowed() {
-    return currentFeatures.maxMemories;
+    return -1;
 }
-/** Has the memory cap been hit? Pass current count from caller. */
-function memoryCapReached(currentCount) {
-    const max = maxMemoriesAllowed();
-    return max > 0 && currentCount >= max;
+/** Always false — no cap is ever reached. */
+function memoryCapReached(_currentCount) {
+    return false;
 }
-/** Number of lessons to inject into CLAUDE.md / before_agent_start. */
+/** Always 20. */
 function lessonsLimit() {
-    return isPro() ? 20 : 10;
+    return 20;
 }
-/** Is remote /ingest allowed? Free + Team yes, Pro (single-machine) no. */
+/** Always true — remote ingest is always allowed. */
 function remoteIngestAllowed() {
-    return currentFeatures.remoteIngest !== false;
+    return true;
 }
-/** Direct read of the underlying features (for callers that need the full record). */
+/** Direct read of the underlying features record. */
 function getCurrentFeatures() {
     return currentFeatures;
 }