@gamaze/hicortex 0.10.1 → 0.11.1

package/dist/graph.js

@@ -10,10 +10,13 @@
  * we deal with (hundreds to low thousands of nodes).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPORT_MAX_LIMIT = exports.EXPORT_DEFAULT_LIMIT = void 0;
 exports.louvainCommunities = louvainCommunities;
 exports.detectHubs = detectHubs;
 exports.getNeighbors = getNeighbors;
+exports.exportGraph = exportGraph;
 exports.shortestPath = shortestPath;
+const retrieval_js_1 = require("./retrieval.js");
 function loadGraph(db) {
     const rows = db
         .prepare("SELECT source_id, target_id, strength FROM memory_links")
@@ -210,6 +213,148 @@ function getNeighbors(db, memoryId, limit = 10, relationship) {
     return results;
 }
 // ---------------------------------------------------------------------------
+// Full graph export (for GET /graph?op=export — the /viz page, #124)
+// ---------------------------------------------------------------------------
+// Default shows the whole graph for corpora up to 5k memories (owner request
+// 05.07 — the strongest-500 default hid most edges). Payload note: nodes carry
+// content up to 4000 chars, so 5k nodes can be a several-MB JSON response —
+// acceptable on localhost/LAN, which is the /viz deployment model.
+exports.EXPORT_DEFAULT_LIMIT = 5000;
+exports.EXPORT_MAX_LIMIT = 10000;
+/** First non-empty line of content, capped at 80 chars. */
+function makeLabel(content) {
+    const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? content;
+    return firstLine.trim().slice(0, 80);
+}
+/**
+ * Assemble the full node/edge payload for the /viz page.
+ *
+ * Nodes are ranked by effective (decayed) strength and capped at `limit`.
+ * Edges include only links where BOTH endpoints made the cut.
+ * Link counts come from one aggregate query over memory_links (no per-row
+ * queries) and feed both the effectiveStrength hardening term and the
+ * per-node linkCount field.
+ */
+function exportGraph(db, options = {}) {
+    const limit = Math.min(Math.max(Math.floor(options.limit ?? exports.EXPORT_DEFAULT_LIMIT), 1), exports.EXPORT_MAX_LIMIT);
+    const now = new Date();
+    // Per-memory link counts — single aggregate query (same shape as detectHubs)
+    const linkCountRows = db
+        .prepare(`SELECT id, COUNT(*) as cnt FROM (
+         SELECT source_id AS id FROM memory_links
+         UNION ALL
+         SELECT target_id AS id FROM memory_links
+       ) GROUP BY id`)
+        .all();
+    const linkCounts = new Map(linkCountRows.map((r) => [r.id, r.cnt]));
+    // Candidate memories — domain/type filters pushed into SQL
+    let sql = `SELECT id, content, memory_type, domain, project, base_strength,
+            last_accessed, access_count, created_at
+     FROM memories`;
+    const where = [];
+    const params = [];
+    if (options.domain) {
+        where.push("domain = ?");
+        params.push(options.domain);
+    }
+    if (options.type) {
+        where.push("memory_type = ?");
+        params.push(options.type);
+    }
+    if (options.tag) {
+        // Tag match (any weight) OR the domain fallback for never-multi-tagged
+        // rows — consistent with the tags payload fallback below.
+        where.push(`(id IN (SELECT memory_id FROM memory_tags WHERE tag = ?)
+        OR (domain = ? AND id NOT IN (SELECT DISTINCT memory_id FROM memory_tags)))`);
+        params.push(options.tag, options.tag);
+    }
+    if (where.length > 0)
+        sql += ` WHERE ${where.join(" AND ")}`;
+    const rows = db.prepare(sql).all(...params);
+    const hubIds = new Set(detectHubs(db).map((h) => h.id));
+    // Score, filter on effective strength, rank, cap
+    const scored = rows.map((row) => {
+        const linkCount = linkCounts.get(row.id) ?? 0;
+        const strength = (0, retrieval_js_1.effectiveStrength)(row.base_strength ?? 0.5, row.last_accessed, now, { accessCount: row.access_count ?? 0, linkCount });
+        return { row, strength, linkCount };
+    });
+    const filtered = options.minStrength !== undefined
+        ? scored.filter((s) => s.strength >= options.minStrength)
+        : scored;
+    filtered.sort((a, b) => b.strength - a.strength);
+    const top = filtered.slice(0, limit);
+    // Multi-label tags (graded-schema spec) — fetch only for the capped node
+    // set. One query keyed on the included ids; grouped into per-node parallel
+    // arrays ORDERED BY WEIGHT DESC (NULL weights last, in insertion/relevance
+    // order). The derived primary remains on `domain` (the colour); `tags` is
+    // the full set, `tagWeights` the parallel association weights (rounded 4dp;
+    // 0 for NULL/not-yet-computed).
+    const topIds = top.map((t) => t.row.id);
+    const tagsByMemory = new Map();
+    if (topIds.length > 0) {
+        const idPlaceholders = topIds.map(() => "?").join(", ");
+        const tagRows = db
+            .prepare(`SELECT memory_id, tag, weight FROM memory_tags
+         WHERE memory_id IN (${idPlaceholders})
+         ORDER BY memory_id, (weight IS NULL) ASC, weight DESC, rowid ASC`)
+            .all(...topIds);
+        for (const r of tagRows) {
+            const arr = tagsByMemory.get(r.memory_id);
+            const entry = { tag: r.tag, weight: r.weight };
+            if (arr)
+                arr.push(entry);
+            else
+                tagsByMemory.set(r.memory_id, [entry]);
+        }
+    }
+    const nodes = top.map(({ row, strength, linkCount }) => {
+        const weighted = tagsByMemory.get(row.id)
+            ?? (row.domain ? [{ tag: row.domain, weight: null }] : []);
+        return {
+            id: row.id,
+            label: makeLabel(row.content),
+            content: row.content.slice(0, 4000),
+            memory_type: row.memory_type,
+            domain: row.domain,
+            tags: weighted.map((w) => w.tag),
+            tagWeights: weighted.map((w) => (w.weight == null ? 0 : Math.round(w.weight * 10000) / 10000)),
+            project: row.project,
+            strength: Math.round(strength * 10000) / 10000,
+            linkCount,
+            isHub: hubIds.has(row.id),
+            created_at: row.created_at,
+        };
+    });
+    // Edges — only where both endpoints are in the included set
+    const included = new Set(nodes.map((n) => n.id));
+    const linkRows = db
+        .prepare("SELECT source_id, target_id, relationship, strength FROM memory_links")
+        .all();
+    const edges = linkRows
+        .filter((l) => included.has(l.source_id) && included.has(l.target_id))
+        .map((l) => ({
+        source: l.source_id,
+        target: l.target_id,
+        relationship: l.relationship,
+        strength: l.strength,
+    }));
+    // Filter dropdown values — distinct across the WHOLE DB, not the shown subset
+    const domains = db
+        .prepare("SELECT DISTINCT domain FROM memories WHERE domain IS NOT NULL AND domain != '' ORDER BY domain")
+        .all().map((r) => r.domain);
+    const types = db
+        .prepare("SELECT DISTINCT memory_type FROM memories WHERE memory_type IS NOT NULL AND memory_type != '' ORDER BY memory_type")
+        .all().map((r) => r.memory_type);
+    const total = db.prepare("SELECT COUNT(*) as cnt FROM memories").get().cnt;
+    return {
+        nodes,
+        edges,
+        domains,
+        types,
+        meta: { total, shown: nodes.length, edgeCount: edges.length },
+    };
+}
+// ---------------------------------------------------------------------------
 // Shortest path (for MCP tool)
 // ---------------------------------------------------------------------------
 function shortestPath(db, fromId, toId, maxDepth = 5) {

package/dist/index.js

@@ -333,7 +333,7 @@ exports.default = {
                     target_id: { type: "string", description: "Target memory ID (required for path operation)" },
                     limit: { type: "number", description: "Max results (default 10)" },
                     domain: { type: "string", description: "Filter hubs by domain" },
-                    relationship: { type: "string", description: "Filter neighbors by relationship type (e.g., CONTRADICTS, SUPERSEDES, derives)" },
+                    relationship: { type: "string", description: "Filter neighbors by relationship type (e.g., extends, relates_to; legacy data may also have CONTRADICTS, SUPERSEDES, updates)" },
                 },
                 required: ["operation"],
             },

package/dist/init.d.ts

@@ -15,6 +15,7 @@
  *   - Strip old static CLAUDE.md learnings block if present
  *   - Install CC custom commands (/learn, /hicortex-activate)
  */
+import type { DomainDef } from "./types.js";
 /**
  * Parse a KEY=VALUE env file (e.g. ~/.hermes/.env or ~/.claude/settings.json env block).
  * Handles: comments (#), quoted values, empty lines.
@@ -36,6 +37,30 @@ export declare function persistAuthToken(configPath: string): {
     token: string;
     generated: boolean;
 };
+/**
+ * Generic default memory domains scaffolded by server-mode init (issue #150).
+ * Deliberately broad, high-level spheres — an editable STARTING POINT, not a
+ * taxonomy. Users narrow or replace them to match how THEY think (life areas
+ * or project/topic areas both work). There is NO fallback category: a no-fit
+ * memory is handled automatically by the weak-primary floor + decay lifecycle
+ * (see nofit.ts) — never by a catch-all domain.
+ */
+export declare const GENERIC_DEFAULT_DOMAINS: DomainDef[];
+/**
+ * Scaffold the generic default `domains` list into config.json (server mode).
+ *
+ * Non-clobber (same philosophy as persistAuthToken): only writes when the
+ * config has NO `domains` key at all. An existing key — even an empty array —
+ * is user-owned and is never touched. Upgrading installs that re-run init get
+ * the scaffold too (they have no `domains` key yet); installs that never
+ * re-run init keep the legacy project-grouping behaviour.
+ *
+ * Prints its own hint lines (tested); returns whether it wrote the scaffold.
+ * Exported for testability.
+ */
+export declare function scaffoldDefaultDomains(configPath: string): {
+    scaffolded: boolean;
+};
 /**
  * Install (or verify) the CC SessionStart hook that runs `hicortex lessons-context`.
  * The hook fetches lessons from the configured server at session start and injects

package/dist/init.js

@@ -17,9 +17,11 @@
  *   - Install CC custom commands (/learn, /hicortex-activate)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERIC_DEFAULT_DOMAINS = void 0;
 exports.parseEnvFile = parseEnvFile;
 exports.generateAuthToken = generateAuthToken;
 exports.persistAuthToken = persistAuthToken;
+exports.scaffoldDefaultDomains = scaffoldDefaultDomains;
 exports.installSessionStartHook = installSessionStartHook;
 exports.runInit = runInit;
 exports.resolveNightlyHour = resolveNightlyHour;
@@ -697,6 +699,52 @@ function persistAuthToken(configPath) {
     (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
     return { token, generated: true };
 }
+/**
+ * Generic default memory domains scaffolded by server-mode init (issue #150).
+ * Deliberately broad, high-level spheres — an editable STARTING POINT, not a
+ * taxonomy. Users narrow or replace them to match how THEY think (life areas
+ * or project/topic areas both work). There is NO fallback category: a no-fit
+ * memory is handled automatically by the weak-primary floor + decay lifecycle
+ * (see nofit.ts) — never by a catch-all domain.
+ */
+exports.GENERIC_DEFAULT_DOMAINS = [
+    { name: "Work", description: "Your job and professional life — employer, clients, workstreams" },
+    { name: "Personal", description: "Private life — home, hobbies, everyday matters" },
+    { name: "People", description: "Relationships — family, friends, social life, network" },
+    { name: "Health", description: "Fitness, wellbeing, medical" },
+    { name: "Finance", description: "Money — budgeting, spending, investing" },
+];
+/**
+ * Scaffold the generic default `domains` list into config.json (server mode).
+ *
+ * Non-clobber (same philosophy as persistAuthToken): only writes when the
+ * config has NO `domains` key at all. An existing key — even an empty array —
+ * is user-owned and is never touched. Upgrading installs that re-run init get
+ * the scaffold too (they have no `domains` key yet); installs that never
+ * re-run init keep the legacy project-grouping behaviour.
+ *
+ * Prints its own hint lines (tested); returns whether it wrote the scaffold.
+ * Exported for testability.
+ */
+function scaffoldDefaultDomains(configPath) {
+    let config = {};
+    try {
+        config = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+    }
+    catch { /* new file */ }
+    if ("domains" in config) {
+        console.log("  ✓ Memory domains already configured — leaving your list as-is");
+        return { scaffolded: false };
+    }
+    config.domains = exports.GENERIC_DEFAULT_DOMAINS;
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(configPath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(configPath, JSON.stringify(config, null, 2));
+    const names = exports.GENERIC_DEFAULT_DOMAINS.map((d) => d.name).join(", ");
+    console.log(`  ✓ Memory domains scaffolded in ${configPath}`);
+    console.log(`    Defaults: ${names}. Edit the \`domains\` list to match how YOU think —`);
+    console.log(`    they can be life areas OR project/topic areas (see domains.example.json in the package).`);
+    return { scaffolded: true };
+}
 /**
  * Determine the npm package specifier for the daemon.
  * Uses tag-based resolution so restarts pick up new versions automatically.
@@ -1005,6 +1053,12 @@ async function runInit(options = {}) {
     else {
         console.log(`  ✓ Auth token already configured`);
     }
+    // Scaffold the generic default memory domains (server mode only — domains
+    // live in the server's config; a client's memories are classified by the
+    // server). Non-clobber: an existing `domains` key is never touched.
+    // Classification activates automatically once an LLM is configured; until
+    // then domains sit inert (strict-skip path).
+    scaffoldDefaultDomains(configPath);
     // Install the nightly job (capture via localhost /distill + consolidation).
     // Without it a server-mode install never captures or consolidates — the
     // daemon only serves recall + /distill. Skips if a schedule already exists.

package/dist/lesson-selection.js

@@ -69,14 +69,21 @@ function parseDate(ts) {
     const d = new Date(ts);
     return isNaN(d.getTime()) ? null : d;
 }
-function projectMatch(lesson, targetProject, moduleIndex) {
-    if (!lesson.project)
-        return 0.0;
+function projectMatch(lesson, targetProject, moduleIndex, targetDomainName) {
     if (targetProject && lesson.project === targetProject)
         return 1.0;
     if (lesson.project === "global")
         return 0.3;
-    // Domain-aware: same domain = 0.5
+    // Content-mode same-domain boost: when the caller knows the current
+    // life-sphere domain, a lesson filed into the SAME domain scores 0.5.
+    // This is the content-classification analogue of the project-grouping
+    // moduleIndex boost below. Keyed on lesson.domain directly (no project map).
+    if (targetDomainName && lesson.domain && lesson.domain === targetDomainName) {
+        return 0.5;
+    }
+    if (!lesson.project)
+        return 0.0;
+    // Project-grouping same-domain boost: same domain via moduleIndex = 0.5.
     if (targetProject && moduleIndex) {
         const targetDomain = moduleIndex.domains.find((d) => d.projects.includes(targetProject));
         if (targetDomain && targetDomain.projects.includes(lesson.project)) {
@@ -129,7 +136,7 @@ exports.domainAwareLessonSelector = {
         const now = new Date();
         // Score every lesson
         const scored = lessons.map((lesson) => {
-            const pMatch = projectMatch(lesson, ctx.project, ctx.moduleIndex);
+            const pMatch = projectMatch(lesson, ctx.project, ctx.moduleIndex, ctx.domain);
             const rScore = recencyScore(lesson, now);
             const sScore = lesson.base_strength ?? 0.5;
             const aScore = accessAffinity(lesson);

package/dist/lessons-context.js

@@ -83,7 +83,8 @@ async function fetchLessonsContext() {
         for (const domain of moduleIndex.domains) {
             const kwStr = domain.keywords.length > 0 ? `: ${domain.keywords.join(", ")}` : "";
             parts.push(`${domain.name} (${domain.memoryCount} memories, ${domain.lessonCount} lessons)${kwStr}`);
-            parts.push(`  ${domain.projects.join(" | ")}`);
+            if (domain.projects.length > 0)
+                parts.push(`  ${domain.projects.join(" | ")}`);
         }
         parts.push(`${index.total} memories, ${index.lessonCount} lessons, ${index.sourceCount} agents. Search with \`hicortex_search\`.`);
     }

package/dist/llm.d.ts

@@ -29,6 +29,21 @@ export interface LlmConfig {
     reflectBaseUrl?: string;
     reflectApiKey?: string;
     reflectProvider?: string;
+    /**
+     * Optional separate model for memory tag classification (defaults to the
+     * reflect tier when unset — zero behavior change for existing installs).
+     * Chosen after an A/B benchmark where a dedicated classifier model
+     * materially outperformed the reflect model on this task.
+     */
+    classifyModel?: string;
+    /**
+     * Optional separate endpoint for classification. When only classifyModel is
+     * set, the classify model runs on the reflect endpoint (or the base endpoint
+     * when no reflect endpoint is configured).
+     */
+    classifyBaseUrl?: string;
+    classifyApiKey?: string;
+    classifyProvider?: string;
 }
 /**
  * Resolve LLM configuration from explicit config-file overrides or
@@ -53,6 +68,46 @@ export declare function resolveExplicitLlmConfig(overrides?: {
  * the transition for any lingering call sites — remove after 0.10.0 ships.
  */
 export declare const resolveLlmConfigForCC: typeof resolveExplicitLlmConfig;
+/**
+ * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
+ *
+ * This is the SINGLE config path used by pipeline runs (nightly consolidation
+ * and `hicortex relink`): named backends (claude-cli, ollama) first, then the
+ * explicit-config/env fallthrough via resolveExplicitLlmConfig, then the
+ * reflect endpoint overlay. Extracted verbatim from nightly.ts — behavior
+ * is identical to the pre-0.11 inline block.
+ *
+ * Returns `reason: "claude_binary_missing"` when claude-cli is configured but
+ * the binary can't be found, so callers can log a context-specific message.
+ */
+export declare function resolveSavedLlmConfig(savedConfig: Record<string, unknown> | null): {
+    config: LlmConfig | null;
+    reason?: "claude_binary_missing";
+};
+/**
+ * Endpoint + model that memory tag classification will ACTUALLY use, for
+ * pre-flight probing. Pure function — the single source of truth shared by
+ * the nightly's contentDomainsReady gate and `hicortex classify-domains`.
+ *
+ * Mirrors LlmClient.completeClassify's routing:
+ *   - classify tier configured (classifyModel and/or classifyBaseUrl) →
+ *     classifyBaseUrl ?? reflectBaseUrl, classifyModel ?? reflectModel
+ *   - classify tier absent → the reflect tier (reflectBaseUrl/reflectModel),
+ *     exactly what completeReflect uses
+ *
+ * Returns null when no probe applies: only a SEPARATE Ollama endpoint can go
+ * unreachable mid-run (API providers are cloud-reachable; the base endpoint
+ * is not pre-flighted anywhere, matching distill/reflect behavior).
+ *
+ * `tier` tells callers which configuration produced the target — "reflect"
+ * means the classification probe is identical to the reflect-stage probe and
+ * its result can be reused.
+ */
+export declare function resolveClassifyProbeTarget(config: LlmConfig): {
+    tier: "classify" | "reflect";
+    baseUrl: string;
+    model: string;
+} | null;
 /**
  * Find the claude CLI binary. Returns the full path or null.
  */
@@ -132,6 +187,18 @@ export declare class LlmClient {
      * Routes to distillBaseUrl/distillProvider if configured (e.g. remote Ollama with faster model).
      */
     completeDistill(prompt: string, maxTokens?: number): Promise<string>;
+    /**
+     * Classification-tier completion (memory tag classification).
+     *
+     * Routing (same "optional dedicated model+baseUrl with fallback" pattern as
+     * completeDistill; Ollama calls inherit think:false via completeOllama):
+     *   - Neither classifyModel nor classifyBaseUrl set → delegate to
+     *     completeReflect (exactly the pre-classify-tier behavior).
+     *   - classifyBaseUrl set → that endpoint, model classifyModel ?? reflectModel.
+     *   - Only classifyModel set → the classify model on the reflect endpoint
+     *     when one is configured, else on the base endpoint.
+     */
+    completeClassify(prompt: string, maxTokens?: number): Promise<string>;
     /**
      * Complete with overridden baseUrl/apiKey/provider (used for reflect tier with separate endpoint).
      * Creates a temporary LlmClient to avoid mutating shared config under concurrent calls.

package/dist/llm.js

@@ -17,6 +17,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LlmClient = exports.RateLimitError = exports.resolveLlmConfigForCC = void 0;
 exports.resolveExplicitLlmConfig = resolveExplicitLlmConfig;
+exports.resolveSavedLlmConfig = resolveSavedLlmConfig;
+exports.resolveClassifyProbeTarget = resolveClassifyProbeTarget;
 exports.findClaudeBinary = findClaudeBinary;
 exports.claudeCliConfig = claudeCliConfig;
 exports.probeOllama = probeOllama;
@@ -68,6 +70,102 @@ function resolveExplicitLlmConfig(overrides) {
  * the transition for any lingering call sites — remove after 0.10.0 ships.
  */
 exports.resolveLlmConfigForCC = resolveExplicitLlmConfig;
+/**
+ * Resolve an LlmConfig from a saved ~/.hicortex/config.json object.
+ *
+ * This is the SINGLE config path used by pipeline runs (nightly consolidation
+ * and `hicortex relink`): named backends (claude-cli, ollama) first, then the
+ * explicit-config/env fallthrough via resolveExplicitLlmConfig, then the
+ * reflect endpoint overlay. Extracted verbatim from nightly.ts — behavior
+ * is identical to the pre-0.11 inline block.
+ *
+ * Returns `reason: "claude_binary_missing"` when claude-cli is configured but
+ * the binary can't be found, so callers can log a context-specific message.
+ */
+function resolveSavedLlmConfig(savedConfig) {
+    let llmConfig = null;
+    if (savedConfig?.llmBackend === "claude-cli") {
+        const claudePath = findClaudeBinary();
+        if (claudePath) {
+            llmConfig = claudeCliConfig(claudePath);
+        }
+        else {
+            return { config: null, reason: "claude_binary_missing" };
+        }
+    }
+    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 = 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;
+    }
+    // Optional classify tier (memory tag classification). Same overlay pattern
+    // as distillModel/distillBaseUrl: when absent, completeClassify falls back
+    // to the reflect tier — zero behavior change for existing installs.
+    if (llmConfig && savedConfig?.classifyModel) {
+        llmConfig.classifyModel = savedConfig.classifyModel;
+    }
+    if (llmConfig && savedConfig?.classifyBaseUrl) {
+        llmConfig.classifyBaseUrl = savedConfig.classifyBaseUrl;
+        llmConfig.classifyApiKey = savedConfig.classifyApiKey ?? llmConfig.apiKey;
+        llmConfig.classifyProvider = savedConfig.classifyProvider ?? llmConfig.provider;
+    }
+    return { config: llmConfig };
+}
+/**
+ * Endpoint + model that memory tag classification will ACTUALLY use, for
+ * pre-flight probing. Pure function — the single source of truth shared by
+ * the nightly's contentDomainsReady gate and `hicortex classify-domains`.
+ *
+ * Mirrors LlmClient.completeClassify's routing:
+ *   - classify tier configured (classifyModel and/or classifyBaseUrl) →
+ *     classifyBaseUrl ?? reflectBaseUrl, classifyModel ?? reflectModel
+ *   - classify tier absent → the reflect tier (reflectBaseUrl/reflectModel),
+ *     exactly what completeReflect uses
+ *
+ * Returns null when no probe applies: only a SEPARATE Ollama endpoint can go
+ * unreachable mid-run (API providers are cloud-reachable; the base endpoint
+ * is not pre-flighted anywhere, matching distill/reflect behavior).
+ *
+ * `tier` tells callers which configuration produced the target — "reflect"
+ * means the classification probe is identical to the reflect-stage probe and
+ * its result can be reused.
+ */
+function resolveClassifyProbeTarget(config) {
+    const classifyConfigured = Boolean(config.classifyModel || config.classifyBaseUrl);
+    if (classifyConfigured) {
+        const baseUrl = config.classifyBaseUrl ?? config.reflectBaseUrl;
+        const model = config.classifyModel ?? config.reflectModel;
+        const provider = config.classifyBaseUrl
+            ? (config.classifyProvider ?? config.provider)
+            : (config.reflectProvider ?? config.provider); // riding the reflect endpoint
+        if (baseUrl && provider === "ollama") {
+            return { tier: "classify", baseUrl, model };
+        }
+        return null; // base endpoint or API provider — no probe
+    }
+    // Classify tier absent — classification delegates to completeReflect.
+    if (config.reflectBaseUrl && (config.reflectProvider ?? config.provider) === "ollama") {
+        return { tier: "reflect", baseUrl: config.reflectBaseUrl, model: config.reflectModel ?? config.model };
+    }
+    return null;
+}
 function detectProvider(url) {
     const u = url.toLowerCase();
     if (u.includes("ollama") || u.includes(":11434"))
@@ -298,6 +396,30 @@ class LlmClient {
         }
         return this.complete(this.config.distillModel ?? this.config.model, prompt, maxTokens, 900_000);
     }
+    /**
+     * Classification-tier completion (memory tag classification).
+     *
+     * Routing (same "optional dedicated model+baseUrl with fallback" pattern as
+     * completeDistill; Ollama calls inherit think:false via completeOllama):
+     *   - Neither classifyModel nor classifyBaseUrl set → delegate to
+     *     completeReflect (exactly the pre-classify-tier behavior).
+     *   - classifyBaseUrl set → that endpoint, model classifyModel ?? reflectModel.
+     *   - Only classifyModel set → the classify model on the reflect endpoint
+     *     when one is configured, else on the base endpoint.
+     */
+    async completeClassify(prompt, maxTokens = 8192) {
+        if (!this.config.classifyModel && !this.config.classifyBaseUrl) {
+            return this.completeReflect(prompt, maxTokens);
+        }
+        const model = this.config.classifyModel ?? this.config.reflectModel;
+        if (this.config.classifyBaseUrl) {
+            return this.completeWithOverride(this.config.classifyBaseUrl, this.config.classifyApiKey ?? this.config.apiKey, this.config.classifyProvider ?? this.config.provider, model, prompt, maxTokens, 900_000);
+        }
+        if (this.config.reflectBaseUrl) {
+            return this.completeWithOverride(this.config.reflectBaseUrl, this.config.reflectApiKey ?? this.config.apiKey, this.config.reflectProvider ?? this.config.provider, model, prompt, maxTokens, 900_000);
+        }
+        return this.complete(model, prompt, maxTokens, 900_000);
+    }
     /**
      * Complete with overridden baseUrl/apiKey/provider (used for reflect tier with separate endpoint).
      * Creates a temporary LlmClient to avoid mutating shared config under concurrent calls.