@gamaze/hicortex 0.10.1 → 0.11.1

package/dist/classify-domains.d.ts

@@ -0,0 +1,98 @@
+/**
+ * `hicortex classify-domains` — deliberate, resumable content-based domain
+ * classification pass over the memories corpus (feat/content-domains).
+ *
+ * The nightly's content-domain stage only files NULL/stale rows incrementally.
+ * This command back-fills the whole corpus on demand, with the same discipline
+ * as `hicortex relink`:
+ *   - Scope: memories ordered by rowid, processed in batches (default 200).
+ *     Default scope = rows whose domain is NULL or not in the configured set.
+ *     `--all` reclassifies EVERY memory.
+ *   - Resumable: `domainCursor` (last fully-committed rowid) persisted in
+ *     state.json after each batch. Interruption never loses more than the
+ *     current batch. `--reset` restarts from rowid 0.
+ *   - Classification: one constrained MULTI-TAG LLM call per memory via the
+ *     CLASSIFY tier (classifyBaseUrl/classifyModel when configured, else the
+ *     reflect tier), same as the nightly. The LLM emits ONLY the ordered tag
+ *     set; per-tag weights come from the domain prototypes (computed once at
+ *     run start) and the PRIMARY (memories.domain) is derived (argmax weight,
+ *     compartment override, LLM order breaking ties) inside
+ *     storage.setMemoryTags. After a completed (non-aborted) run the
+ *     prototypes, all weights, and all primaries are recomputed from the
+ *     final tag sets — same reconsolidation pass as the nightly.
+ *   - No-fit (owner amendment 07.07): an LLM reply of {"tags": []} means no
+ *     configured domain fits — there is NO fallback category. The memory gets
+ *     a WEAK primary (argmax prototype cosine, when >= weakPrimaryFloor) or,
+ *     below the floor, accelerated decay (base_strength halved, domain left
+ *     NULL so later runs re-attempt it). See nofit.ts.
+ *   - LLM pre-flight: the endpoint classification will actually use (when a
+ *     separate Ollama) is probed before any work. If unreachable, abort
+ *     cleanly (nothing written, cursor untouched) — strict, like distill.
+ *   - Infra-error abort (issue #150): if the classifier returns null mid-run
+ *     (endpoint died AFTER preflight), the run aborts after committing
+ *     the last full batch. The failing memory is left completely untouched; the
+ *     cursor sits at the last committed batch so a re-run resumes cleanly.
+ *   - Server-mode only: needs the local DB.
+ *
+ * Requires a `domains` list in ~/.hicortex/config.json — without it there is
+ * nothing to classify into and the command exits with a clear message.
+ */
+import { LlmClient } from "./llm.js";
+import type { EmbedFn } from "./retrieval.js";
+export interface ClassifyDomainsOptions {
+    /** Reclassify EVERY memory, not just NULL/stale-domain rows. */
+    all?: boolean;
+    /** Memories per batch (default 200). Cursor advances per committed batch. */
+    batchSize?: number;
+    /** Ignore the saved cursor and restart from rowid 0. */
+    reset?: boolean;
+    /** DB path override (tests). Defaults to resolveDbPath(). */
+    dbPath?: string;
+    /** State dir override (tests). Defaults to ~/.hicortex. */
+    stateDir?: string;
+    /** LLM override (tests). Bypasses config resolution + preflight. */
+    llm?: LlmClient;
+    /** Config override (tests). Defaults to reading stateDir/config.json. */
+    config?: Record<string, unknown> | null;
+    /**
+     * Embedder override (tests). Used only for domain-description prototype
+     * seeds; defaults to the local ONNX embedder, loaded lazily on first need
+     * (same pattern as relink).
+     */
+    embedFn?: EmbedFn;
+}
+export interface ClassifyDomainsReport {
+    /** Memories examined in this invocation. */
+    scanned: number;
+    /** Memories whose tags were written (primary changed or first-set). */
+    classified: number;
+    /** Memories whose primary was already the classified value (no rewrite). */
+    unchanged: number;
+    /** Memories skipped due to an infra error (classifier returned null). */
+    failed: number;
+    /** No-fit memories that earned a WEAK primary (prototype argmax >= floor). */
+    weakPrimary: number;
+    /** No-fit memories below the floor — untagged, base_strength halved. */
+    noAssociationDecayed: number;
+    /** Batches processed. */
+    batches: number;
+    /** Cursor after this run. */
+    cursor: number;
+    /** Whether the run aborted early on an infra error (classifier null). */
+    aborted: boolean;
+    /** Final per-PRIMARY memory counts (whole corpus, post-run). */
+    byDomain: Record<string, number>;
+    /** Total tag assignments across memory_tags (whole corpus, post-run). */
+    totalTags: number;
+    /** Post-run reconsolidation: memory_tags rows whose weight was recomputed. */
+    weightsRecomputed: number;
+    /** Post-run reconsolidation: memories whose derived primary changed. */
+    primariesUpdated: number;
+}
+/**
+ * Run the classify-domains pass. Returns a structured report.
+ * Throws on unrecoverable setup errors (client mode, no domains, no LLM,
+ * classification endpoint down) — the cursor always reflects the last
+ * committed batch.
+ */
+export declare function runClassifyDomains(options?: ClassifyDomainsOptions): Promise<ClassifyDomainsReport>;

package/dist/classify-domains.js

@@ -0,0 +1,340 @@
+"use strict";
+/**
+ * `hicortex classify-domains` — deliberate, resumable content-based domain
+ * classification pass over the memories corpus (feat/content-domains).
+ *
+ * The nightly's content-domain stage only files NULL/stale rows incrementally.
+ * This command back-fills the whole corpus on demand, with the same discipline
+ * as `hicortex relink`:
+ *   - Scope: memories ordered by rowid, processed in batches (default 200).
+ *     Default scope = rows whose domain is NULL or not in the configured set.
+ *     `--all` reclassifies EVERY memory.
+ *   - Resumable: `domainCursor` (last fully-committed rowid) persisted in
+ *     state.json after each batch. Interruption never loses more than the
+ *     current batch. `--reset` restarts from rowid 0.
+ *   - Classification: one constrained MULTI-TAG LLM call per memory via the
+ *     CLASSIFY tier (classifyBaseUrl/classifyModel when configured, else the
+ *     reflect tier), same as the nightly. The LLM emits ONLY the ordered tag
+ *     set; per-tag weights come from the domain prototypes (computed once at
+ *     run start) and the PRIMARY (memories.domain) is derived (argmax weight,
+ *     compartment override, LLM order breaking ties) inside
+ *     storage.setMemoryTags. After a completed (non-aborted) run the
+ *     prototypes, all weights, and all primaries are recomputed from the
+ *     final tag sets — same reconsolidation pass as the nightly.
+ *   - No-fit (owner amendment 07.07): an LLM reply of {"tags": []} means no
+ *     configured domain fits — there is NO fallback category. The memory gets
+ *     a WEAK primary (argmax prototype cosine, when >= weakPrimaryFloor) or,
+ *     below the floor, accelerated decay (base_strength halved, domain left
+ *     NULL so later runs re-attempt it). See nofit.ts.
+ *   - LLM pre-flight: the endpoint classification will actually use (when a
+ *     separate Ollama) is probed before any work. If unreachable, abort
+ *     cleanly (nothing written, cursor untouched) — strict, like distill.
+ *   - Infra-error abort (issue #150): if the classifier returns null mid-run
+ *     (endpoint died AFTER preflight), the run aborts after committing
+ *     the last full batch. The failing memory is left completely untouched; the
+ *     cursor sits at the last committed batch so a re-run resumes cleanly.
+ *   - Server-mode only: needs the local DB.
+ *
+ * Requires a `domains` list in ~/.hicortex/config.json — without it there is
+ * nothing to classify into and the command exits with a clear message.
+ */
+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.runClassifyDomains = runClassifyDomains;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const db_js_1 = require("./db.js");
+const state_js_1 = require("./state.js");
+const storage = __importStar(require("./storage.js"));
+const llm_js_1 = require("./llm.js");
+const domain_classify_js_1 = require("./domain-classify.js");
+const consolidate_js_1 = require("./consolidate.js");
+const schema_prototypes_js_1 = require("./schema-prototypes.js");
+const nofit_js_1 = require("./nofit.js");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+function readConfig(stateDir) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(stateDir, "config.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Pre-flight the endpoint classification will ACTUALLY use — the classify
+ * tier (classifyModel/classifyBaseUrl) when configured, else the reflect tier.
+ * Target resolution is the pure resolveClassifyProbeTarget (llm.ts), the same
+ * source of truth as the nightly's contentDomainsReady gate.
+ *
+ * Returns null when ready, or a reason string when it is unreachable (caller
+ * aborts clean). Only a separate Ollama endpoint can go unreachable mid-run;
+ * API providers are cloud-reachable.
+ */
+async function preflightClassify(config) {
+    const target = (0, llm_js_1.resolveClassifyProbeTarget)(config);
+    if (!target)
+        return null;
+    const health = await (0, llm_js_1.probeOllamaModel)(target.baseUrl, target.model);
+    if (!health.ok) {
+        return health.reason === "unreachable"
+            ? `${target.tier} endpoint unreachable (${target.baseUrl})`
+            : `${target.tier} model not loaded (${target.model} missing on ${target.baseUrl})`;
+    }
+    return null;
+}
+/**
+ * Run the classify-domains pass. Returns a structured report.
+ * Throws on unrecoverable setup errors (client mode, no domains, no LLM,
+ * classification endpoint down) — the cursor always reflects the last
+ * committed batch.
+ */
+async function runClassifyDomains(options = {}) {
+    const batchSize = options.batchSize ?? 200;
+    const stateDir = options.stateDir ?? HICORTEX_HOME;
+    const all = options.all ?? false;
+    if (!Number.isInteger(batchSize) || batchSize < 1) {
+        throw new Error(`[hicortex] classify-domains: invalid --batch value: ${options.batchSize}`);
+    }
+    const config = options.config !== undefined ? options.config : readConfig(stateDir);
+    // Server-mode only — client installs have no local DB.
+    if (config?.mode === "client") {
+        throw new Error("[hicortex] classify-domains is server-mode only (it needs the local DB). " +
+            `This machine is a client of ${config.serverUrl ?? "a remote server"} — run it on the server.`);
+    }
+    const domains = (0, domain_classify_js_1.parseConfigDomains)(config);
+    if (!domains) {
+        throw new Error("[hicortex] classify-domains needs a `domains` list in ~/.hicortex/config.json. " +
+            'Add e.g. { "domains": [{ "name": "Work", "description": "..." }, ' +
+            '{ "name": "Boating", "description": "..." }] } and re-run. ' +
+            "No fallback bucket is needed — no-fit memories are handled automatically.");
+    }
+    const weakPrimaryFloor = (0, nofit_js_1.resolveWeakPrimaryFloor)(config);
+    // Resolve the LLM (classify tier does the classifying; falls back to reflect).
+    let llm;
+    if (options.llm) {
+        llm = options.llm;
+    }
+    else {
+        const resolved = (0, llm_js_1.resolveSavedLlmConfig)(config);
+        if (!resolved.config) {
+            throw new Error("[hicortex] classify-domains: no LLM configured — run `npx @gamaze/hicortex init`.");
+        }
+        const classifyDown = await preflightClassify(resolved.config);
+        if (classifyDown) {
+            throw new Error(`[hicortex] classify-domains aborted: ${classifyDown}. ` +
+                "Nothing written, cursor untouched — retry when the endpoint is up.");
+        }
+        llm = new llm_js_1.LlmClient(resolved.config);
+    }
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
+    const db = (0, db_js_1.initDb)(dbPath);
+    const report = {
+        scanned: 0,
+        classified: 0,
+        unchanged: 0,
+        failed: 0,
+        weakPrimary: 0,
+        noAssociationDecayed: 0,
+        batches: 0,
+        cursor: 0,
+        aborted: false,
+        byDomain: {},
+        totalTags: 0,
+        weightsRecomputed: 0,
+        primariesUpdated: 0,
+    };
+    try {
+        let cursor = options.reset ? 0 : ((0, state_js_1.loadState)(stateDir).domainCursor ?? 0);
+        report.cursor = cursor;
+        console.log(`[hicortex] classify-domains starting: ${domains.length} domains, ` +
+            `scope ${all ? "ALL" : "null/stale"}, batch ${batchSize}, cursor ${cursor}` +
+            `${options.reset ? " (reset)" : ""}`);
+        // Lazy embedder — only loaded if a domain needs a description seed
+        // (member_count < 5). Same pattern as relink's fallback embedder.
+        let embedFn = options.embedFn ?? null;
+        const getEmbedFn = async () => {
+            if (!embedFn) {
+                const { embed } = await import("./embedder.js");
+                embedFn = embed;
+            }
+            return embedFn;
+        };
+        // Prototypes once at run start — newly classified memories get their
+        // weights from these; the post-run reconsolidation pass refreshes
+        // everything from the final tag sets.
+        const compartments = (0, schema_prototypes_js_1.compartmentSet)(domains);
+        const { prototypes } = await (0, schema_prototypes_js_1.computeDomainPrototypes)(db, domains, getEmbedFn);
+        // Scope filter: default = NULL / not-in-set / no tags yet; --all = everything.
+        const placeholders = domains.map(() => "?").join(", ");
+        const scopeSql = all
+            ? "rowid > ?"
+            : `rowid > ? AND (domain IS NULL OR domain NOT IN (${placeholders}) ` +
+                `OR id NOT IN (SELECT DISTINCT memory_id FROM memory_tags))`;
+        const batchStmt = db.prepare(`SELECT rowid AS __rowid, id, content, project, domain FROM memories
+       WHERE ${scopeSql} ORDER BY rowid ASC LIMIT ?`);
+        // Set true when the classifier returns null (infra error): finish the
+        // current batch's already-classified writes, commit, advance cursor to the
+        // last SUCCESSFULLY-classified row, then stop (the failing row is untouched).
+        let infraAbort = false;
+        for (;;) {
+            const params = all ? [cursor, batchSize] : [cursor, ...domains.map((d) => d.name), batchSize];
+            const rows = batchStmt.all(...params);
+            if (rows.length === 0)
+                break;
+            let batchClassified = 0;
+            let batchUnchanged = 0;
+            let batchWeakPrimary = 0;
+            let batchNoAssociation = 0;
+            let scannedInBatch = 0;
+            // Highest rowid we can safely advance the cursor to (last row we fully
+            // resolved — classified or unchanged — before any infra abort).
+            let committedRowid = cursor;
+            // Classify (network) OUTSIDE the write transaction; collect results.
+            // No-fit resolution (resolveNoFit) is read-only, so it also happens in
+            // the scan phase; only the writes are deferred to the transaction.
+            const writes = [];
+            for (const row of rows) {
+                const result = await (0, domain_classify_js_1.classifyMemoryTags)(row.content, row.project, domains, llm);
+                if (result === null) {
+                    // Infra error — stop scanning; leave this row untouched for retry.
+                    infraAbort = true;
+                    break;
+                }
+                scannedInBatch++;
+                if (result.tags.length === 0) {
+                    // Genuine no-fit (owner amendment 07.07): weak primary from the
+                    // prototype argmax when it clears the floor, else accelerated
+                    // decay. Each rowid is visited at most once per run (cursor is
+                    // strictly increasing), so a run never double-halves.
+                    const resolution = (0, nofit_js_1.resolveNoFit)(db, row.id, domains, prototypes, weakPrimaryFloor);
+                    if (resolution.kind === "weak_primary") {
+                        batchWeakPrimary++;
+                        if (resolution.domain === row.domain)
+                            batchUnchanged++;
+                        else
+                            batchClassified++;
+                    }
+                    else {
+                        batchNoAssociation++;
+                    }
+                    writes.push({ kind: "nofit", id: row.id, resolution });
+                    committedRowid = row.__rowid;
+                    continue;
+                }
+                // Derived primary (argmax weight from the run-start prototypes,
+                // compartment override, LLM order breaking ties) — the same value
+                // setMemoryTags will write below.
+                const weights = (0, schema_prototypes_js_1.computeTagWeights)(db, row.id, result.tags, prototypes);
+                const derived = (0, schema_prototypes_js_1.derivePrimary)(result.tags.map((tag) => ({ tag, weight: weights[tag] ?? null })), compartments);
+                if (derived === row.domain) {
+                    batchUnchanged++;
+                }
+                else {
+                    batchClassified++;
+                }
+                writes.push({ kind: "tags", id: row.id, tags: result.tags, weights });
+                committedRowid = row.__rowid;
+            }
+            // Commit the resolved writes, then persist the cursor at the last fully
+            // resolved rowid (crash-safe + infra-abort-safe: a re-run resumes there).
+            const tx = db.transaction(() => {
+                for (const w of writes) {
+                    if (w.kind === "tags") {
+                        storage.setMemoryTags(db, w.id, w.tags, { weights: w.weights, compartments });
+                    }
+                    else if (w.resolution.kind === "weak_primary") {
+                        (0, nofit_js_1.applyWeakPrimary)(db, w.id, w.resolution.domain, w.resolution.weight, compartments);
+                    }
+                    else {
+                        (0, nofit_js_1.applyNoAssociationDecay)(db, w.id);
+                    }
+                }
+            });
+            tx();
+            (0, state_js_1.updateState)((s) => { s.domainCursor = committedRowid; }, stateDir);
+            report.scanned += scannedInBatch;
+            report.classified += batchClassified;
+            report.unchanged += batchUnchanged;
+            report.weakPrimary += batchWeakPrimary;
+            report.noAssociationDecayed += batchNoAssociation;
+            report.batches++;
+            report.cursor = committedRowid;
+            cursor = committedRowid;
+            console.log(`[hicortex]   batch ${report.batches}: resolved ${scannedInBatch}, ` +
+                `classified ${batchClassified}, unchanged ${batchUnchanged}, ` +
+                `weak-primary ${batchWeakPrimary}, no-association ${batchNoAssociation} ` +
+                `(cursor ${committedRowid})${infraAbort ? " [infra abort]" : ""}`);
+            if (infraAbort) {
+                report.aborted = true;
+                report.failed++;
+                console.warn("[hicortex] classify-domains ABORTED on a classify-endpoint error. " +
+                    "The failing memory is untouched; cursor at last committed batch — re-run when the endpoint is back up.");
+                break;
+            }
+        }
+        // Post-run reconsolidation (same pass as the nightly, skipped on infra
+        // abort — the corpus is partially classified; the next full run or nightly
+        // repairs it): recompute prototypes from the FINAL tag sets, refresh every
+        // weight and derived primary, then rebuild the moduleIndex counts from the
+        // refreshed primaries.
+        if (!report.aborted) {
+            const { prototypes: finalPrototypes } = await (0, schema_prototypes_js_1.computeDomainPrototypes)(db, domains, getEmbedFn);
+            report.weightsRecomputed = (0, schema_prototypes_js_1.recomputeAllTagWeights)(db, finalPrototypes).updated;
+            report.primariesUpdated = (0, schema_prototypes_js_1.refreshPrimaries)(db, domains).updated;
+            (0, consolidate_js_1.rebuildContentModuleIndex)(db, domains, stateDir);
+        }
+        // Final per-PRIMARY counts across the whole corpus.
+        const counts = db
+            .prepare(`SELECT domain, COUNT(*) AS cnt FROM memories WHERE domain IS NOT NULL GROUP BY domain ORDER BY cnt DESC`)
+            .all();
+        for (const c of counts)
+            report.byDomain[c.domain] = c.cnt;
+        // Total tag assignments across memory_tags (multi-label breadth).
+        report.totalTags = db.prepare("SELECT COUNT(*) AS cnt FROM memory_tags").get().cnt;
+        const breakdown = counts.map((c) => `${c.domain}=${c.cnt}`).join(", ") || "none";
+        console.log(`[hicortex] classify-domains ${report.aborted ? "ABORTED" : "complete"}: ` +
+            `${report.scanned} resolved, ${report.classified} (re)filed, ` +
+            `${report.unchanged} unchanged, ${report.weakPrimary} weak-primary, ` +
+            `${report.noAssociationDecayed} no-association decayed, ${report.failed} infra-skipped, ` +
+            `${report.totalTags} total tags, ${report.weightsRecomputed} weights recomputed, ` +
+            `${report.primariesUpdated} primaries updated (hash ${(0, domain_classify_js_1.domainSetHash)(domains).slice(0, 8)})`);
+        console.log(`[hicortex]   by primary: ${breakdown}`);
+        return report;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/cli.d.ts

@@ -8,6 +8,7 @@
  *   nightly    Run capture + consolidate (manual trigger)
  *              nightly --capture-only  Capture only, skip consolidation
  *              nightly --status        Show nightly pipeline health check
+ *   relink     Resumable link-discovery pass over the entire corpus (issue #143)
  *   status     Show config, DB stats, adapter status
  *   uninstall  Clean removal of CC integration
  */

package/dist/cli.js

@@ -9,6 +9,7 @@
  *   nightly    Run capture + consolidate (manual trigger)
  *              nightly --capture-only  Capture only, skip consolidation
  *              nightly --status        Show nightly pipeline health check
+ *   relink     Resumable link-discovery pass over the entire corpus (issue #143)
  *   status     Show config, DB stats, adapter status
  *   uninstall  Clean removal of CC integration
  */
@@ -61,6 +62,58 @@ switch (command) {
         }
         break;
     }
+    case "relink": {
+        const args = process.argv.slice(3);
+        const intFlag = (name) => {
+            const idx = args.indexOf(name);
+            if (idx === -1)
+                return undefined;
+            const val = parseInt(args[idx + 1], 10);
+            if (isNaN(val)) {
+                console.error(`[hicortex] relink: ${name} requires an integer value`);
+                process.exit(1);
+            }
+            return val;
+        };
+        const relinkOptions = {
+            dryRun: args.includes("--dry-run"),
+            reset: args.includes("--reset"),
+            batchSize: intFlag("--batch"),
+        };
+        import("./relink.js").then(({ runRelink }) => {
+            runRelink(relinkOptions).catch((err) => {
+                console.error(err instanceof Error ? err.message : `[hicortex] Relink failed: ${err}`);
+                process.exit(1);
+            });
+        });
+        break;
+    }
+    case "classify-domains": {
+        const args = process.argv.slice(3);
+        const intFlag = (name) => {
+            const idx = args.indexOf(name);
+            if (idx === -1)
+                return undefined;
+            const val = parseInt(args[idx + 1], 10);
+            if (isNaN(val)) {
+                console.error(`[hicortex] classify-domains: ${name} requires an integer value`);
+                process.exit(1);
+            }
+            return val;
+        };
+        const classifyOptions = {
+            all: args.includes("--all"),
+            reset: args.includes("--reset"),
+            batchSize: intFlag("--batch"),
+        };
+        import("./classify-domains.js").then(({ runClassifyDomains }) => {
+            runClassifyDomains(classifyOptions).catch((err) => {
+                console.error(err instanceof Error ? err.message : `[hicortex] classify-domains failed: ${err}`);
+                process.exit(1);
+            });
+        });
+        break;
+    }
     case "status":
         import("./status.js").then(({ runStatus }) => {
             runStatus().catch((err) => {
@@ -99,8 +152,12 @@ Usage: hicortex <command> [options]
 Commands:
   server          Start the MCP HTTP/SSE server (server mode)
   init            Set up Hicortex (server mode, local DB + daemon)
+                  Scaffolds 5 editable default memory domains (Work, Personal,
+                  People, Health, Finance) in ~/.hicortex/config.json
   init --server <url>  Set up as client (remote server)
   nightly         Run nightly denoise + capture + consolidate
+  relink          Resumable link-discovery pass over the ENTIRE corpus (server mode)
+  classify-domains  Backfill content-based domain tags over the corpus (server mode, needs config.domains)
   lessons-context Fetch lessons and print Markdown to stdout (CC SessionStart hook)
   status          Show current configuration and stats
   uninstall       Remove CC integration (preserves DB)
@@ -111,6 +168,12 @@ Options:
   nightly --dry-run         Preview without changes
   nightly --capture-only    Capture only, skip consolidation (safe to run multiple times/day)
   nightly --status          Show nightly pipeline health
+  relink --dry-run          Discovery + counts only, zero writes, cursor untouched
+  relink --batch <n>        Memories per batch (default: 200)
+  relink --reset            Restart from the beginning (ignore saved cursor)
+  classify-domains --all    Reclassify every memory (default: only NULL/stale-domain rows)
+  classify-domains --batch <n>  Memories per batch (default: 200)
+  classify-domains --reset  Restart from the beginning (ignore saved cursor)
 
 Examples:
   npx @gamaze/hicortex server