ahok-skill 1.3.1

package/src/ai/mcp.ts

@@ -0,0 +1,494 @@
+import type { IncomingMessage, ServerResponse } from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { env } from "../core/cfg";
+import {
+    add_hsg_memory,
+    hsg_query,
+    reinforce_memory,
+    sector_configs,
+} from "../memory/hsg";
+import { q, all_async, memories_table, vector_store } from "../core/db";
+import { getEmbeddingInfo } from "../memory/embed";
+import { j, p } from "../utils";
+import type { sector_type, mem_row, rpc_err_code } from "../core/types";
+import { update_user_summary } from "../memory/user_summary";
+
+const sec_enum = z.enum([
+    "episodic",
+    "semantic",
+    "procedural",
+    "emotional",
+    "reflective",
+] as const);
+
+const trunc = (val: string, max = 200) =>
+    val.length <= max ? val : `${val.slice(0, max).trimEnd()}...`;
+
+const build_mem_snap = (row: mem_row) => ({
+    id: row.id,
+    primary_sector: row.primary_sector,
+    salience: Number(row.salience.toFixed(3)),
+    last_seen_at: row.last_seen_at,
+    user_id: row.user_id,
+    content_preview: trunc(row.content, 240),
+});
+
+const fmt_matches = (matches: Awaited<ReturnType<typeof hsg_query>>) =>
+    matches
+        .map((m: any, idx: any) => {
+            const prev = trunc(m.content.replace(/\s+/g, " ").trim(), 200);
+            return `${idx + 1}. [${m.primary_sector}] score=${m.score.toFixed(3)} salience=${m.salience.toFixed(3)} id=${m.id}\n${prev}`;
+        })
+        .join("\n\n");
+
+const set_hdrs = (res: ServerResponse) => {
+    res.setHeader("Content-Type", "application/json");
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST,OPTIONS");
+    res.setHeader(
+        "Access-Control-Allow-Headers",
+        "Content-Type,Authorization,Mcp-Session-Id",
+    );
+};
+
+const send_err = (
+    res: ServerResponse,
+    code: rpc_err_code,
+    msg: string,
+    id: number | string | null = null,
+    status = 400,
+) => {
+    if (!res.headersSent) {
+        res.statusCode = status;
+        set_hdrs(res);
+        res.end(
+            JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code, message: msg },
+                id,
+            }),
+        );
+    }
+};
+
+const uid = (val?: string | null) => (val?.trim() ? val.trim() : undefined);
+
+export const create_mcp_srv = () => {
+    const srv = new McpServer(
+        {
+            name: "openmemory-mcp",
+            version: "2.1.0",
+        },
+        { capabilities: { tools: {}, resources: {}, logging: {} } },
+    );
+
+    srv.tool(
+        "openmemory_query",
+        "Run a semantic retrieval against OpenMemory",
+        {
+            query: z
+                .string()
+                .min(1, "query text is required")
+                .describe("Free-form search text"),
+            k: z
+                .number()
+                .int()
+                .min(1)
+                .max(32)
+                .default(8)
+                .describe("Maximum results to return"),
+            sector: sec_enum
+                .optional()
+                .describe("Restrict search to a specific sector"),
+            min_salience: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe("Minimum salience threshold"),
+            user_id: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("Isolate results to a specific user identifier"),
+        },
+        async ({ query, k, sector, min_salience, user_id }) => {
+            const u = uid(user_id);
+            const flt =
+                sector || min_salience !== undefined || u
+                    ? {
+                        ...(sector
+                            ? { sectors: [sector as sector_type] }
+                            : {}),
+                        ...(min_salience !== undefined
+                            ? { minSalience: min_salience }
+                            : {}),
+                        ...(u ? { user_id: u } : {}),
+                    }
+                    : undefined;
+            const matches = await hsg_query(query, k ?? 8, flt);
+            const summ = matches.length
+                ? fmt_matches(matches)
+                : "No memories matched the supplied query.";
+            const pay = matches.map((m: any) => ({
+                id: m.id,
+                score: Number(m.score.toFixed(4)),
+                primary_sector: m.primary_sector,
+                sectors: m.sectors,
+                salience: Number(m.salience.toFixed(4)),
+                last_seen_at: m.last_seen_at,
+                path: m.path,
+                content: m.content,
+            }));
+            return {
+                content: [
+                    { type: "text", text: summ },
+                    {
+                        type: "text",
+                        text: JSON.stringify({ query, matches: pay }, null, 2),
+                    },
+                ],
+            };
+        },
+    );
+
+    srv.tool(
+        "openmemory_store",
+        "Persist new content into OpenMemory",
+        {
+            content: z.string().min(1).describe("Raw memory text to store"),
+            tags: z.array(z.string()).optional().describe("Optional tag list"),
+            metadata: z
+                .record(z.any())
+                .optional()
+                .describe("Arbitrary metadata blob"),
+            user_id: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe(
+                    "Associate the memory with a specific user identifier",
+                ),
+        },
+        async ({ content, tags, metadata, user_id }) => {
+            const u = uid(user_id);
+            const res = await add_hsg_memory(
+                content,
+                j(tags || []),
+                metadata,
+                u,
+            );
+            if (u)
+                update_user_summary(u).catch((err) =>
+                    console.error("[MCP] user summary update failed:", err),
+                );
+            const txt = `Stored memory ${res.id} (primary=${res.primary_sector}) across sectors: ${res.sectors.join(", ")}${u ? ` [user=${u}]` : ""}`;
+            const payload = {
+                id: res.id,
+                primary_sector: res.primary_sector,
+                sectors: res.sectors,
+                user_id: u ?? null,
+            };
+            return {
+                content: [
+                    { type: "text", text: txt },
+                    { type: "text", text: JSON.stringify(payload, null, 2) },
+                ],
+            };
+        },
+    );
+
+    srv.tool(
+        "openmemory_reinforce",
+        "Boost salience for an existing memory",
+        {
+            id: z.string().min(1).describe("Memory identifier to reinforce"),
+            boost: z
+                .number()
+                .min(0.01)
+                .max(1)
+                .default(0.1)
+                .describe("Salience boost amount (default 0.1)"),
+        },
+        async ({ id, boost }) => {
+            await reinforce_memory(id, boost);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Reinforced memory ${id} by ${boost}`,
+                    },
+                ],
+            };
+        },
+    );
+
+    srv.tool(
+        "openmemory_list",
+        "List recent memories for quick inspection",
+        {
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .default(10)
+                .describe("Number of memories to return"),
+            sector: sec_enum
+                .optional()
+                .describe("Optionally limit to a sector"),
+            user_id: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("Restrict results to a specific user identifier"),
+        },
+        async ({ limit, sector, user_id }) => {
+            const u = uid(user_id);
+            let rows: mem_row[];
+            if (u) {
+                const all = await q.all_mem_by_user.all(u, limit ?? 10, 0);
+                rows = sector
+                    ? all.filter((row) => row.primary_sector === sector)
+                    : all;
+            } else {
+                rows = sector
+                    ? await q.all_mem_by_sector.all(sector, limit ?? 10, 0)
+                    : await q.all_mem.all(limit ?? 10, 0);
+            }
+            const items = rows.map((row) => ({
+                ...build_mem_snap(row),
+                tags: p(row.tags || "[]") as string[],
+                metadata: p(row.meta || "{}") as Record<string, unknown>,
+            }));
+            const lns = items.map(
+                (item, idx) =>
+                    `${idx + 1}. [${item.primary_sector}] salience=${item.salience} id=${item.id}${item.tags.length ? ` tags=${item.tags.join(", ")}` : ""}${item.user_id ? ` user=${item.user_id}` : ""}\n${item.content_preview}`,
+            );
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: lns.join("\n\n") || "No memories stored yet.",
+                    },
+                    { type: "text", text: JSON.stringify({ items }, null, 2) },
+                ],
+            };
+        },
+    );
+
+    srv.tool(
+        "openmemory_get",
+        "Fetch a single memory by identifier",
+        {
+            id: z.string().min(1).describe("Memory identifier to load"),
+            include_vectors: z
+                .boolean()
+                .default(false)
+                .describe("Include sector vector metadata"),
+            user_id: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe(
+                    "Validate ownership against a specific user identifier",
+                ),
+        },
+        async ({ id, include_vectors, user_id }) => {
+            const u = uid(user_id);
+            const mem = await q.get_mem.get(id);
+            if (!mem)
+                return {
+                    content: [
+                        { type: "text", text: `Memory ${id} not found.` },
+                    ],
+                };
+            if (u && mem.user_id !== u)
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Memory ${id} not found for user ${u}.`,
+                        },
+                    ],
+                };
+            const vecs = include_vectors
+                ? await vector_store.getVectorsById(id)
+                : [];
+            const pay = {
+                id: mem.id,
+                content: mem.content,
+                primary_sector: mem.primary_sector,
+                salience: mem.salience,
+                decay_lambda: mem.decay_lambda,
+                created_at: mem.created_at,
+                updated_at: mem.updated_at,
+                last_seen_at: mem.last_seen_at,
+                user_id: mem.user_id,
+                tags: p(mem.tags || "[]"),
+                metadata: p(mem.meta || "{}"),
+                sectors: include_vectors
+                    ? vecs.map((v) => v.sector)
+                    : undefined,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(pay, null, 2) }],
+            };
+        },
+    );
+
+    srv.resource(
+        "openmemory-config",
+        "openmemory://config",
+        {
+            mimeType: "application/json",
+            description:
+                "Runtime configuration snapshot for the OpenMemory MCP server",
+        },
+        async () => {
+            const stats = await all_async(
+                `select primary_sector as sector, count(*) as count, avg(salience) as avg_salience from ${memories_table} group by primary_sector`,
+            );
+            const pay = {
+                mode: env.mode,
+                sectors: sector_configs,
+                stats,
+                embeddings: getEmbeddingInfo(),
+                server: { version: "2.1.0", protocol: "2025-06-18" },
+                available_tools: [
+                    "openmemory_query",
+                    "openmemory_store",
+                    "openmemory_reinforce",
+                    "openmemory_list",
+                    "openmemory_get",
+                ],
+            };
+            return {
+                contents: [
+                    {
+                        uri: "openmemory://config",
+                        text: JSON.stringify(pay, null, 2),
+                    },
+                ],
+            };
+        },
+    );
+
+    srv.server.oninitialized = () => {
+        // Use stderr for debug output, not stdout
+        console.error(
+            "[MCP] initialization completed with client:",
+            srv.server.getClientVersion(),
+        );
+    };
+    return srv;
+};
+
+const extract_pay = async (req: IncomingMessage & { body?: any }) => {
+    if (req.body !== undefined) {
+        if (typeof req.body === "string") {
+            if (!req.body.trim()) return undefined;
+            return JSON.parse(req.body);
+        }
+        if (typeof req.body === "object" && req.body !== null) return req.body;
+        return undefined;
+    }
+    const raw = await new Promise<string>((resolve, reject) => {
+        let buf = "";
+        req.on("data", (chunk) => {
+            buf += chunk;
+        });
+        req.on("end", () => resolve(buf));
+        req.on("error", reject);
+    });
+    if (!raw.trim()) return undefined;
+    return JSON.parse(raw);
+};
+
+export const mcp = (app: any) => {
+    const srv = create_mcp_srv();
+    const trans = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+        enableJsonResponse: true,
+    });
+    const srv_ready = srv
+        .connect(trans)
+        .then(() => {
+            console.error("[MCP] Server started and transport connected");
+        })
+        .catch((error) => {
+            console.error("[MCP] Failed to initialize transport:", error);
+            throw error;
+        });
+
+    const handle_req = async (req: any, res: any) => {
+        try {
+            await srv_ready;
+            const pay = await extract_pay(req);
+            if (!pay || typeof pay !== "object") {
+                send_err(res, -32600, "Request body must be a JSON object");
+                return;
+            }
+            console.error("[MCP] Incoming request:", JSON.stringify(pay));
+            set_hdrs(res);
+            await trans.handleRequest(req, res, pay);
+        } catch (error) {
+            console.error("[MCP] Error handling request:", error);
+            if (error instanceof SyntaxError) {
+                send_err(res, -32600, "Invalid JSON payload");
+                return;
+            }
+            if (!res.headersSent)
+                send_err(
+                    res,
+                    -32603,
+                    "Internal server error",
+                    (error as any)?.id ?? null,
+                    500,
+                );
+        }
+    };
+
+    app.post("/mcp", (req: any, res: any) => {
+        void handle_req(req, res);
+    });
+    app.options("/mcp", (_req: any, res: any) => {
+        res.statusCode = 204;
+        set_hdrs(res);
+        res.end();
+    });
+
+    const method_not_allowed = (_req: IncomingMessage, res: ServerResponse) => {
+        send_err(
+            res,
+            -32600,
+            "Method not supported. Use POST  /mcp with JSON payload.",
+            null,
+            405,
+        );
+    };
+    app.get("/mcp", method_not_allowed);
+    app.delete("/mcp", method_not_allowed);
+    app.put("/mcp", method_not_allowed);
+};
+
+export const start_mcp_stdio = async () => {
+    const srv = create_mcp_srv();
+    const trans = new StdioServerTransport();
+    await srv.connect(trans);
+    // console.error("[MCP] STDIO transport connected"); // Use stderr for debug output, not stdout
+};
+
+if (typeof require !== "undefined" && require.main === module) {
+    void start_mcp_stdio().catch((error) => {
+        console.error("[MCP] STDIO startup failed:", error);
+        process.exitCode = 1;
+    });
+}

package/src/cli.ts

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+import { run_async, all_async } from "./core/db";
+
+const SCHEMA_DEFINITIONS = {
+    memories: `create table if not exists memories(id text primary key,user_id text,segment integer default 0,content text not null,simhash text,primary_sector text not null,tags text,meta text,created_at integer,updated_at integer,last_seen_at integer,salience real,decay_lambda real,version integer default 1,mean_dim integer,mean_vec blob,compressed_vec blob,feedback_score real default 0)`,
+    vectors: `create table if not exists vectors(id text not null,sector text not null,user_id text,v blob not null,dim integer not null,primary key(id,sector))`,
+    waypoints: `create table if not exists waypoints(src_id text,dst_id text not null,user_id text,weight real not null,created_at integer,updated_at integer,primary key(src_id,user_id))`,
+    embed_logs: `create table if not exists embed_logs(id text primary key,model text,status text,ts integer,err text)`,
+    users: `create table if not exists users(user_id text primary key,summary text,reflection_count integer default 0,created_at integer,updated_at integer)`,
+    stats: `create table if not exists stats(id integer primary key autoincrement,type text not null,count integer default 1,ts integer not null)`,
+    temporal_facts: `create table if not exists temporal_facts(id text primary key,subject text not null,predicate text not null,object text not null,valid_from integer not null,valid_to integer,confidence real not null check(confidence >= 0 and confidence <= 1),last_updated integer not null,metadata text,unique(subject,predicate,object,valid_from))`,
+    temporal_edges: `create table if not exists temporal_edges(id text primary key,source_id text not null,target_id text not null,relation_type text not null,valid_from integer not null,valid_to integer,weight real not null,metadata text,foreign key(source_id) references temporal_facts(id),foreign key(target_id) references temporal_facts(id))`,
+};
+
+const INDEX_DEFINITIONS = [
+    "create index if not exists idx_memories_sector on memories(primary_sector)",
+    "create index if not exists idx_memories_segment on memories(segment)",
+    "create index if not exists idx_memories_simhash on memories(simhash)",
+    "create index if not exists idx_memories_ts on memories(last_seen_at)",
+    "create index if not exists idx_memories_user on memories(user_id)",
+    "create index if not exists idx_vectors_user on vectors(user_id)",
+    "create index if not exists idx_waypoints_src on waypoints(src_id)",
+    "create index if not exists idx_waypoints_dst on waypoints(dst_id)",
+    "create index if not exists idx_waypoints_user on waypoints(user_id)",
+    "create index if not exists idx_stats_ts on stats(ts)",
+    "create index if not exists idx_stats_type on stats(type)",
+    "create index if not exists idx_temporal_subject on temporal_facts(subject)",
+    "create index if not exists idx_temporal_predicate on temporal_facts(predicate)",
+    "create index if not exists idx_temporal_validity on temporal_facts(valid_from,valid_to)",
+    "create index if not exists idx_temporal_composite on temporal_facts(subject,predicate,valid_from,valid_to)",
+    "create index if not exists idx_edges_source on temporal_edges(source_id)",
+    "create index if not exists idx_edges_target on temporal_edges(target_id)",
+    "create index if not exists idx_edges_validity on temporal_edges(valid_from,valid_to)",
+];
+
+async function get_existing_tables(): Promise<Set<string>> {
+    const tables = await all_async(
+        `SELECT name FROM sqlite_master WHERE type='table'`,
+    );
+    return new Set(tables.map((t) => t.name));
+}
+
+async function get_existing_indexes(): Promise<Set<string>> {
+    const indexes = await all_async(
+        `SELECT name FROM sqlite_master WHERE type='index' AND name NOT LIKE 'sqlite_%'`,
+    );
+    return new Set(indexes.map((i) => i.name));
+}
+
+async function run_migrations() {
+    console.log("[MIGRATE] Starting automatic migration...");
+
+    const existing_tables = await get_existing_tables();
+    const existing_indexes = await get_existing_indexes();
+
+    let created_tables = 0;
+    let created_indexes = 0;
+
+    for (const [table_name, schema] of Object.entries(SCHEMA_DEFINITIONS)) {
+        if (!existing_tables.has(table_name)) {
+            console.log(`[MIGRATE] Creating table: ${table_name}`);
+            const statements = schema.split(";").filter((s) => s.trim());
+            for (const stmt of statements) {
+                if (stmt.trim()) {
+                    await run_async(stmt.trim());
+                }
+            }
+            created_tables++;
+        }
+    }
+
+    for (const index_sql of INDEX_DEFINITIONS) {
+        const match = index_sql.match(/create index if not exists (\w+)/);
+        const index_name = match ? match[1] : null;
+        if (index_name && !existing_indexes.has(index_name)) {
+            console.log(`[MIGRATE] Creating index: ${index_name}`);
+            await run_async(index_sql);
+            created_indexes++;
+        }
+    }
+
+    console.log(
+        `[MIGRATE] Migration complete: ${created_tables} tables, ${created_indexes} indexes created`,
+    );
+
+    const final_tables = await get_existing_tables();
+    console.log(`[MIGRATE] Total tables: ${final_tables.size}`);
+    console.log(`[MIGRATE] Tables: ${Array.from(final_tables).join(", ")}`);
+}
+
+run_migrations().catch((err) => {
+    console.error("[MIGRATE] Error:", err);
+    process.exit(1);
+});

package/src/core/cfg.ts

@@ -0,0 +1,110 @@
+import path from "path";
+import dotenv from "dotenv";
+
+dotenv.config({ path: path.resolve(__dirname, "../../../../.env") });
+const num = (v: string | undefined, d: number) => Number(v) || d;
+const str = (v: string | undefined, d: string) => v || d;
+const bool = (v: string | undefined) => v === "true";
+type tier = "fast" | "smart" | "deep" | "hybrid";
+
+const get_tier = (): tier => {
+    const man = process.env.OM_TIER as tier;
+    if (man && ["fast", "smart", "deep", "hybrid"].includes(man)) return man;
+    console.warn(
+        "[OpenMemory] OM_TIER not set! Please set OM_TIER=hybrid|fast|smart|deep in .env",
+    );
+    return "hybrid";
+};
+export const tier = get_tier();
+const tier_dims = { fast: 1536, smart: 1536, deep: 1536, hybrid: 1536 };
+const tier_cache = { fast: 2, smart: 3, deep: 5, hybrid: 3 };
+const tier_max_active = { fast: 32, smart: 64, deep: 128, hybrid: 64 };
+
+export const env = {
+    port: num(process.env.OM_PORT, 8080),
+    db_path: str(
+        process.env.OM_DB_PATH,
+        path.resolve(__dirname, "../../data/openmemory.sqlite"),
+    ),
+    api_key: process.env.OM_API_KEY,
+    rate_limit_enabled: bool(process.env.OM_RATE_LIMIT_ENABLED),
+    rate_limit_window_ms: num(process.env.OM_RATE_LIMIT_WINDOW_MS, 60000),
+    rate_limit_max_requests: num(process.env.OM_RATE_LIMIT_MAX_REQUESTS, 100),
+    compression_enabled: bool(process.env.OM_COMPRESSION_ENABLED),
+    compression_algorithm: str(process.env.OM_COMPRESSION_ALGORITHM, "auto") as
+        | "semantic"
+        | "syntactic"
+        | "aggressive"
+        | "auto",
+    compression_min_length: num(process.env.OM_COMPRESSION_MIN_LENGTH, 100),
+    emb_kind: str(process.env.OM_EMBEDDINGS, "synthetic"),
+    embedding_fallback: str(process.env.OM_EMBEDDING_FALLBACK, "synthetic")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean),
+    embed_mode: str(process.env.OM_EMBED_MODE, "simple"),
+    adv_embed_parallel: bool(process.env.OM_ADV_EMBED_PARALLEL),
+    embed_delay_ms: num(process.env.OM_EMBED_DELAY_MS, 200),
+    openai_key:
+        process.env.OPENAI_API_KEY || process.env.OM_OPENAI_API_KEY || "",
+    openai_base_url: str(
+        process.env.OM_OPENAI_BASE_URL,
+        "https://api.openai.com/v1",
+    ),
+    openai_model: process.env.OM_OPENAI_MODEL,
+    gemini_key:
+        process.env.GEMINI_API_KEY || process.env.OM_GEMINI_API_KEY || "",
+    AWS_REGION: process.env.AWS_REGION || "",
+    AWS_ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID || "",
+    AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY || "",
+    ollama_url: str(
+        process.env.OLLAMA_URL || process.env.OM_OLLAMA_URL,
+        "http://localhost:11434",
+    ),
+    local_model_path:
+        process.env.LOCAL_MODEL_PATH || process.env.OM_LOCAL_MODEL_PATH || "",
+    vec_dim: num(process.env.OM_VEC_DIM, tier_dims[tier]),
+    min_score: num(process.env.OM_MIN_SCORE, 0.3),
+    decay_lambda: num(process.env.OM_DECAY_LAMBDA, 0.02),
+    decay_interval_minutes: num(process.env.OM_DECAY_INTERVAL_MINUTES, 1440),
+    max_payload_size: num(process.env.OM_MAX_PAYLOAD_SIZE, 1_000_000),
+    mode: str(process.env.OM_MODE, "standard").toLowerCase(),
+    lg_namespace: str(process.env.OM_LG_NAMESPACE, "default"),
+    lg_max_context: num(process.env.OM_LG_MAX_CONTEXT, 50),
+    lg_reflective: (process.env.OM_LG_REFLECTIVE ?? "true") !== "false",
+    metadata_backend: str(
+        process.env.OM_METADATA_BACKEND,
+        "sqlite",
+    ).toLowerCase(),
+    vector_backend: str(process.env.OM_VECTOR_BACKEND, "postgres").toLowerCase(),
+    valkey_host: str(process.env.OM_VALKEY_HOST, "localhost"),
+    valkey_port: num(process.env.OM_VALKEY_PORT, 6379),
+    valkey_password: process.env.OM_VALKEY_PASSWORD,
+    ide_mode: bool(process.env.OM_IDE_MODE),
+    ide_allowed_origins: str(
+        process.env.OM_IDE_ALLOWED_ORIGINS,
+        "http://localhost:5173,http://localhost:3000",
+    ).split(","),
+    auto_reflect: bool(process.env.OM_AUTO_REFLECT),
+    reflect_interval: num(process.env.OM_REFLECT_INTERVAL, 10),
+    reflect_min: num(process.env.OM_REFLECT_MIN_MEMORIES, 20),
+    user_summary_interval: num(process.env.OM_USER_SUMMARY_INTERVAL, 30),
+    use_summary_only: (process.env.OM_USE_SUMMARY_ONLY ?? "true") !== "false",
+    summary_max_length: num(process.env.OM_SUMMARY_MAX_LENGTH, 200),
+    seg_size: num(process.env.OM_SEG_SIZE, 10000),
+    cache_segments: num(process.env.OM_CACHE_SEGMENTS, tier_cache[tier]),
+    max_active: num(process.env.OM_MAX_ACTIVE, tier_max_active[tier]),
+    decay_ratio: num(process.env.OM_DECAY_RATIO, 0.03),
+    decay_sleep_ms: num(process.env.OM_DECAY_SLEEP_MS, 200),
+    decay_threads: num(process.env.OM_DECAY_THREADS, 3),
+    decay_cold_threshold: num(process.env.OM_DECAY_COLD_THRESHOLD, 0.25),
+    decay_reinforce_on_query:
+        (process.env.OM_DECAY_REINFORCE_ON_QUERY ?? "true") !== "false",
+    regeneration_enabled:
+        (process.env.OM_REGENERATION_ENABLED ?? "true") !== "false",
+    max_vector_dim: num(process.env.OM_MAX_VECTOR_DIM, tier_dims[tier]),
+    min_vector_dim: num(process.env.OM_MIN_VECTOR_DIM, 64),
+    summary_layers: num(process.env.OM_SUMMARY_LAYERS, 3),
+    keyword_boost: num(process.env.OM_KEYWORD_BOOST, 2.5),
+    keyword_min_length: num(process.env.OM_KEYWORD_MIN_LENGTH, 3),
+};