@modusensus/dsh-mneme 0.7.11 → 0.7.12

package/src/config.js

@@ -249,4 +249,53 @@ export const Config = z.object({
   // audits to recall_runs and NEVER touches recall_evals, regardless of this
   // flag (production isolation is unconditional).
   evalPersistTestResults: z.boolean().default(false),
+
+  // --- standalone external API (v0.7.12) ------------------------------------
+  // A plain node:http server for ecosystem integrations that cannot reach the
+  // DSH-internal webServer. Disabled by default; when enabled the Bearer token
+  // is persisted in the settings kv ("external_api"), auto-generated on first
+  // boot. Bind host: keep the loopback default — moving it to a non-loopback
+  // address exposes the whole memory store to the network and is the
+  // operator's responsibility.
+  externalApiEnabled: z.boolean().default(false),
+  externalApiPort: z.natural().default(8790),
+  externalApiHost: z.string().default("127.0.0.1"),
+
+  // --- light mode preset (v0.7.12) -------------------------------------------
+  // One switch for low-resource setups: turns off every background/semantic
+  // heavy path (dream consolidation, entity extraction, vector pipeline,
+  // reranker, BM25, semantic dedup / selective inject, sleep mode) while
+  // keeping the core loop (autoInject, autoSummarize, hot memory, quality
+  // filter, keyword search). Applied by applyLightModePreset before the config
+  // reaches any service; a persisted panel_mode="light" (settings kv) counts
+  // as lightMode=true too and wins over the bundle config.
+  lightMode: z.boolean().default(false),
 });
+
+// Fields forced to false by the light-mode preset. Everything not listed here
+// (autoInject, autoSummarize, hotMemory*, memoryQualityFilter, dream
+// thresholds/delays, ...) is left untouched — those are the core loop.
+const LIGHT_MODE_OFF = [
+  "entityExtractionEnabled",
+  "autoDream",
+  "sleepModeEnabled",
+  "rerankEnabled",
+  "autoReindexOnBoot",
+  "hybridInject",
+  "searchSemanticDedup",
+  "selectiveInjectEnabled",
+  "bm25SearchEnabled"
+];
+
+/**
+ * Apply the light-mode preset to a resolved config object (pure function,
+ * exported for tests). When cfg.lightMode is not exactly true the config is
+ * returned unchanged; otherwise a shallow copy carries false for every heavy
+ * feature. Idempotent and side-effect free.
+ */
+export function applyLightModePreset(cfg) {
+  if (cfg?.lightMode !== true) return cfg;
+  const preset = { ...cfg, lightMode: true };
+  for (const key of LIGHT_MODE_OFF) preset[key] = false;
+  return preset;
+}

package/src/index.js

@@ -7,13 +7,14 @@ import { createSummarizer } from "./summarize.js";
 import { createDreamScheduler } from "./dream.js";
 import { createSleepScheduler, runSleep } from "./dream/sleep.js";
 import { createApi } from "./api.js";
+import { createStandaloneApi } from "./api-standalone.js";
 import { createSettings } from "./settings.js";
 import { createCommandManager } from "./commands.js";
 import { createEmbedder } from "./embedding.js";
 import { createEmbedderByProvider } from "./local-embedder.js";
 import { LocalReranker } from "./reranker.js";
 import { createVectorIndex } from "./vector-index.js";
-import { Config } from "./config.js";
+import { Config, applyLightModePreset } from "./config.js";
 import { extractEntities } from "./entities/extractor.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -29,12 +30,12 @@ export { Config };
 // has no prototype, is called normally, and its returned disposer is collected
 // and run by the fiber on unload.
 export const apply = (ctx, config) => {
-  const cfg = Config(config);
+  const rawCfg = Config(config);
 
   // Resolve memoryDir: expand leading "~"
-  const memoryDir = cfg.memoryDir.startsWith("~")
-    ? join(homedir(), cfg.memoryDir.slice(1))
-    : cfg.memoryDir;
+  const memoryDir = rawCfg.memoryDir.startsWith("~")
+    ? join(homedir(), rawCfg.memoryDir.slice(1))
+    : rawCfg.memoryDir;
   mkdirSync(memoryDir, { recursive: true });
 
   const store = createStore(join(memoryDir, "memory.db"));
@@ -47,11 +48,26 @@ export const apply = (ctx, config) => {
   // default 90). Best-effort like the failure prune — the audit trail is
   // bookkeeping and a failed purge must never block plugin boot.
   try {
-    if (cfg.llmAudit?.enabled !== false) {
-      const retentionMs = Number.isInteger(cfg.llmAudit?.retentionDays) ? cfg.llmAudit.retentionDays : 90;
+    if (rawCfg.llmAudit?.enabled !== false) {
+      const retentionMs = Number.isInteger(rawCfg.llmAudit?.retentionDays) ? rawCfg.llmAudit.retentionDays : 90;
       store.deleteOldLlmAudits(new Date(Date.now() - retentionMs * 86400000).toISOString());
     }
   } catch { /* non-fatal */ }
+
+  // User-configurable settings (profile, rules, panel mode, standalone API
+  // token) share the same SQLite file in dedicated tables, isolated from
+  // memories. Created before the config is finalized: the persisted
+  // panel_mode participates in light-mode resolution below.
+  const settings = createSettings(store.db);
+
+  // Light mode (v0.7.12): the bundle config flag OR a persisted panel_mode of
+  // "light" (the panel switch wins over the bundle config so it survives
+  // config redeploys). applyLightModePreset turns every heavy background /
+  // semantic feature off and keeps the core loop (autoInject, autoSummarize,
+  // hot memory, quality filter).
+  const lightMode = rawCfg.lightMode === true || settings.getPanelMode() === "light";
+  const cfg = applyLightModePreset({ ...rawCfg, lightMode });
+
   const mirror = createMirror(memoryDir);
   const service = createService({ store, mirror, config: cfg, logger: ctx.logger });
 
@@ -78,10 +94,6 @@ export const apply = (ctx, config) => {
     } catch { /* non-fatal: recall recording is bookkeeping */ }
   });
 
-  // User-configurable settings (profile, rules) and custom commands share the
-  // same SQLite file but live in dedicated tables, isolated from memories.
-  const settings = createSettings(store.db);
-
   // Semantic pipeline: a local/ollama embedder when configured, otherwise the
   // legacy OpenAI-compatible embedder (settings-driven). The vector index wraps
   // the store's embedding column and tracks the active model fingerprint. A
@@ -107,7 +119,13 @@ export const apply = (ctx, config) => {
 
   let embedder = null;
   let reranker = null;
-  if (cfg.embedProvider === "openai") {
+  if (lightMode) {
+    // Light mode: the whole vector pipeline stays off — no embedder (nothing
+    // pulls in ONNX/transformers), no reranker, no boot backfill (the preset
+    // also cleared autoReindexOnBoot). Recall degrades to keyword search and
+    // human mirror edits still merge on boot.
+    applyHumanEdits();
+  } else if (cfg.embedProvider === "openai") {
     // vectorIndex is passed so the legacy OpenAI embedder records the producing
     // model fingerprint after each successful embed (Bug3).
     embedder = createEmbedder({ store, settings, logger: ctx.logger, vectorIndex });
@@ -326,6 +344,19 @@ export const apply = (ctx, config) => {
     disposers.push(api.dispose);
   }
 
+  // Standalone external API (v0.7.12): plain node:http server for ecosystem
+  // integrations outside the DSH host. Persisted external_api settings win
+  // over the bundle config (enabled/port); the Bearer token lives in the same
+  // kv and is auto-generated on first boot by createStandaloneApi. Binding a
+  // non-loopback host is the operator's documented responsibility.
+  if ((settings.getExternalApi?.()?.enabled ?? cfg.externalApiEnabled) === true) {
+    const standalone = createStandaloneApi({ service, store, config: cfg, logger: ctx.logger, settings });
+    disposers.push(() => standalone.server.close());
+    standalone.ready.catch((error) => {
+      ctx.logger?.warn?.(`[dsh-mneme] standalone API failed to start: ${String(error)}`);
+    });
+  }
+
   // Async disposer: cordis awaits the returned promise on unload (runDisposable),
   // so an in-flight dream run is allowed to finish before the SQLite store is
   // closed — dream.dispose() resolves only after its current run settles.

package/src/settings.js

@@ -137,6 +137,46 @@ export function createSettings(db) {
       };
       setSetting("vector", JSON.stringify(cfg));
       return cfg;
+    },
+
+    /**
+     * Standalone external API settings (kv "external_api"): {enabled, port,
+     * token}. The Bearer token is auto-generated on first boot and persisted
+     * here. Partial writes preserve the keys they don't mention.
+     */
+    getExternalApi() {
+      const raw = getSetting("external_api");
+      if (!raw) return undefined;
+      try {
+        const cfg = JSON.parse(raw);
+        return typeof cfg === "object" && cfg !== null ? cfg : undefined;
+      } catch {
+        return undefined;
+      }
+    },
+    setExternalApi(patch = {}) {
+      const prev = this.getExternalApi() ?? {};
+      const port = Number(patch.port ?? prev.port);
+      const host = typeof patch.host === "string" && patch.host.trim() ? patch.host.trim() : (prev.host ?? "127.0.0.1");
+      const cfg = {
+        enabled: patch.enabled !== undefined ? patch.enabled === true : prev.enabled === true,
+        port: Number.isInteger(port) && port > 0 ? port : 8790,
+        host,
+        token: String(patch.token ?? prev.token ?? "")
+      };
+      setSetting("external_api", JSON.stringify(cfg));
+      return cfg;
+    },
+
+    /**
+     * Web panel mode (kv "panel_mode"): "light" (low-resource preset) or
+     * "standard" (full feature set). Unset reads as "standard".
+     */
+    getPanelMode() {
+      return getSetting("panel_mode") === "light" ? "light" : "standard";
+    },
+    setPanelMode(mode) {
+      setSetting("panel_mode", mode === "light" ? "light" : "standard");
     }
   };
 }

package/src/store.js

@@ -239,7 +239,10 @@ CREATE TABLE IF NOT EXISTS mirror_state (
 );
 `;
 
-const TYPES = new Set(["preference", "project", "decision", "history", "summary", "pattern"]);
+// Exported for API-layer type validation (standalone API POST /memories and
+// the /status byType breakdown); the set itself stays the single source of
+// truth for what store.save accepts.
+export const TYPES = new Set(["preference", "project", "decision", "history", "summary", "pattern"]);
 
 // Epistemic status: what kind of evidence a memory rests on. Defaults to
 // 'subjective' so legacy rows (and rows without any signal) stay compatible.

package/test/api.test.js

@@ -191,6 +191,50 @@ test("PUT /api/dsh-mneme/rules saves rules", async () => {
   assert.deepEqual(settings.getRules(), ["a", "b"]);
 });
 
+// --- panel mode (light/standard) ---
+
+test("GET /api/dsh-mneme/mode defaults to standard", async () => {
+  const { routes } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/mode");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode"), res);
+  assert.equal(res.statusCode, 200);
+  assert.deepEqual(JSON.parse(res.body), { mode: "standard" });
+});
+
+test("PUT /api/dsh-mneme/mode validates the enum and persists", async () => {
+  const { routes, settings } = setup();
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/mode");
+
+  const put = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "light" }), put);
+  assert.equal(put.statusCode, 200);
+  assert.deepEqual(JSON.parse(put.body), { mode: "light" });
+  assert.equal(settings.getPanelMode(), "light");
+
+  const back = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "standard" }), back);
+  assert.deepEqual(JSON.parse(back.body), { mode: "standard" });
+
+  const bad = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "turbo" }), bad);
+  assert.equal(bad.statusCode, 400);
+  assert.equal(settings.getPanelMode(), "standard", "invalid value not persisted");
+});
+
+test("PUT /api/dsh-mneme/mode is token-gated like other settings writes", async () => {
+  const { routes } = setup(undefined, "secret-token");
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/mode");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/mode", "PUT", { mode: "light" }), res);
+  assert.equal(res.statusCode, 401);
+  const ok = new FakeRes();
+  const authed = req("/api/dsh-mneme/mode", "PUT", { mode: "light" });
+  authed.headers = { authorization: "Bearer secret-token" };
+  await route.handler(authed, ok);
+  assert.equal(ok.statusCode, 200);
+});
+
 test("GET /api/dsh-mneme/commands lists commands", async () => {
   const { routes, settings } = setup();
   settings.addCommand({ name: "agenda", instruction: "x" });

package/test/settings.test.js

@@ -99,3 +99,27 @@ test("vector config disabled value is stored as false", () => {
   assert.equal(settings.getVectorConfig().enabled, false);
   store.close();
 });
+
+test("panel mode defaults to standard and round-trips", () => {
+  const { store, settings } = setup();
+  assert.equal(settings.getPanelMode(), "standard");
+  settings.setPanelMode("light");
+  assert.equal(settings.getPanelMode(), "light");
+  settings.setPanelMode("standard");
+  assert.equal(settings.getPanelMode(), "standard");
+  store.close();
+});
+
+test("external api settings persist token and merge partial writes", () => {
+  const { store, settings } = setup();
+  assert.equal(settings.getExternalApi(), undefined);
+  settings.setExternalApi({ enabled: true, port: 9000, token: "tok-1" });
+  assert.deepEqual(settings.getExternalApi(), { enabled: true, port: 9000, host: "127.0.0.1", token: "tok-1" });
+  // Token-only write preserves the other keys.
+  settings.setExternalApi({ token: "tok-2" });
+  assert.deepEqual(settings.getExternalApi(), { enabled: true, port: 9000, host: "127.0.0.1", token: "tok-2" });
+  // Host write persists and survives the next partial merge.
+  settings.setExternalApi({ host: "0.0.0.0" });
+  assert.deepEqual(settings.getExternalApi(), { enabled: true, port: 9000, host: "0.0.0.0", token: "tok-2" });
+  store.close();
+});

package/test/standalone-api.test.js

@@ -0,0 +1,326 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createSettings } from "../src/settings.js";
+import { createStandaloneApi } from "../src/api-standalone.js";
+import { Config, applyLightModePreset } from "../src/config.js";
+
+// Real HTTP server on an OS-assigned port (port: 0), driven with fetch.
+async function setup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const api = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0 });
+  await api.ready;
+  const base = `http://127.0.0.1:${api.port}`;
+  const auth = { authorization: `Bearer ${api.token}` };
+  return {
+    store,
+    service,
+    settings,
+    api,
+    base,
+    auth,
+    close: () => {
+      // Drop pooled keep-alive sockets so node --test can drain the loop.
+      api.server.closeIdleConnections?.();
+      api.server.close();
+      store.close();
+    }
+  };
+}
+
+// --- auth ---------------------------------------------------------------------
+
+test("GET /health is open without a token; every other route 401s", async () => {
+  const { base, close } = await setup();
+  try {
+    const health = await fetch(`${base}/health`);
+    assert.equal(health.status, 200);
+    assert.deepEqual(await health.json(), { ok: true });
+
+    for (const path of ["/status", "/memories", "/memories/x", "/search?q=x"]) {
+      const res = await fetch(`${base}${path}`);
+      assert.equal(res.status, 401, `${path} requires a token`);
+      assert.deepEqual(await res.json(), { error: "unauthorized" });
+    }
+
+    const bad = await fetch(`${base}/status`, { headers: { authorization: "Bearer wrong-token" } });
+    assert.equal(bad.status, 401, "wrong token rejected");
+  } finally {
+    close();
+  }
+});
+
+test("token is persisted into settings kv and reused across restarts", async () => {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const first = createStandaloneApi({ service, store, config: {}, settings, port: 0 });
+  await first.ready;
+  try {
+    assert.equal(settings.getExternalApi().token, first.token, "generated token persisted");
+    assert.ok(first.token.length >= 20, "token is a real random value");
+    const second = createStandaloneApi({ service, store, config: {}, settings, port: 0 });
+    await second.ready;
+    assert.equal(second.token, first.token, "restart reuses the persisted token");
+    second.server.closeIdleConnections?.();
+    second.server.close();
+  } finally {
+    first.server.closeIdleConnections?.();
+    first.server.close();
+    store.close();
+  }
+});
+
+// --- CRUD loop ------------------------------------------------------------------
+
+test("POST/GET/DELETE /memories round trip", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const post = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "preference", title: "语言", content: "始终用中文回复", importance: 4, tags: ["交流"] })
+    });
+    assert.equal(post.status, 201);
+    const created = await post.json();
+    assert.ok(created.id, "row id returned");
+    assert.equal(created.title, "语言");
+    assert.equal(created.importance, 4);
+
+    const list = await fetch(`${base}/memories?limit=10`, { headers: auth });
+    assert.equal(list.status, 200);
+    const listBody = await list.json();
+    assert.equal(listBody.total, 1);
+    assert.equal(listBody.items.length, 1);
+
+    const got = await fetch(`${base}/memories/${created.id}`, { headers: auth });
+    assert.equal(got.status, 200);
+    assert.equal((await got.json()).content, "始终用中文回复");
+
+    const del = await fetch(`${base}/memories/${created.id}`, { method: "DELETE", headers: auth });
+    assert.equal(del.status, 200);
+    assert.deepEqual(await del.json(), { ok: true });
+
+    const gone = await fetch(`${base}/memories/${created.id}`, { headers: auth });
+    assert.equal(gone.status, 404, "deleted row reads back as 404");
+    const delAgain = await fetch(`${base}/memories/${created.id}`, { method: "DELETE", headers: auth });
+    assert.equal(delAgain.status, 404, "deleting a missing row is 404, not a fake ok");
+  } finally {
+    close();
+  }
+});
+
+test("POST /memories dedupes same title within a type (200 + merged content)", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const first = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "mneme", content: "v1 内容" })
+    });
+    assert.equal(first.status, 201);
+    const row1 = await first.json();
+
+    const second = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "mneme", content: "v2 追加" })
+    });
+    assert.equal(second.status, 200, "merge, not a second creation");
+    const row2 = await second.json();
+    assert.equal(row2.id, row1.id, "same row reused");
+    assert.ok(row2.content.includes("v1 内容") && row2.content.includes("v2 追加"), "content appended");
+
+    const list = await fetch(`${base}/memories`, { headers: auth });
+    assert.equal((await list.json()).total, 1, "no duplicate row created");
+  } finally {
+    close();
+  }
+});
+
+test("POST /memories validation: invalid type, bad JSON, non-array tags → 400", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const badType = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "diary", title: "t", content: "c" })
+    });
+    assert.equal(badType.status, 400);
+    assert.deepEqual(await badType.json(), { error: "invalid-type" });
+
+    const badJson = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: "{not json"
+    });
+    assert.equal(badJson.status, 400);
+    assert.deepEqual(await badJson.json(), { error: "invalid-json" });
+
+    const badTags = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "t", content: "c", tags: "x" })
+    });
+    assert.equal(badTags.status, 400);
+    assert.deepEqual(await badTags.json(), { error: "tags-must-be-an-array" });
+
+    const noTitle = await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", content: "c" })
+    });
+    assert.equal(noTitle.status, 400);
+    assert.deepEqual(await noTitle.json(), { error: "missing-title" });
+  } finally {
+    close();
+  }
+});
+
+// --- list filters / status / search ---------------------------------------------
+
+test("GET /memories honors type + minImportance filters and paging", async () => {
+  const { base, auth, service, close } = await setup();
+  try {
+    service.saveWithDedupe({ type: "preference", title: "低", content: "i2", importance: 2 });
+    service.saveWithDedupe({ type: "preference", title: "高", content: "i5", importance: 5 });
+    service.saveWithDedupe({ type: "project", title: "项目", content: "i4", importance: 4 });
+
+    const byType = await fetch(`${base}/memories?type=preference`, { headers: auth });
+    assert.equal((await byType.json()).total, 2);
+
+    const byImportance = await fetch(`${base}/memories?minImportance=4`, { headers: auth });
+    const filtered = await byImportance.json();
+    assert.equal(filtered.total, 2);
+    assert.deepEqual(filtered.items.map((m) => m.title).sort(), ["项目", "高"]);
+
+    const paged = await fetch(`${base}/memories?limit=2&offset=0&order=chrono`, { headers: auth });
+    const page = await paged.json();
+    assert.equal(page.items.length, 2);
+    assert.equal(page.total, 3);
+  } finally {
+    close();
+  }
+});
+
+test("GET /status reports version, per-type totals, entities and uptime", async () => {
+  const { base, auth, service, close } = await setup();
+  try {
+    service.saveWithDedupe({ type: "preference", title: "p", content: "c" });
+    service.saveWithDedupe({ type: "project", title: "j", content: "c" });
+    service.saveWithDedupe({ type: "project", title: "j2", content: "c" });
+
+    const res = await fetch(`${base}/status`, { headers: auth });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.version, "0.7.12");
+    assert.equal(body.memories.total, 3);
+    assert.equal(body.memories.byType.preference, 1);
+    assert.equal(body.memories.byType.project, 2);
+    assert.equal(body.entities, 0, "no extraction wired → empty entity table");
+    assert.ok(Number.isInteger(body.uptime_s));
+  } finally {
+    close();
+  }
+});
+
+test("GET /search finds saved memories; empty q returns empty keyword result", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    await fetch(`${base}/memories`, {
+      method: "POST",
+      headers: { ...auth, "content-type": "application/json" },
+      body: JSON.stringify({ type: "project", title: "记忆插件", content: "SQLite 全文检索" })
+    });
+
+    const res = await fetch(`${base}/search?q=${encodeURIComponent("全文检索")}&mode=keyword`, { headers: auth });
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.mode, "keyword");
+    assert.equal(body.items.length, 1);
+    assert.equal(body.items[0].title, "记忆插件");
+
+    const empty = await fetch(`${base}/search?q=`, { headers: auth });
+    assert.deepEqual(await empty.json(), { items: [], mode: "keyword" });
+  } finally {
+    close();
+  }
+});
+
+test("unknown path returns 404 json", async () => {
+  const { base, auth, close } = await setup();
+  try {
+    const res = await fetch(`${base}/nope`, { headers: auth });
+    assert.equal(res.status, 404);
+    assert.deepEqual(await res.json(), { error: "not-found" });
+  } finally {
+    close();
+  }
+});
+
+// --- light-mode preset (applyLightModePreset) ------------------------------------
+
+const LIGHT_OFF_FIELDS = [
+  "entityExtractionEnabled",
+  "autoDream",
+  "sleepModeEnabled",
+  "rerankEnabled",
+  "autoReindexOnBoot",
+  "hybridInject",
+  "searchSemanticDedup",
+  "selectiveInjectEnabled",
+  "bm25SearchEnabled"
+];
+
+test("applyLightModePreset turns heavy features off and keeps the core loop", () => {
+  const cfg = applyLightModePreset(Config({ lightMode: true }));
+  for (const field of LIGHT_OFF_FIELDS) {
+    assert.equal(cfg[field], false, `${field} forced off in light mode`);
+  }
+  // Core loop preserved.
+  assert.equal(cfg.autoInject, true);
+  assert.equal(cfg.autoSummarize, true);
+  assert.equal(cfg.hotMemoryEnabled, true);
+  assert.equal(cfg.memoryQualityFilter.enabled, true);
+  // Unrelated knobs untouched.
+  assert.equal(cfg.dreamThresholdCount, 10);
+  assert.equal(cfg.dreamDelayMs, 2000);
+  assert.equal(cfg.maxInjectedItems, 5);
+});
+
+test("applyLightModePreset keeps explicit non-preset values and is a no-op without lightMode", () => {
+  const tuned = applyLightModePreset(Config({ lightMode: true, dreamThresholdCount: 30, maxInjectedItems: 8 }));
+  assert.equal(tuned.dreamThresholdCount, 30, "operator values survive the preset");
+  assert.equal(tuned.maxInjectedItems, 8);
+
+  const plain = Config({});
+  assert.equal(applyLightModePreset(plain), plain, "identity when lightMode is unset");
+  const off = Config({ lightMode: false });
+  assert.equal(applyLightModePreset(off), off, "identity when lightMode is false");
+});
+
+test("persisted panel_mode=light wins over a bundle config that did not ask for it", () => {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  try {
+    // Panel switched to light in a previous session; bundle config says nothing.
+    settings.setPanelMode("light");
+    const rawCfg = Config({});
+    const lightMode = rawCfg.lightMode === true || settings.getPanelMode() === "light";
+    const cfg = applyLightModePreset({ ...rawCfg, lightMode });
+    assert.equal(lightMode, true, "persisted mode forces light");
+    assert.equal(cfg.autoDream, false);
+    assert.equal(cfg.entityExtractionEnabled, false);
+    assert.equal(cfg.autoInject, true, "core injection stays on");
+
+    // standard (default) never forces the preset even with a light bundle flag off.
+    settings.setPanelMode("standard");
+    const raw2 = Config({});
+    assert.equal(raw2.lightMode === true || settings.getPanelMode() === "light", false);
+  } finally {
+    store.close();
+  }
+});