ahok-skill 1.3.1

package/dist/ops/extract.js

@@ -0,0 +1,333 @@
+"use strict";
+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.extractPDF = extractPDF;
+exports.extractDOCX = extractDOCX;
+exports.extractHTML = extractHTML;
+exports.extractURL = extractURL;
+exports.extractAudio = extractAudio;
+exports.extractVideo = extractVideo;
+exports.extractText = extractText;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const mammoth_1 = __importDefault(require("mammoth"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const openai_1 = __importDefault(require("openai"));
+const TurndownService = require("turndown");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+async function extractPDF(buffer) {
+    const { PDFParse } = await Promise.resolve().then(() => __importStar(require("pdf-parse")));
+    const parser = new PDFParse({ data: buffer });
+    const textResult = await parser.getText();
+    const infoResult = await parser.getInfo();
+    return {
+        text: textResult.text,
+        metadata: {
+            content_type: "pdf",
+            char_count: textResult.text.length,
+            estimated_tokens: estimateTokens(textResult.text),
+            extraction_method: "pdf-parse",
+            pages: textResult.total,
+            info: infoResult,
+        },
+    };
+}
+async function extractDOCX(buffer) {
+    const result = await mammoth_1.default.extractRawText({ buffer });
+    return {
+        text: result.value,
+        metadata: {
+            content_type: "docx",
+            char_count: result.value.length,
+            estimated_tokens: estimateTokens(result.value),
+            extraction_method: "mammoth",
+            messages: result.messages,
+        },
+    };
+}
+async function extractHTML(html) {
+    const turndown = new TurndownService({
+        headingStyle: "atx",
+        codeBlockStyle: "fenced",
+    });
+    const markdown = turndown.turndown(html);
+    return {
+        text: markdown,
+        metadata: {
+            content_type: "html",
+            char_count: markdown.length,
+            estimated_tokens: estimateTokens(markdown),
+            extraction_method: "turndown",
+            original_html_length: html.length,
+        },
+    };
+}
+async function extractURL(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const html = await response.text();
+    const turndown = new TurndownService({
+        headingStyle: "atx",
+        codeBlockStyle: "fenced",
+    });
+    const markdown = turndown.turndown(html);
+    return {
+        text: markdown,
+        metadata: {
+            content_type: "url",
+            char_count: markdown.length,
+            estimated_tokens: estimateTokens(markdown),
+            extraction_method: "node-fetch+turndown",
+            source_url: url,
+            fetched_at: new Date().toISOString(),
+        },
+    };
+}
+async function extractAudio(buffer, mimeType) {
+    const apiKey = process.env.OPENAI_API_KEY || process.env.OM_OPENAI_API_KEY;
+    if (!apiKey) {
+        throw new Error("OpenAI API key required for audio transcription. Set OPENAI_API_KEY in .env");
+    }
+    // Check file size (Whisper API limit is 25MB)
+    const maxSize = 25 * 1024 * 1024; // 25MB
+    if (buffer.length > maxSize) {
+        throw new Error(`Audio file too large: ${(buffer.length / 1024 / 1024).toFixed(2)}MB. Maximum size is 25MB.`);
+    }
+    // Create temporary file for Whisper API
+    const tempDir = os.tmpdir();
+    const ext = getAudioExtension(mimeType);
+    const tempFilePath = path.join(tempDir, `audio-${Date.now()}${ext}`);
+    try {
+        // Write buffer to temp file
+        fs.writeFileSync(tempFilePath, buffer);
+        // Initialize OpenAI client
+        const openai = new openai_1.default({ apiKey });
+        // Transcribe audio using Whisper
+        const transcription = await openai.audio.transcriptions.create({
+            file: fs.createReadStream(tempFilePath),
+            model: "whisper-1",
+            response_format: "verbose_json",
+        });
+        const text = transcription.text;
+        return {
+            text,
+            metadata: {
+                content_type: "audio",
+                char_count: text.length,
+                estimated_tokens: estimateTokens(text),
+                extraction_method: "whisper",
+                audio_format: ext.replace(".", ""),
+                file_size_bytes: buffer.length,
+                file_size_mb: (buffer.length / 1024 / 1024).toFixed(2),
+                duration_seconds: transcription.duration || null,
+                language: transcription.language || null,
+            },
+        };
+    }
+    catch (error) {
+        console.error("[EXTRACT] Audio transcription failed:", error);
+        throw new Error(`Audio transcription failed: ${error.message}`);
+    }
+    finally {
+        // Clean up temp file
+        try {
+            if (fs.existsSync(tempFilePath)) {
+                fs.unlinkSync(tempFilePath);
+            }
+        }
+        catch (e) {
+            console.warn("[EXTRACT] Failed to clean up temp file:", e);
+        }
+    }
+}
+async function extractVideo(buffer) {
+    // Create temporary files for video and audio
+    const tempDir = os.tmpdir();
+    const videoPath = path.join(tempDir, `video-${Date.now()}.mp4`);
+    const audioPath = path.join(tempDir, `audio-${Date.now()}.mp3`);
+    try {
+        // Write video buffer to temp file
+        fs.writeFileSync(videoPath, buffer);
+        // Extract audio using ffmpeg
+        await new Promise((resolve, reject) => {
+            (0, fluent_ffmpeg_1.default)(videoPath)
+                .output(audioPath)
+                .noVideo()
+                .audioCodec("libmp3lame")
+                .on("end", () => resolve())
+                .on("error", (err) => reject(err))
+                .run();
+        });
+        // Read extracted audio
+        const audioBuffer = fs.readFileSync(audioPath);
+        // Transcribe extracted audio
+        const result = await extractAudio(audioBuffer, "audio/mpeg");
+        // Update metadata to reflect video source
+        result.metadata.content_type = "video";
+        result.metadata.extraction_method = "ffmpeg+whisper";
+        result.metadata.video_file_size_bytes = buffer.length;
+        result.metadata.video_file_size_mb = (buffer.length /
+            1024 /
+            1024).toFixed(2);
+        return result;
+    }
+    catch (error) {
+        if (error.message?.includes("ffmpeg")) {
+            throw new Error("FFmpeg not found. Please install FFmpeg to process video files. Visit: https://ffmpeg.org/download.html");
+        }
+        console.error("[EXTRACT] Video processing failed:", error);
+        throw new Error(`Video processing failed: ${error.message}`);
+    }
+    finally {
+        // Clean up temp files
+        try {
+            if (fs.existsSync(videoPath))
+                fs.unlinkSync(videoPath);
+            if (fs.existsSync(audioPath))
+                fs.unlinkSync(audioPath);
+        }
+        catch (e) {
+            console.warn("[EXTRACT] Failed to clean up temp files:", e);
+        }
+    }
+}
+function getAudioExtension(mimeType) {
+    const mimeMap = {
+        "audio/mpeg": ".mp3",
+        "audio/mp3": ".mp3",
+        "audio/wav": ".wav",
+        "audio/wave": ".wav",
+        "audio/x-wav": ".wav",
+        "audio/mp4": ".m4a",
+        "audio/m4a": ".m4a",
+        "audio/x-m4a": ".m4a",
+        "audio/webm": ".webm",
+        "audio/ogg": ".ogg",
+    };
+    return mimeMap[mimeType.toLowerCase()] || ".mp3";
+}
+async function extractText(contentType, data) {
+    const type = contentType.toLowerCase();
+    // Audio formats
+    if (type === "mp3" ||
+        type === "audio" ||
+        type === "audio/mpeg" ||
+        type === "audio/mp3" ||
+        type === "audio/wav" ||
+        type === "audio/wave" ||
+        type === "audio/x-wav" ||
+        type === "wav" ||
+        type === "m4a" ||
+        type === "audio/mp4" ||
+        type === "audio/m4a" ||
+        type === "audio/x-m4a" ||
+        type === "webm" ||
+        type === "audio/webm" ||
+        type === "ogg" ||
+        type === "audio/ogg") {
+        const buffer = Buffer.isBuffer(data)
+            ? data
+            : Buffer.from(data, "base64");
+        return extractAudio(buffer, type.startsWith("audio/") ? type : `audio/${type}`);
+    }
+    // Video formats
+    if (type === "mp4" ||
+        type === "video" ||
+        type === "video/mp4" ||
+        type === "video/webm" ||
+        type === "video/mpeg" ||
+        type === "avi" ||
+        type === "video/avi" ||
+        type === "mov" ||
+        type === "video/quicktime") {
+        const buffer = Buffer.isBuffer(data)
+            ? data
+            : Buffer.from(data, "base64");
+        return extractVideo(buffer);
+    }
+    switch (type) {
+        case "pdf":
+            return extractPDF(Buffer.isBuffer(data)
+                ? data
+                : Buffer.from(data, "base64"));
+        case "docx":
+        case "doc":
+            return extractDOCX(Buffer.isBuffer(data)
+                ? data
+                : Buffer.from(data, "base64"));
+        case "html":
+        case "htm":
+            return extractHTML(data.toString());
+        case "md":
+        case "markdown": {
+            const text = data.toString();
+            return {
+                text,
+                metadata: {
+                    content_type: "markdown",
+                    char_count: text.length,
+                    estimated_tokens: estimateTokens(text),
+                    extraction_method: "passthrough",
+                },
+            };
+        }
+        case "txt":
+        case "text": {
+            const text = data.toString();
+            return {
+                text,
+                metadata: {
+                    content_type: "txt",
+                    char_count: text.length,
+                    estimated_tokens: estimateTokens(text),
+                    extraction_method: "passthrough",
+                },
+            };
+        }
+        default:
+            throw new Error(`Unsupported content type: ${contentType}`);
+    }
+}

package/dist/ops/ingest.js

@@ -0,0 +1,214 @@
+"use strict";
+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.ingestDocument = ingestDocument;
+exports.ingestURL = ingestURL;
+const hsg_1 = require("../memory/hsg");
+const db_1 = require("../core/db");
+const utils_1 = require("../utils");
+const extract_1 = require("./extract");
+const LG = 8000, SEC = 3000;
+const split = (t, sz) => {
+    if (t.length <= sz)
+        return [t];
+    const secs = [];
+    const paras = t.split(/\n\n+/);
+    let cur = "";
+    for (const p of paras) {
+        if (cur.length + p.length > sz && cur.length > 0) {
+            secs.push(cur.trim());
+            cur = p;
+        }
+        else
+            cur += (cur ? "\n\n" : "") + p;
+    }
+    if (cur.trim())
+        secs.push(cur.trim());
+    return secs;
+};
+const mkRoot = async (txt, ex, meta, user_id) => {
+    const sum = txt.length > 500 ? txt.slice(0, 500) + "..." : txt;
+    const cnt = `[Document: ${ex.metadata.content_type.toUpperCase()}]\n\n${sum}\n\n[Full content split across ${Math.ceil(txt.length / SEC)} sections]`;
+    const id = (0, utils_1.rid)(), ts = (0, utils_1.now)();
+    await db_1.transaction.begin();
+    try {
+        await db_1.q.ins_mem.run(id, cnt, "reflective", (0, utils_1.j)([]), (0, utils_1.j)({
+            ...meta,
+            ...ex.metadata,
+            is_root: true,
+            ingestion_strategy: "root-child",
+            ingested_at: ts,
+        }), ts, ts, ts, 1.0, 0.1, 1, user_id || "anonymous", null);
+        await db_1.transaction.commit();
+        return id;
+    }
+    catch (e) {
+        console.error("[ERROR] Root failed:", e);
+        await db_1.transaction.rollback();
+        throw e;
+    }
+};
+const mkChild = async (txt, idx, tot, rid, meta, user_id) => {
+    const r = await (0, hsg_1.add_hsg_memory)(txt, (0, utils_1.j)([]), {
+        ...meta,
+        is_child: true,
+        section_index: idx,
+        total_sections: tot,
+        parent_id: rid,
+    }, user_id || undefined);
+    return r.id;
+};
+const link = async (rid, cid, idx, user_id) => {
+    const ts = (0, utils_1.now)();
+    await db_1.transaction.begin();
+    try {
+        await db_1.q.ins_waypoint.run(rid, cid, user_id || "anonymous", 1.0, ts, ts);
+        await db_1.transaction.commit();
+        console.log(`[INGEST] Linked: ${rid.slice(0, 8)} -> ${cid.slice(0, 8)} (section ${idx})`);
+    }
+    catch (e) {
+        await db_1.transaction.rollback();
+        console.error(`[INGEST] Link failed for section ${idx}:`, e);
+        throw e;
+    }
+};
+async function ingestDocument(t, data, meta, cfg, user_id) {
+    const th = cfg?.lg_thresh || LG, sz = cfg?.sec_sz || SEC;
+    const ex = await (0, extract_1.extractText)(t, data);
+    const { text, metadata: exMeta } = ex;
+    const useRC = cfg?.force_root || exMeta.estimated_tokens > th;
+    if (!useRC) {
+        const r = await (0, hsg_1.add_hsg_memory)(text, (0, utils_1.j)([]), {
+            ...meta,
+            ...exMeta,
+            ingestion_strategy: "single",
+            ingested_at: (0, utils_1.now)(),
+        }, user_id || undefined);
+        return {
+            root_memory_id: r.id,
+            child_count: 0,
+            total_tokens: exMeta.estimated_tokens,
+            strategy: "single",
+            extraction: exMeta,
+        };
+    }
+    const secs = split(text, sz);
+    console.log(`[INGEST] Document: ${exMeta.estimated_tokens} tokens`);
+    console.log(`[INGEST] Splitting into ${secs.length} sections`);
+    let rid;
+    const cids = [];
+    try {
+        rid = await mkRoot(text, ex, meta, user_id);
+        console.log(`[INGEST] Root memory created: ${rid}`);
+        for (let i = 0; i < secs.length; i++) {
+            try {
+                const cid = await mkChild(secs[i], i, secs.length, rid, meta, user_id);
+                cids.push(cid);
+                await link(rid, cid, i, user_id);
+                console.log(`[INGEST] Section ${i + 1}/${secs.length} processed: ${cid}`);
+            }
+            catch (e) {
+                console.error(`[INGEST] Section ${i + 1}/${secs.length} failed:`, e);
+                throw e;
+            }
+        }
+        console.log(`[INGEST] Completed: ${cids.length} sections linked to ${rid}`);
+        return {
+            root_memory_id: rid,
+            child_count: secs.length,
+            total_tokens: exMeta.estimated_tokens,
+            strategy: "root-child",
+            extraction: exMeta,
+        };
+    }
+    catch (e) {
+        console.error("[INGEST] Document ingestion failed:", e);
+        throw e;
+    }
+}
+async function ingestURL(url, meta, cfg, user_id) {
+    const { extractURL } = await Promise.resolve().then(() => __importStar(require("./extract")));
+    const ex = await extractURL(url);
+    const th = cfg?.lg_thresh || LG, sz = cfg?.sec_sz || SEC;
+    const useRC = cfg?.force_root || ex.metadata.estimated_tokens > th;
+    if (!useRC) {
+        const r = await (0, hsg_1.add_hsg_memory)(ex.text, (0, utils_1.j)([]), {
+            ...meta,
+            ...ex.metadata,
+            ingestion_strategy: "single",
+            ingested_at: (0, utils_1.now)(),
+        }, user_id || undefined);
+        return {
+            root_memory_id: r.id,
+            child_count: 0,
+            total_tokens: ex.metadata.estimated_tokens,
+            strategy: "single",
+            extraction: ex.metadata,
+        };
+    }
+    const secs = split(ex.text, sz);
+    console.log(`[INGEST] URL: ${ex.metadata.estimated_tokens} tokens`);
+    console.log(`[INGEST] Splitting into ${secs.length} sections`);
+    let rid;
+    const cids = [];
+    try {
+        rid = await mkRoot(ex.text, ex, { ...meta, source_url: url }, user_id);
+        console.log(`[INGEST] Root memory for URL: ${rid}`);
+        for (let i = 0; i < secs.length; i++) {
+            try {
+                const cid = await mkChild(secs[i], i, secs.length, rid, { ...meta, source_url: url }, user_id);
+                cids.push(cid);
+                await link(rid, cid, i, user_id);
+                console.log(`[INGEST] URL section ${i + 1}/${secs.length} processed: ${cid}`);
+            }
+            catch (e) {
+                console.error(`[INGEST] URL section ${i + 1}/${secs.length} failed:`, e);
+                throw e;
+            }
+        }
+        console.log(`[INGEST] URL completed: ${cids.length} sections linked to ${rid}`);
+        return {
+            root_memory_id: rid,
+            child_count: secs.length,
+            total_tokens: ex.metadata.estimated_tokens,
+            strategy: "root-child",
+            extraction: ex.metadata,
+        };
+    }
+    catch (e) {
+        console.error("[INGEST] URL ingestion failed:", e);
+        throw e;
+    }
+}

package/dist/server/index.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const server = require("./server.js");
+const cfg_1 = require("../core/cfg");
+const hsg_1 = require("../memory/hsg");
+const mcp_1 = require("../ai/mcp");
+const routes_1 = require("./routes");
+const auth_1 = require("./middleware/auth");
+const reflect_1 = require("../memory/reflect");
+const user_summary_1 = require("../memory/user_summary");
+const telemetry_1 = require("../core/telemetry");
+const dashboard_1 = require("./routes/dashboard");
+const ASC = `   ____                   __  __                                 
+  / __ \\                 |  \\/  |                                
+ | |  | |_ __   ___ _ __ | \\  / | ___ _ __ ___   ___  _ __ _   _ 
+ | |  | | '_ \\ / _ \\ '_ \\| |\\/| |/ _ \\ '_ \` _ \\ / _ \\| '__| | | |
+ | |__| | |_) |  __/ | | | |  | |  __/ | | | | | (_) | |  | |_| |
+  \\____/| .__/ \\___|_| |_|_|  |_|\\___|_| |_| |_|\\___/|_|   \\__, |
+        | |                                                 __/ |
+        |_|                                                |___/ `;
+const app = server({ max_payload_size: cfg_1.env.max_payload_size });
+console.log(ASC);
+console.log(`[CONFIG] Vector Dimension: ${cfg_1.env.vec_dim}`);
+console.log(`[CONFIG] Cache Segments: ${cfg_1.env.cache_segments}`);
+console.log(`[CONFIG] Max Active Queries: ${cfg_1.env.max_active}`);
+// Warn about configuration mismatch that causes embedding incompatibility
+if (cfg_1.env.emb_kind !== "synthetic" && (cfg_1.tier === "hybrid" || cfg_1.tier === "fast")) {
+    console.warn(`[CONFIG] ⚠️  WARNING: Embedding configuration mismatch detected!\n` +
+        `         OM_EMBEDDINGS=${cfg_1.env.emb_kind} but OM_TIER=${cfg_1.tier}\n` +
+        `         Storage will use ${cfg_1.env.emb_kind} embeddings, but queries will use synthetic embeddings.\n` +
+        `         This causes semantic search to fail. Set OM_TIER=deep to fix.`);
+}
+app.use((0, dashboard_1.req_tracker_mw)());
+app.use((req, res, next) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,PATCH,DELETE,OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type,Authorization,x-api-key");
+    if (req.method === "OPTIONS") {
+        res.status(200).end();
+        return;
+    }
+    next();
+});
+app.use(auth_1.authenticate_api_request);
+if (process.env.OM_LOG_AUTH === "true") {
+    app.use(auth_1.log_authenticated_request);
+}
+const path = require("path");
+(0, routes_1.routes)(app);
+// Serve dashboard static files
+const publicDir = path.join(__dirname, "../..", "public");
+app.use(app.serverStatic("/", publicDir));
+// Fallback for SPA routing
+app.get("*", (req, res, next) => {
+    if (req.path.startsWith("/api") || req.path.startsWith("/auth")) {
+        return next();
+    }
+    res.setHeader("Content-Type", "text/html");
+    const fs = require("fs");
+    const indexPath = path.join(publicDir, "index.html");
+    if (fs.existsSync(indexPath)) {
+        res.send(fs.readFileSync(indexPath, "utf8"));
+    }
+    else {
+        next();
+    }
+});
+(0, mcp_1.mcp)(app);
+if (cfg_1.env.mode === "langgraph") {
+    console.log("[MODE] LangGraph integration enabled");
+}
+const decayIntervalMs = cfg_1.env.decay_interval_minutes * 60 * 1000;
+console.log(`[DECAY] Interval: ${cfg_1.env.decay_interval_minutes} minutes (${decayIntervalMs / 1000}s)`);
+setInterval(async () => {
+    console.log("[DECAY] Running HSG decay process...");
+    try {
+        const result = await (0, hsg_1.run_decay_process)();
+        console.log(`[DECAY] Completed: ${result.decayed}/${result.processed} memories updated`);
+    }
+    catch (error) {
+        console.error("[DECAY] Process failed:", error);
+    }
+}, decayIntervalMs);
+setInterval(async () => {
+    console.log("[PRUNE] Pruning weak waypoints...");
+    try {
+        const pruned = await (0, hsg_1.prune_weak_waypoints)();
+        console.log(`[PRUNE] Completed: ${pruned} waypoints removed`);
+    }
+    catch (error) {
+        console.error("[PRUNE] Failed:", error);
+    }
+}, 7 * 24 * 60 * 60 * 1000);
+setTimeout(() => {
+    (0, hsg_1.run_decay_process)()
+        .then((result) => {
+        console.log(`[INIT] Initial decay: ${result.decayed}/${result.processed} memories updated`);
+    })
+        .catch(console.error);
+}, 3000);
+(0, reflect_1.start_reflection)();
+(0, user_summary_1.start_user_summary_reflection)();
+console.log(`[SERVER] Starting on port ${cfg_1.env.port}`);
+app.listen(cfg_1.env.port, () => {
+    console.log(`[SERVER] Running on http://localhost:${cfg_1.env.port}`);
+    (0, telemetry_1.sendTelemetry)().catch(() => {
+        // ignore telemetry failures
+    });
+});