@gamaze/hicortex 0.2.1 → 0.3.1

package/dist/mcp-server.js

@@ -0,0 +1,299 @@
+"use strict";
+/**
+ * Hicortex MCP HTTP/SSE Server.
+ *
+ * Persistent HTTP server that exposes Hicortex tools via MCP protocol.
+ * Shared across all CC sessions (and future Codex/Gemini adapters).
+ * One process, one DB connection, one embedder — no per-session overhead.
+ *
+ * Endpoints:
+ *   GET  /health     — health check
+ *   GET  /sse        — SSE stream for MCP clients
+ *   POST /messages   — message endpoint for MCP clients
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const express_1 = __importDefault(require("express"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const zod_1 = require("zod");
+const db_js_1 = require("./db.js");
+const llm_js_1 = require("./llm.js");
+const license_js_1 = require("./license.js");
+const embedder_js_1 = require("./embedder.js");
+const storage = __importStar(require("./storage.js"));
+const retrieval = __importStar(require("./retrieval.js"));
+const consolidate_js_1 = require("./consolidate.js");
+// ---------------------------------------------------------------------------
+// Server state
+// ---------------------------------------------------------------------------
+let db = null;
+let llm = null;
+let cancelConsolidation = null;
+let stateDir = "";
+const VERSION = "0.3.0";
+// ---------------------------------------------------------------------------
+// MCP Server setup
+// ---------------------------------------------------------------------------
+function createMcpServer() {
+    const server = new mcp_js_1.McpServer({
+        name: "hicortex",
+        version: VERSION,
+    });
+    // -- hicortex_search --
+    server.tool("hicortex_search", "Search long-term memory using semantic similarity. Returns the most relevant memories from past sessions.", {
+        query: zod_1.z.string().describe("Search query text"),
+        limit: zod_1.z.number().optional().describe("Max results (default 5)"),
+        project: zod_1.z.string().optional().describe("Filter by project name"),
+    }, async ({ query, limit, project }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        try {
+            const results = await retrieval.retrieve(db, embedder_js_1.embed, query, { limit, project });
+            return { content: [{ type: "text", text: formatResults(results) }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Search failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    // -- hicortex_context --
+    server.tool("hicortex_context", "Get recent context memories, optionally filtered by project. Useful to recall what happened recently.", {
+        project: zod_1.z.string().optional().describe("Filter by project name"),
+        limit: zod_1.z.number().optional().describe("Max results (default 10)"),
+    }, async ({ project, limit }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        try {
+            const results = retrieval.searchContext(db, { project, limit });
+            return { content: [{ type: "text", text: formatResults(results) }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Context search failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    // -- hicortex_ingest --
+    server.tool("hicortex_ingest", "Store a new memory in long-term storage. Use for important facts, decisions, or lessons.", {
+        content: zod_1.z.string().describe("Memory content to store"),
+        project: zod_1.z.string().optional().describe("Project this memory belongs to"),
+        memory_type: zod_1.z.enum(["episode", "lesson", "fact", "decision"]).optional().describe("Type of memory (default: episode)"),
+    }, async ({ content, project, memory_type }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        const features = (0, license_js_1.getFeatures)(stateDir);
+        if (features.maxMemories > 0 && storage.countMemories(db) >= features.maxMemories) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Free tier limit reached (${features.maxMemories} 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, {
+                sourceAgent: "claude-code/manual",
+                project,
+                memoryType: memory_type ?? "episode",
+                privacy: "WORK",
+            });
+            return { content: [{ type: "text", text: `Memory stored (id: ${id.slice(0, 8)})` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Ingest failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    // -- hicortex_lessons --
+    server.tool("hicortex_lessons", "Get actionable lessons learned from past sessions. Auto-generated insights about mistakes to avoid.", {
+        days: zod_1.z.number().optional().describe("Look back N days (default 7)"),
+        project: zod_1.z.string().optional().describe("Filter by project name"),
+    }, async ({ days, project }) => {
+        if (!db)
+            return { content: [{ type: "text", text: "Hicortex not initialized" }], isError: true };
+        try {
+            const lessons = storage.getLessons(db, days ?? 7, project);
+            if (lessons.length === 0) {
+                return { content: [{ type: "text", text: "No lessons found for the specified period." }] };
+            }
+            const text = lessons.map((l) => `- ${l.content.slice(0, 500)}`).join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `Lessons fetch failed: ${err instanceof Error ? err.message : String(err)}` }], isError: true };
+        }
+    });
+    return server;
+}
+// ---------------------------------------------------------------------------
+// HTTP server with SSE transport
+// ---------------------------------------------------------------------------
+async function startServer(options = {}) {
+    const port = options.port ?? 8787;
+    const host = options.host ?? "127.0.0.1";
+    // Initialize core
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
+    console.log(`[hicortex] Initializing database at ${dbPath}`);
+    db = (0, db_js_1.initDb)(dbPath);
+    stateDir = dbPath.replace(/\/hicortex\.db$/, "");
+    // LLM config
+    const llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+    llm = new llm_js_1.LlmClient(llmConfig);
+    console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model} (reflect: ${llmConfig.reflectModel})`);
+    // License: read from options, config file, or env var
+    const licenseKey = options.licenseKey
+        ?? readConfigLicenseKey(stateDir)
+        ?? process.env.HICORTEX_LICENSE_KEY;
+    (0, license_js_1.validateLicense)(licenseKey, stateDir).catch((err) => console.log(`[hicortex] License validation failed: ${err}`));
+    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);
+    // Stats
+    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`);
+    // Create MCP server
+    const mcpServer = createMcpServer();
+    // Express app
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    // SSE transport management
+    const transports = new Map();
+    // Health endpoint
+    app.get("/health", (_req, res) => {
+        const s = db ? (0, db_js_1.getStats)(db, dbPath) : { memories: 0, links: 0, db_size_bytes: 0, by_type: {} };
+        res.json({
+            status: "ok",
+            version: VERSION,
+            memories: s.memories,
+            links: s.links,
+            db_size_kb: Math.round(s.db_size_bytes / 1024),
+            llm: `${llmConfig.provider}/${llmConfig.model}`,
+        });
+    });
+    // SSE endpoint — client connects here to establish MCP session
+    app.get("/sse", async (req, res) => {
+        const transport = new sse_js_1.SSEServerTransport("/messages", res);
+        transports.set(transport.sessionId, transport);
+        transport.onclose = () => {
+            transports.delete(transport.sessionId);
+        };
+        await mcpServer.connect(transport);
+    });
+    // Message endpoint — client POSTs MCP messages here
+    app.post("/messages", async (req, res) => {
+        const sessionId = req.query.sessionId;
+        if (!sessionId || !transports.has(sessionId)) {
+            res.status(400).json({ error: "Invalid or missing sessionId" });
+            return;
+        }
+        const transport = transports.get(sessionId);
+        // Pass parsed body since express.json() already consumed the stream
+        await transport.handlePostMessage(req, res, req.body);
+    });
+    // Start listening
+    const server = app.listen(port, host, () => {
+        console.log(`[hicortex] MCP server listening on http://${host}:${port}`);
+        console.log(`[hicortex] SSE endpoint: http://${host}:${port}/sse`);
+        console.log(`[hicortex] Health: http://${host}:${port}/health`);
+    });
+    server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`[hicortex] Port ${port} is already in use. ` +
+                `Another Hicortex server or service may be running.\n` +
+                `  Check: lsof -i :${port}\n` +
+                `  Use a different port: npx @gamaze/hicortex server --port ${port + 1}`);
+            process.exit(1);
+        }
+        throw err;
+    });
+    // Graceful shutdown
+    const shutdown = () => {
+        console.log("[hicortex] Shutting down...");
+        if (cancelConsolidation) {
+            cancelConsolidation();
+            cancelConsolidation = null;
+        }
+        for (const transport of transports.values()) {
+            transport.close().catch(() => { });
+        }
+        transports.clear();
+        server.close(() => {
+            if (db) {
+                db.close();
+                db = null;
+            }
+            console.log("[hicortex] Server stopped.");
+            process.exit(0);
+        });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Read license key from ~/.hicortex/config.json.
+ * Written by /hicortex-activate CC command.
+ */
+function readConfigLicenseKey(stateDir) {
+    try {
+        const { readFileSync } = require("node:fs");
+        const { join } = require("node:path");
+        const configPath = join(stateDir, "config.json");
+        const raw = readFileSync(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        return config.licenseKey || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatResults(results) {
+    if (results.length === 0)
+        return "No memories found.";
+    return results
+        .map((r) => `[${r.memory_type}] (score: ${r.score.toFixed(3)}, strength: ${r.effective_strength.toFixed(3)}) ${r.content.slice(0, 500)}`)
+        .join("\n\n");
+}

package/dist/nightly.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+export declare function runNightly(options?: {
+    dryRun?: boolean;
+    dbPath?: string;
+    stateDir?: string;
+}): Promise<void>;

package/dist/nightly.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * 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
+ */
+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.runNightly = runNightly;
+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 llm_js_1 = require("./llm.js");
+const embedder_js_1 = require("./embedder.js");
+const storage = __importStar(require("./storage.js"));
+const distiller_js_1 = require("./distiller.js");
+const consolidate_js_1 = require("./consolidate.js");
+const transcript_reader_js_1 = require("./transcript-reader.js");
+const claude_md_js_1 = require("./claude-md.js");
+const license_js_1 = require("./license.js");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+const LAST_RUN_PATH = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
+function readConfigLicenseKey(stateDir) {
+    try {
+        const configPath = (0, node_path_1.join)(stateDir, "config.json");
+        const raw = (0, node_fs_1.readFileSync)(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        return config.licenseKey || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readLastRun() {
+    try {
+        const ts = (0, node_fs_1.readFileSync)(LAST_RUN_PATH, "utf-8").trim();
+        const d = new Date(ts);
+        if (!isNaN(d.getTime()))
+            return d;
+    }
+    catch {
+        // No file — first run
+    }
+    return new Date(0); // Process everything
+}
+function writeLastRun() {
+    (0, node_fs_1.mkdirSync)(HICORTEX_HOME, { recursive: true });
+    (0, node_fs_1.writeFileSync)(LAST_RUN_PATH, new Date().toISOString());
+}
+async function runNightly(options = {}) {
+    const dryRun = options.dryRun ?? false;
+    const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
+    const stateDir = options.stateDir ?? HICORTEX_HOME;
+    console.log(`[hicortex] Nightly pipeline starting${dryRun ? " (dry run)" : ""}`);
+    console.log(`[hicortex] DB: ${dbPath}`);
+    // Init DB
+    const db = (0, db_js_1.initDb)(dbPath);
+    try {
+        // License: read from config file or env var
+        const licenseKey = readConfigLicenseKey(stateDir) ?? process.env.HICORTEX_LICENSE_KEY;
+        await (0, license_js_1.validateLicense)(licenseKey, stateDir);
+        // Init LLM
+        const llmConfig = (0, llm_js_1.resolveLlmConfigForCC)();
+        const llm = new llm_js_1.LlmClient(llmConfig);
+        console.log(`[hicortex] LLM: ${llmConfig.provider}/${llmConfig.model}`);
+        // Step 1: Read new CC transcripts
+        const since = readLastRun();
+        console.log(`[hicortex] Reading CC transcripts since ${since.toISOString()}`);
+        const batches = (0, transcript_reader_js_1.readCcTranscripts)(since);
+        console.log(`[hicortex] Found ${batches.length} new session(s)`);
+        if (batches.length === 0 && !dryRun) {
+            // Still run consolidation — there may be unscored memories from OC
+            console.log(`[hicortex] No new CC transcripts. Running consolidation only.`);
+        }
+        // Step 2: Distill each session
+        let memoriesIngested = 0;
+        const features = (0, license_js_1.getFeatures)(stateDir);
+        for (const batch of batches) {
+            const transcript = (0, distiller_js_1.extractConversationText)(batch.entries);
+            if (transcript.length < 200) {
+                console.log(`[hicortex]   Skip ${batch.sessionId.slice(0, 8)} (${batch.projectName}): too short`);
+                continue;
+            }
+            console.log(`[hicortex]   Distilling ${batch.sessionId.slice(0, 8)} (${batch.projectName}, ${batch.date})`);
+            if (dryRun) {
+                console.log(`[hicortex]     [dry-run] Would distill ${transcript.length} chars`);
+                continue;
+            }
+            // Check cap before distilling
+            if (features.maxMemories > 0 && storage.countMemories(db) >= features.maxMemories) {
+                console.log(`[hicortex]   Free tier limit (${features.maxMemories} memories). Skipping new ingestion. ` +
+                    `Upgrade: https://hicortex.gamaze.com/`);
+                break;
+            }
+            try {
+                const entries = await (0, distiller_js_1.distillSession)(llm, transcript, batch.projectName, batch.date);
+                for (const entry of entries) {
+                    try {
+                        const embedding = await (0, embedder_js_1.embed)(entry);
+                        storage.insertMemory(db, entry, embedding, {
+                            sourceAgent: `claude-code/${batch.projectName}`,
+                            sourceSession: batch.sessionId,
+                            project: batch.projectName,
+                            privacy: "WORK",
+                            memoryType: "episode",
+                        });
+                        memoriesIngested++;
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        console.error(`[hicortex]     Failed to ingest entry: ${msg}`);
+                    }
+                }
+                console.log(`[hicortex]     → ${entries.length} memories extracted`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(`[hicortex]     Distillation failed: ${msg}`);
+            }
+        }
+        console.log(`[hicortex] Distillation complete: ${memoriesIngested} new memories`);
+        // Step 3: Consolidation
+        if (!dryRun) {
+            console.log(`[hicortex] Running consolidation...`);
+            const report = await (0, consolidate_js_1.runConsolidation)(db, llm, embedder_js_1.embed, dryRun);
+            console.log(`[hicortex] Consolidation ${report.status} in ${report.elapsed_seconds}s` +
+                (report.stages.reflection ? ` (${report.stages.reflection.lessons_generated} lessons)` : ""));
+        }
+        // Step 4: Inject lessons into CLAUDE.md
+        if (!dryRun) {
+            const injection = (0, claude_md_js_1.injectLessons)(db, { stateDir });
+            console.log(`[hicortex] CLAUDE.md updated: ${injection.lessonsCount} lessons at ${injection.path}`);
+        }
+        // Step 5: Update last-run timestamp
+        if (!dryRun) {
+            writeLastRun();
+        }
+        console.log(`[hicortex] Nightly pipeline complete.`);
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/status.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hicortex status — show current configuration and stats.
+ */
+export declare function runStatus(): Promise<void>;

package/dist/status.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Hicortex status — show current configuration and stats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStatus = runStatus;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const db_js_1 = require("./db.js");
+const HICORTEX_HOME = (0, node_path_1.join)((0, node_os_1.homedir)(), ".hicortex");
+const CC_SETTINGS = (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "settings.json");
+const OC_CONFIG = (0, node_path_1.join)((0, node_os_1.homedir)(), ".openclaw", "openclaw.json");
+async function runStatus() {
+    console.log("Hicortex Status");
+    console.log("─".repeat(40));
+    // DB
+    const dbPath = (0, db_js_1.resolveDbPath)();
+    const dbExists = (0, node_fs_1.existsSync)(dbPath);
+    console.log(`DB:           ${dbPath} ${dbExists ? "" : "(not found)"}`);
+    if (dbExists) {
+        try {
+            const { initDb, getStats } = await import("./db.js");
+            const db = initDb(dbPath);
+            const stats = getStats(db, dbPath);
+            const typeStr = Object.entries(stats.by_type).map(([k, v]) => `${k}=${v}`).join(", ");
+            console.log(`Memories:     ${stats.memories} (${typeStr || "none"})`);
+            console.log(`Links:        ${stats.links}`);
+            console.log(`DB size:      ${(stats.db_size_bytes / 1024).toFixed(1)} KB`);
+            db.close();
+        }
+        catch (err) {
+            console.log(`DB error:     ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // License
+    const configPath = (0, node_path_1.join)(HICORTEX_HOME, "config.json");
+    let licenseKey = "";
+    try {
+        const config = JSON.parse((0, node_fs_1.readFileSync)(configPath, "utf-8"));
+        licenseKey = config.licenseKey ?? "";
+    }
+    catch { /* no config */ }
+    console.log(`License:      ${licenseKey ? "configured" : "free tier (250 memories)"}`);
+    console.log();
+    // Adapters
+    console.log("Adapters:");
+    // OC
+    let ocInstalled = false;
+    try {
+        const raw = (0, node_fs_1.readFileSync)(OC_CONFIG, "utf-8");
+        const config = JSON.parse(raw);
+        const entries = config?.plugins?.entries ?? {};
+        const installs = config?.plugins?.installs ?? {};
+        ocInstalled = "hicortex" in entries || "hicortex" in installs;
+    }
+    catch { /* no OC */ }
+    console.log(`  OC plugin:  ${ocInstalled ? "installed" : "not found"}`);
+    // CC
+    let ccRegistered = false;
+    let ccUrl = "";
+    try {
+        const raw = (0, node_fs_1.readFileSync)(CC_SETTINGS, "utf-8");
+        const settings = JSON.parse(raw);
+        const hc = settings?.mcpServers?.hicortex;
+        if (hc) {
+            ccRegistered = true;
+            ccUrl = hc.url ?? "";
+        }
+    }
+    catch { /* no CC settings */ }
+    console.log(`  CC MCP:     ${ccRegistered ? `registered → ${ccUrl}` : "not registered"}`);
+    console.log();
+    // Server status
+    console.log("Server:");
+    let serverRunning = false;
+    try {
+        const resp = await fetch("http://127.0.0.1:8787/health", {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (resp.ok) {
+            const data = await resp.json();
+            serverRunning = true;
+            console.log(`  Status:     running (${data.llm})`);
+        }
+    }
+    catch { /* not running */ }
+    if (!serverRunning)
+        console.log("  Status:     not running");
+    // Daemon
+    const os = (0, node_os_1.platform)();
+    if (os === "darwin") {
+        try {
+            const out = (0, node_child_process_1.execSync)("launchctl list 2>/dev/null | grep hicortex", { encoding: "utf-8" });
+            console.log(`  Daemon:     launchd (${out.trim() ? "loaded" : "not loaded"})`);
+        }
+        catch {
+            console.log("  Daemon:     launchd (not installed)");
+        }
+    }
+    else if (os === "linux") {
+        try {
+            const out = (0, node_child_process_1.execSync)("systemctl --user is-active hicortex.service 2>/dev/null", { encoding: "utf-8" }).trim();
+            console.log(`  Daemon:     systemd (${out})`);
+        }
+        catch {
+            console.log("  Daemon:     systemd (not installed)");
+        }
+    }
+    // Last nightly run
+    const lastRunPath = (0, node_path_1.join)(HICORTEX_HOME, "nightly-last-run.txt");
+    try {
+        const ts = (0, node_fs_1.readFileSync)(lastRunPath, "utf-8").trim();
+        console.log(`  Last run:   ${ts}`);
+    }
+    catch {
+        console.log("  Last run:   never");
+    }
+}

package/dist/transcript-reader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * CC transcript reader — reads Claude Code .jsonl session files.
+ *
+ * CC stores transcripts at ~/.claude/projects/<project-hash>/<session-uuid>.jsonl.
+ * Each line is a JSON object with type, message, timestamp, etc.
+ *
+ * The reader scans for new sessions since the last nightly run
+ * and feeds them to the existing distiller pipeline.
+ */
+export interface TranscriptBatch {
+    sessionId: string;
+    projectName: string;
+    date: string;
+    entries: unknown[];
+}
+/**
+ * Read all CC transcripts modified since `since`.
+ * Returns one batch per session file.
+ */
+export declare function readCcTranscripts(since: Date, projectsDir?: string): TranscriptBatch[];