@gamaze/hicortex 0.7.0 → 0.10.0

package/dist/mcp-server.js

@@ -61,15 +61,23 @@ const embedder_js_1 = require("./embedder.js");
 const storage = __importStar(require("./storage.js"));
 const graph_js_1 = require("./graph.js");
 const retrieval = __importStar(require("./retrieval.js"));
-const consolidate_js_1 = require("./consolidate.js");
 const seed_lesson_js_1 = require("./seed-lesson.js");
+const distiller_js_1 = require("./distiller.js");
 // ---------------------------------------------------------------------------
 // Server state
 // ---------------------------------------------------------------------------
 let db = null;
 let llm = null;
-let cancelConsolidation = null;
+// llmConfig is module-level so the /distill handler can call resolveDistillFallback
+// without having to read config on every request. null when no LLM is configured.
+let llmConfig = null;
+// distillFallbackMode controls whether a failed remote distill endpoint causes an
+// immediate abort ("strict", default) or a fallback to the base model ("local").
+let distillFallbackMode = "strict";
 let stateDir = "";
+// Cache detectChunkSize results keyed by "<provider>/<model>@<baseUrl>" so we
+// probe each endpoint once per server boot rather than once per /distill request.
+const chunkSizeCache = new Map();
 let VERSION = "0.3.x";
 try {
     const pkg = JSON.parse(require("node:fs").readFileSync(require("node:path").join(__dirname, "..", "package.json"), "utf-8"));
@@ -123,17 +131,6 @@ function createMcpServer() {
     }, async ({ content, project, memory_type }) => {
         if (!db)
             return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
-        if ((0, features_js_1.memoryCapReached)(storage.countMemories(db))) {
-            return {
-                content: [{
-                        type: "text",
-                        text: `Free tier limit reached (${(0, features_js_1.maxMemoriesAllowed)()} memories). ` +
-                            `Your existing memories and lessons still work — search and recall are unaffected. ` +
-                            `New memories won't be saved until you upgrade.\n\n` +
-                            `Upgrade for unlimited usage: https://hicortex.gamaze.com/`
-                    }],
-            };
-        }
         try {
             const embedding = await (0, embedder_js_1.embed)(content);
             const id = storage.insertMemory(db, content, embedding, {
@@ -251,7 +248,8 @@ function createMcpServer() {
         target_id: zod_1.z.string().optional().describe("Target memory ID (required for path operation)"),
         limit: zod_1.z.coerce.number().optional().describe("Max results (default 10)"),
         domain: zod_1.z.string().optional().describe("Filter hubs by domain"),
-    }, async ({ operation, id, target_id, limit: resultLimit, domain: filterDomain }) => {
+        relationship: zod_1.z.string().optional().describe("Filter neighbors by relationship type (e.g., CONTRADICTS, SUPERSEDES, derives)"),
+    }, async ({ operation, id, target_id, limit: resultLimit, domain: filterDomain, relationship: filterRelationship }) => {
         if (!db)
             return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
         try {
@@ -261,7 +259,7 @@ function createMcpServer() {
                 const resolvedId = resolveMemoryId(db, id);
                 if (!resolvedId)
                     return { content: [{ type: "text", text: `Memory not found: ${id}` }], isError: true };
-                const neighbors = (0, graph_js_1.getNeighbors)(db, resolvedId, resultLimit ?? 10);
+                const neighbors = (0, graph_js_1.getNeighbors)(db, resolvedId, resultLimit ?? 10, filterRelationship);
                 if (neighbors.length === 0)
                     return { content: [{ type: "text", text: "No connected memories found." }] };
                 const text = neighbors.map((n) => `[${n.direction}] ${n.relationship} (${n.strength.toFixed(2)})\n  ${n.id.slice(0, 8)} | ${n.project ?? "global"} | ${n.content}`).join("\n\n");
@@ -312,22 +310,19 @@ async function startServer(options = {}) {
     console.log(`[hicortex] Initializing database at ${dbPath}`);
     db = (0, db_js_1.initDb)(dbPath);
     stateDir = require("node:path").dirname(dbPath);
-    // LLM config: check config.json first, then env vars, then claude CLI
+    // LLM config: explicit config only — no silent harness auto-detection.
+    // Named backends (claude-cli, ollama) → immediate config; everything else
+    // goes through resolveExplicitLlmConfig which requires a user-chosen provider.
+    // If nothing is configured: start recall-only with an unmissable warning.
     const savedConfig = readConfigFile(stateDir);
-    let llmConfig;
     if (savedConfig?.llmBackend === "claude-cli") {
         const claudePath = (0, llm_js_1.findClaudeBinary)();
         if (claudePath) {
             llmConfig = (0, llm_js_1.claudeCliConfig)(claudePath);
         }
         else {
-            console.warn("[hicortex] claude-cli configured but claude binary not found, falling back");
-            llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
-                llmBaseUrl: savedConfig?.llmBaseUrl,
-                llmApiKey: savedConfig?.llmApiKey,
-                llmModel: savedConfig?.llmModel,
-                reflectModel: savedConfig?.reflectModel,
-            });
+            console.warn("[hicortex] claude-cli configured but claude binary not found — LLM disabled");
+            llmConfig = null;
         }
     }
     else if (savedConfig?.llmBackend === "ollama") {
@@ -341,36 +336,56 @@ async function startServer(options = {}) {
         };
     }
     else {
-        llmConfig = (0, llm_js_1.resolveLlmConfigForCC)({
+        llmConfig = (0, llm_js_1.resolveExplicitLlmConfig)({
             llmBaseUrl: savedConfig?.llmBaseUrl,
             llmApiKey: savedConfig?.llmApiKey,
             llmModel: savedConfig?.llmModel,
             reflectModel: savedConfig?.reflectModel,
         });
     }
-    // Apply optional distill endpoint (e.g. remote Ollama with faster model)
-    if (savedConfig?.distillModel) {
-        llmConfig.distillModel = savedConfig.distillModel;
-    }
-    if (savedConfig?.distillBaseUrl) {
-        llmConfig.distillBaseUrl = savedConfig.distillBaseUrl;
-        llmConfig.distillApiKey = savedConfig.distillApiKey ?? llmConfig.apiKey;
-        llmConfig.distillProvider = savedConfig.distillProvider ?? llmConfig.provider;
+    if (llmConfig) {
+        // Apply optional distill endpoint (e.g. remote Ollama with faster model)
+        if (savedConfig?.distillModel) {
+            llmConfig.distillModel = savedConfig.distillModel;
+        }
+        if (savedConfig?.distillBaseUrl) {
+            llmConfig.distillBaseUrl = savedConfig.distillBaseUrl;
+            llmConfig.distillApiKey = savedConfig.distillApiKey ?? llmConfig.apiKey;
+            llmConfig.distillProvider = savedConfig.distillProvider ?? llmConfig.provider;
+        }
+        // Apply separate reflect endpoint if configured (e.g. remote Ollama with larger model)
+        if (savedConfig?.reflectBaseUrl) {
+            llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
+            llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
+            llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
+        }
+        // distillFallback: "strict" (default) aborts on remote failure so the session
+        // is retried next run. "local" restores 0.9.0 fallback-to-base-model behavior.
+        const df = savedConfig?.distillFallback;
+        distillFallbackMode = df === "local" ? "local" : "strict";
+        llm = new llm_js_1.LlmClient(llmConfig);
+        const distillInfo = llmConfig.distillBaseUrl
+            ? `${llmConfig.distillProvider}/${llmConfig.distillModel}@${llmConfig.distillBaseUrl}`
+            : llmConfig.distillModel ? llmConfig.distillModel : "";
+        const reflectInfo = llmConfig.reflectBaseUrl
+            ? `${llmConfig.reflectProvider}/${llmConfig.reflectModel}@${llmConfig.reflectBaseUrl}`
+            : llmConfig.reflectModel;
+        console.log(`[hicortex] LLM fast: ${llmConfig.provider}/${llmConfig.model}${distillInfo ? `, distill: ${distillInfo}` : ""}, reflect: ${reflectInfo}`);
     }
-    // Apply separate reflect endpoint if configured (e.g. remote Ollama with larger model)
-    if (savedConfig?.reflectBaseUrl) {
-        llmConfig.reflectBaseUrl = savedConfig.reflectBaseUrl;
-        llmConfig.reflectApiKey = savedConfig.reflectApiKey ?? llmConfig.apiKey;
-        llmConfig.reflectProvider = savedConfig.reflectProvider ?? llmConfig.provider;
+    else {
+        llm = null;
+        console.warn("");
+        console.warn("╔══════════════════════════════════════════════════════════════╗");
+        console.warn("║  NO LLM CONFIGURED — running in recall-only mode            ║");
+        console.warn("║                                                              ║");
+        console.warn("║  search / lessons / context: ENABLED                        ║");
+        console.warn("║  /distill (capture) and consolidation: DISABLED             ║");
+        console.warn("║                                                              ║");
+        console.warn("║  To enable capture, run:                                    ║");
+        console.warn("║    npx @gamaze/hicortex init                                ║");
+        console.warn("╚══════════════════════════════════════════════════════════════╝");
+        console.warn("");
     }
-    llm = new llm_js_1.LlmClient(llmConfig);
-    const distillInfo = llmConfig.distillBaseUrl
-        ? `${llmConfig.distillProvider}/${llmConfig.distillModel}@${llmConfig.distillBaseUrl}`
-        : llmConfig.distillModel ? llmConfig.distillModel : "";
-    const reflectInfo = llmConfig.reflectBaseUrl
-        ? `${llmConfig.reflectProvider}/${llmConfig.reflectModel}@${llmConfig.reflectBaseUrl}`
-        : llmConfig.reflectModel;
-    console.log(`[hicortex] LLM fast: ${llmConfig.provider}/${llmConfig.model}${distillInfo ? `, distill: ${distillInfo}` : ""}, reflect: ${reflectInfo}`);
     // One-time migration of legacy state files (no-op if state.json exists)
     (0, state_js_1.migrateLegacyState)(stateDir);
     // License: read from options, config file, or env var, init feature cache
@@ -381,9 +396,6 @@ async function startServer(options = {}) {
     if (licenseKey) {
         console.log(`[hicortex] License key configured`);
     }
-    // Schedule nightly consolidation
-    const consolidateHour = options.consolidateHour ?? 2;
-    cancelConsolidation = (0, consolidate_js_1.scheduleConsolidation)(db, llm, embedder_js_1.embed, consolidateHour);
     // Seed lesson on first run
     await (0, seed_lesson_js_1.injectSeedLesson)(db);
     // Self-heal: fix pinned version in daemon config
@@ -392,14 +404,19 @@ async function startServer(options = {}) {
     const stats = (0, db_js_1.getStats)(db, dbPath);
     console.log(`[hicortex] Ready: ${stats.memories} memories, ${stats.links} links, ` +
         `${Math.round(stats.db_size_bytes / 1024)} KB`);
-    // Auth token: from config, env var, or default (always-on baseline security)
-    const DEFAULT_AUTH_TOKEN = "hctx-default-token";
+    // Auth token: from config file or HICORTEX_AUTH_TOKEN env var.
+    // No hardcoded default — each server install generates its own token via init.
+    // Localhost connections bypass auth regardless (unchanged).
     const authToken = savedConfig?.authToken
-        ?? process.env.HICORTEX_AUTH_TOKEN
-        ?? DEFAULT_AUTH_TOKEN;
+        ?? process.env.HICORTEX_AUTH_TOKEN;
+    if (!authToken) {
+        console.warn("[hicortex] WARNING: no authToken configured — remote connections will be rejected " +
+            "(localhost still works). Run `npx @gamaze/hicortex init` to generate a token.");
+    }
     // Express app
     const app = (0, express_1.default)();
-    app.use(express_1.default.json());
+    // Raise the body limit — whole-session denoised transcripts exceed the 100 kB default.
+    app.use(express_1.default.json({ limit: "25mb" }));
     // CORS: must be before auth so preflight OPTIONS requests get proper headers
     app.use((req, res, next) => {
         const origin = req.headers.origin;
@@ -416,21 +433,27 @@ async function startServer(options = {}) {
         }
         next();
     });
-    // Optional bearer token auth (skip for /health, OPTIONS, and localhost)
-    if (authToken) {
-        console.log(`[hicortex] Bearer token auth enabled`);
-        app.use((req, res, next) => {
-            if (req.path === "/health")
-                return next();
-            const ip = req.ip ?? req.socket.remoteAddress ?? "";
-            if (ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1")
-                return next();
-            const auth = req.headers.authorization;
-            if (auth === `Bearer ${authToken}`)
-                return next();
-            res.status(401).json({ error: "Unauthorized" });
+    // Bearer token auth — ALWAYS installed, fail-closed. /health, OPTIONS, and
+    // localhost bypass. With no token configured, remote requests are REJECTED
+    // (not open): the default bind is 0.0.0.0, so "no token = no auth" would
+    // expose the whole memory store to the network.
+    console.log(authToken
+        ? `[hicortex] Bearer token auth enabled`
+        : `[hicortex] No auth token configured — remote access DISABLED (localhost only). Run init to generate a token.`);
+    app.use((req, res, next) => {
+        if (req.path === "/health")
+            return next();
+        const ip = req.ip ?? req.socket.remoteAddress ?? "";
+        if (ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1")
+            return next();
+        if (authToken && req.headers.authorization === `Bearer ${authToken}`)
+            return next();
+        res.status(401).json({
+            error: authToken
+                ? "Unauthorized"
+                : "No auth token configured on this server — run `npx @gamaze/hicortex init` on the server, then connect with its token.",
         });
-    }
+    });
     // SSE transport management — each connection gets its own McpServer instance
     const transports = new Map();
     // Health endpoint
@@ -442,7 +465,7 @@ async function startServer(options = {}) {
             memories: s.memories,
             links: s.links,
             db_size_kb: Math.round(s.db_size_bytes / 1024),
-            llm: `${llmConfig.provider}/${llmConfig.model}`,
+            llm: llmConfig ? `${llmConfig.provider}/${llmConfig.model}` : "not configured",
         });
     });
     // REST /lessons — return lessons + memory index for client CLAUDE.md injection
@@ -487,16 +510,6 @@ async function startServer(options = {}) {
             res.status(503).json({ error: "Server not initialized" });
             return;
         }
-        // Pro license blocks remote ingest (upgrade to Team for multi-client)
-        const ip = req.ip ?? req.socket.remoteAddress ?? "";
-        const isLocal = ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
-        if (!isLocal && !(0, features_js_1.remoteIngestAllowed)()) {
-            res.status(403).json({
-                error: "Pro license is single-machine. Upgrade to Team for multi-client remote ingestion.",
-                upgrade: "https://hicortex.gamaze.com/",
-            });
-            return;
-        }
         const { content, source_agent, project, memory_type, privacy, source_session, session_date } = req.body ?? {};
         if (!content || typeof content !== "string") {
             res.status(400).json({ error: "Missing or invalid 'content' field" });
@@ -515,11 +528,6 @@ async function startServer(options = {}) {
                 return;
             }
         }
-        // License check
-        if ((0, features_js_1.memoryCapReached)(storage.countMemories(db))) {
-            res.status(429).json({ error: "Memory limit reached", limit: (0, features_js_1.maxMemoriesAllowed)() });
-            return;
-        }
         try {
             const embedding = await (0, embedder_js_1.embed)(content);
             const id = storage.insertMemory(db, content, embedding, {
@@ -536,6 +544,321 @@ async function startServer(options = {}) {
             res.status(500).json({ error: "Ingestion failed", message: err instanceof Error ? err.message : String(err) });
         }
     });
+    // REST /search — semantic search over the memory store.
+    // Common recall path for adapters (Hermes prefetch, CC push-hook). Stateless GET.
+    app.get("/search", async (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        const query = typeof req.query.query === "string" ? req.query.query.trim() : "";
+        if (!query) {
+            res.status(400).json({ error: "Missing 'query'" });
+            return;
+        }
+        const limit = req.query.limit ? Number(req.query.limit) : 5;
+        const project = typeof req.query.project === "string" && req.query.project ? req.query.project : undefined;
+        const privacy = typeof req.query.privacy === "string" && req.query.privacy
+            ? req.query.privacy.split(",").map((s) => s.trim()).filter(Boolean)
+            : undefined;
+        try {
+            const results = await retrieval.retrieve(db, embedder_js_1.embed, query, { limit, project, privacy });
+            res.json({ results });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // REST /context — recent context memories, optionally filtered by project.
+    app.get("/context", (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        const project = typeof req.query.project === "string" && req.query.project ? req.query.project : undefined;
+        const limit = req.query.limit ? Number(req.query.limit) : 10;
+        const privacy = typeof req.query.privacy === "string" && req.query.privacy
+            ? req.query.privacy.split(",").map((s) => s.trim()).filter(Boolean)
+            : undefined;
+        try {
+            const results = retrieval.searchContext(db, { project, limit, privacy });
+            res.json({ results });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // REST /distill — canonical capture endpoint (0.9.0+).
+    // Every machine (including the server itself) POSTs denoised session text here.
+    // The server distills, embeds, stores. Body limit: 25 MB (raised at app init).
+    //
+    // Accepts text (string, preferred nightly path) OR messages (array, legacy).
+    // Performs session-level dedup when session_id is present without segment_id.
+    // Uses cached detectChunkSize per endpoint so the probe runs once per boot.
+    app.post("/distill", async (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        if (!llm || !llmConfig) {
+            res.status(503).json({ error: "No LLM configured — run npx @gamaze/hicortex init. Session will be retried." });
+            return;
+        }
+        const { text, messages, source_agent, project, session_id, segment_id, session_date, privacy } = req.body ?? {};
+        // Resolve the conversation text from either the pre-denoised string or raw messages array.
+        let conversationText;
+        if (typeof text === "string" && text.length > 0) {
+            conversationText = text;
+        }
+        else if (Array.isArray(messages) && messages.length > 0) {
+            conversationText = (0, distiller_js_1.extractConversationText)(messages);
+        }
+        else {
+            res.status(400).json({ error: "Provide either 'text' (string) or 'messages' (array)" });
+            return;
+        }
+        // Session-level dedup: when session_id is present and this is a whole-session
+        // POST (no segment_id), skip if any chunk of this session is already stored.
+        if (session_id && !segment_id) {
+            // Escape LIKE wildcards — Hermes ids contain "_" (e.g. 20260701_045744_...).
+            const likePrefix = `${session_id.replace(/[\\%_]/g, (m) => "\\" + m)}#%`;
+            const existing = db.prepare("SELECT COUNT(*) as c FROM memories WHERE source_session = ? OR source_session LIKE ? ESCAPE '\\'").get(session_id, likePrefix);
+            if (existing.c > 0) {
+                res.status(200).json({ skipped: true, existing_count: existing.c });
+                return;
+            }
+        }
+        // Pre-flight the distill endpoint. In strict mode (default) a failed remote
+        // probe returns "abort" immediately without mutating llmConfig — the nightly
+        // watermark stays put so the session is re-shipped next run. In "local" mode
+        // the config is mutated to fall back to the base model.
+        const cfg = llmConfig;
+        const distillFallbackStatus = await (0, llm_js_1.resolveDistillFallback)(cfg, distillFallbackMode);
+        if (distillFallbackStatus === "abort") {
+            res.status(503).json({ error: "Distill endpoint unavailable — session will be retried next run" });
+            return;
+        }
+        // Cache detectChunkSize per endpoint so we probe at most once per server boot.
+        const effectiveProvider = cfg.distillProvider ?? cfg.provider;
+        const effectiveModel = cfg.distillModel ?? cfg.model;
+        const effectiveBaseUrl = cfg.distillBaseUrl ?? cfg.baseUrl;
+        const cacheKey = `${effectiveProvider}/${effectiveModel}@${effectiveBaseUrl}`;
+        if (!chunkSizeCache.has(cacheKey)) {
+            chunkSizeCache.set(cacheKey, await (0, distiller_js_1.detectChunkSize)(effectiveProvider, effectiveModel, effectiveBaseUrl));
+        }
+        const chunkSize = chunkSizeCache.get(cacheKey);
+        const date = typeof session_date === "string" && session_date ? session_date : new Date().toISOString().slice(0, 10);
+        // Per-entry idempotency prefix for the legacy segment_id path.
+        const sourcePrefix = session_id
+            ? `${session_id}${segment_id ? `#${segment_id}` : ""}`
+            : undefined;
+        try {
+            const entries = await (0, distiller_js_1.distillSession)(llm, conversationText, project ?? "unknown", date, chunkSize);
+            const ids = [];
+            for (let i = 0; i < entries.length; i++) {
+                const entry = entries[i];
+                if (typeof entry !== "string" || !entry.trim())
+                    continue;
+                const embedding = await (0, embedder_js_1.embed)(entry);
+                const id = storage.insertMemory(db, entry, embedding, {
+                    sourceAgent: source_agent ?? "unknown",
+                    // Per-chunk key: "<session_id>#<i>". The prefix matches the nightly
+                    // dedup check above, so a re-run of the same session is fully idempotent.
+                    sourceSession: sourcePrefix ? `${sourcePrefix}#${i}` : undefined,
+                    project: project ?? undefined,
+                    memoryType: "episode",
+                    privacy: privacy ?? "WORK",
+                    createdAt: new Date(date).toISOString(),
+                });
+                ids.push(id);
+            }
+            res.status(201).json({ ids, distilled: ids.length });
+        }
+        catch (err) {
+            res.status(500).json({ error: "Distillation failed", message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // REST /update — update a memory (and re-embed when content changes).
+    //
+    // NOTE for #124: this endpoint returns the clean {updated: true, id} JSON
+    // shape that the future /viz surface can consume directly — no MCP wrapping.
+    // -------------------------------------------------------------------------
+    app.post("/update", async (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        const { id, content, project, memory_type, privacy } = req.body ?? {};
+        if (!id || typeof id !== "string") {
+            res.status(400).json({ error: "Missing or invalid 'id' field" });
+            return;
+        }
+        const fullId = resolveMemoryId(db, id);
+        if (!fullId) {
+            res.status(404).json({ error: `Memory not found: ${id}` });
+            return;
+        }
+        const fields = {};
+        if (content !== undefined)
+            fields.content = content;
+        if (project !== undefined)
+            fields.project = project;
+        if (memory_type !== undefined)
+            fields.memory_type = memory_type;
+        if (privacy !== undefined)
+            fields.privacy = privacy;
+        if (Object.keys(fields).length === 0) {
+            res.status(400).json({ error: "No fields to update" });
+            return;
+        }
+        const validTypes = ["episode", "lesson", "fact", "decision"];
+        if (memory_type !== undefined && !validTypes.includes(memory_type)) {
+            res.status(400).json({ error: `Invalid memory_type: ${memory_type}` });
+            return;
+        }
+        try {
+            storage.updateMemory(db, fullId, fields);
+            // Re-embed when content changes
+            if (content !== undefined) {
+                const embedding = await (0, embedder_js_1.embed)(content);
+                db.prepare("DELETE FROM memory_vectors WHERE id = ?").run(fullId);
+                db.prepare("INSERT INTO memory_vectors (id, embedding) VALUES (?, ?)").run(fullId, Buffer.from(embedding.buffer));
+            }
+            res.json({ updated: true, id: fullId });
+        }
+        catch (err) {
+            res.status(500).json({ error: "Update failed", message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // REST /delete — permanently delete a memory and its links.
+    //
+    // NOTE for #124: returns {deleted: true, id} — clean JSON for future /viz.
+    // -------------------------------------------------------------------------
+    app.post("/delete", async (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        const { id } = req.body ?? {};
+        if (!id || typeof id !== "string") {
+            res.status(400).json({ error: "Missing or invalid 'id' field" });
+            return;
+        }
+        const fullId = resolveMemoryId(db, id);
+        if (!fullId) {
+            res.status(404).json({ error: `Memory not found: ${id}` });
+            return;
+        }
+        try {
+            storage.deleteMemory(db, fullId);
+            res.json({ deleted: true, id: fullId });
+        }
+        catch (err) {
+            res.status(500).json({ error: "Delete failed", message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // REST /index — knowledge domain index (same payload as hicortex_index MCP).
+    //
+    // NOTE for #124: this is the JSON surface that /viz will later consume.
+    // Keep the response shape clean: {domains} or {projects} fallback.
+    // -------------------------------------------------------------------------
+    app.get("/index", (_req, res) => {
+        try {
+            const state = (0, state_js_1.loadState)(stateDir);
+            const moduleIndex = state.moduleIndex;
+            if (moduleIndex && moduleIndex.domains && moduleIndex.domains.length > 0) {
+                res.json({ domains: moduleIndex.domains });
+                return;
+            }
+            // Fallback: flat project counts when moduleIndex is not yet built
+            if (!db) {
+                res.json({ domains: [] });
+                return;
+            }
+            const rows = db.prepare("SELECT project, COUNT(*) as cnt FROM memories WHERE project IS NOT NULL GROUP BY project ORDER BY cnt DESC LIMIT 20").all();
+            res.json({ projects: rows.map((r) => ({ name: r.project, count: r.cnt })) });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    // -------------------------------------------------------------------------
+    // REST /graph — knowledge graph query (same operations as hicortex_graph MCP).
+    //
+    // Supported ops: neighbors, hubs, path
+    //   GET /graph?op=neighbors&id=<id>&limit=10&relationship=<rel>
+    //   GET /graph?op=hubs&limit=10&domain=<domain>
+    //   GET /graph?op=path&id=<from>&target_id=<to>
+    //
+    // NOTE for #124 (/viz): this endpoint IS the JSON surface that /viz will
+    // reuse for its graph visualisation. The response shape is intentionally
+    // clean ({results} for neighbors/path, {hubs} for hubs) so /viz can consume
+    // it without transformation. Do not add MCP-style text formatting here.
+    // -------------------------------------------------------------------------
+    app.get("/graph", (req, res) => {
+        if (!db) {
+            res.status(503).json({ error: "Server not initialized" });
+            return;
+        }
+        const op = typeof req.query.op === "string" ? req.query.op : "";
+        const VALID_OPS = ["neighbors", "hubs", "path"];
+        if (!VALID_OPS.includes(op)) {
+            res.status(400).json({ error: `Invalid op: must be one of ${VALID_OPS.join(", ")}` });
+            return;
+        }
+        const rawLimit = req.query.limit ? Number(req.query.limit) : undefined;
+        const resultLimit = rawLimit && Number.isFinite(rawLimit) ? rawLimit : 10;
+        const filterDomain = typeof req.query.domain === "string" && req.query.domain ? req.query.domain : undefined;
+        const filterRelationship = typeof req.query.relationship === "string" && req.query.relationship ? req.query.relationship : undefined;
+        try {
+            if (op === "neighbors") {
+                const idParam = typeof req.query.id === "string" ? req.query.id : "";
+                if (!idParam) {
+                    res.status(400).json({ error: "id is required for neighbors operation" });
+                    return;
+                }
+                const resolvedId = resolveMemoryId(db, idParam);
+                if (!resolvedId) {
+                    res.status(404).json({ error: `Memory not found: ${idParam}` });
+                    return;
+                }
+                const neighbors = (0, graph_js_1.getNeighbors)(db, resolvedId, resultLimit, filterRelationship);
+                res.json({ results: neighbors });
+                return;
+            }
+            if (op === "hubs") {
+                let hubs = (0, graph_js_1.detectHubs)(db);
+                if (filterDomain) {
+                    hubs = hubs.filter((h) => h.domain === filterDomain || h.project === filterDomain);
+                }
+                res.json({ hubs: hubs.slice(0, resultLimit) });
+                return;
+            }
+            if (op === "path") {
+                const fromParam = typeof req.query.id === "string" ? req.query.id : "";
+                const toParam = typeof req.query.target_id === "string" ? req.query.target_id : "";
+                if (!fromParam || !toParam) {
+                    res.status(400).json({ error: "id and target_id are required for path operation" });
+                    return;
+                }
+                const fromId = resolveMemoryId(db, fromParam);
+                const toId = resolveMemoryId(db, toParam);
+                if (!fromId || !toId) {
+                    res.status(404).json({ error: "One or both memory IDs not found" });
+                    return;
+                }
+                const path = (0, graph_js_1.shortestPath)(db, fromId, toId);
+                res.json({ path: path ?? null });
+                return;
+            }
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        }
+    });
     // SSE endpoint — each connection gets its own McpServer + transport
     app.get("/sse", async (req, res) => {
         const transport = new sse_js_1.SSEServerTransport("/messages", res);
@@ -589,10 +912,6 @@ async function startServer(options = {}) {
     // Graceful shutdown
     const shutdown = () => {
         console.log("[hicortex] Shutting down...");
-        if (cancelConsolidation) {
-            cancelConsolidation();
-            cancelConsolidation = null;
-        }
         for (const transport of transports.values()) {
             transport.close().catch(() => { });
         }

package/dist/nightly.d.ts

@@ -1,15 +1,18 @@
 /**
  * Nightly pipeline — manual trigger or called by the persistent server.
  *
- * Steps:
- *   1. Read new CC transcripts since last run
- *   2. Distill each session into memories via LLM
- *   3. Run consolidation (scoring, reflection, linking, decay)
- *   4. Inject lessons into CLAUDE.md
- *   5. Update last-run timestamp
+ * Steps (0.9.0+):
+ *   1. Read new harness transcripts since last run
+ *   2. Denoise + POST each session to /distill (server captures for itself via localhost)
+ *   3. Run consolidation (scoring, reflection, linking, decay) — server mode only
+ *   4. Update last-run timestamp
+ *
+ * Every machine (server + clients) uses the same capture path: denoise locally,
+ * POST to /distill. No local LLM required for capture; distillation is server-side.
  */
 export declare function runNightly(options?: {
     dryRun?: boolean;
+    captureOnly?: boolean;
     dbPath?: string;
     stateDir?: string;
 }): Promise<void>;