dsh-memsys 0.1.0 → 0.2.1

package/src/import/pointers.mjs

@@ -5,6 +5,32 @@ import { withImmediate } from '../storage/open.mjs';
 import { appendRelation } from '../storage/repositories.mjs';
 import { WriteError } from '../write/authority.mjs';
 
+export function verifyPointerSource({ row, match, observationText }) {
+  if (!match?.file || !match?.span) return { ok: false, reason: 'no_file_version_evidence' };
+  const start = Number(match.span.start);
+  const end = Number(match.span.end);
+  let bytes;
+  try {
+    bytes = fs.readFileSync(match.file);
+  } catch (err) {
+    return { ok: false, reason: 'file_unreadable', error: err.message };
+  }
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > bytes.length || start >= end) {
+    return { ok: false, reason: 'span_out_of_range' };
+  }
+  const slice = bytes.slice(start, end);
+  const spanHash = crypto.createHash('sha256').update(slice).digest('hex');
+  if (spanHash !== match.spanHash) return { ok: false, reason: 'span_hash_mismatch' };
+  const fileHash = crypto.createHash('sha256').update(bytes).digest('hex');
+  if (match.fileHash && fileHash !== match.fileHash) return { ok: false, reason: 'file_hash_mismatch' };
+  if (match.location !== `${match.file}#bytes:${start}-${end}`) return { ok: false, reason: 'location_not_byte_binding' };
+  if (typeof observationText !== 'string' || slice.toString('utf8') !== observationText) {
+    return { ok: false, reason: 'observation_text_mismatch' };
+  }
+  if (match.versionHash !== row.source_version_hash) return { ok: false, reason: 'version_hash_mismatch' };
+  return { ok: true, spanHash, fileHash, observationText };
+}
+
 /** Match the imported source version, never "the latest path with this name". */
 export function planPointers({ main, clock }, versionsFile) {
   const parsed = JSON.parse(fs.readFileSync(versionsFile, 'utf8'));
@@ -35,28 +61,14 @@ export function planPointers({ main, clock }, versionsFile) {
       skipped.push({ sourceObjectId: row.source_object_id, reason: 'no_version_match' });
       continue;
     }
-    if (!match.file || !match.span || !match.spanHash) {
-      skipped.push({ sourceObjectId: row.source_object_id, reason: 'no_file_version_evidence' });
-      continue;
-    }
-    let spanHash = null;
-    try {
-      const bytes = fs.readFileSync(match.file);
-      const start = Number(match.span.start);
-      const end = Number(match.span.end);
-      if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > bytes.length || start >= end) {
-        skipped.push({ sourceObjectId: row.source_object_id, reason: 'span_out_of_range' });
-        continue;
-      }
-      spanHash = crypto.createHash('sha256').update(bytes.slice(start, end)).digest('hex');
-    } catch (err) {
-      skipped.push({ sourceObjectId: row.source_object_id, reason: 'file_unreadable', error: err.message });
-      continue;
-    }
-    if (spanHash !== match.spanHash) {
-      skipped.push({ sourceObjectId: row.source_object_id, reason: 'span_hash_mismatch' });
+    const observationId = targets[0];
+    const observation = observationId ? main.prepare('SELECT * FROM observations WHERE id = ?').get(observationId) : null;
+    const observed = verifyPointerSource({ row, match, observationText: observation?.text });
+    if (!observed.ok) {
+      skipped.push({ sourceObjectId: row.source_object_id, reason: observed.reason, error: observed.error });
       continue;
     }
+    const spanHash = observed.spanHash;
     const pointer = main.prepare('SELECT * FROM pointers WHERE memory_id = ?').get(memoryId);
     if (pointer?.status === 'exact' && pointer.location === match.location) {
       skipped.push({ sourceObjectId: row.source_object_id, reason: 'already_exact' });
@@ -73,6 +85,8 @@ export function planPointers({ main, clock }, versionsFile) {
       file: match.file,
       span: match.span,
       spanHash,
+      sourceFileHash: observed.fileHash,
+      observationHash: payloadHash(observed.observationText),
       revision,
     };
     items.push({
@@ -91,8 +105,36 @@ export function planPointers({ main, clock }, versionsFile) {
 }
 
 export function applyPointers({ main, clock }, plan) {
+  const recomputed = payloadHash({ policy: 'legacy-v1', items: plan.items, skipped: plan.skipped });
+  if (recomputed !== plan.planHash) throw new WriteError('plan_hash_mismatch');
   const applied = [];
   for (const item of plan.items) {
+    let bytes;
+    try {
+      bytes = fs.readFileSync(item.payload.file);
+    } catch (err) {
+      throw new WriteError('source_unreadable', { memoryId: item.memoryId, error: err.message });
+    }
+    const start = Number(item.payload.span.start);
+    const end = Number(item.payload.span.end);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > bytes.length || start >= end) {
+      throw new WriteError('source_span_changed', { memoryId: item.memoryId });
+    }
+    const spanHash = crypto.createHash('sha256').update(bytes.slice(start, end)).digest('hex');
+    const fileHash = crypto.createHash('sha256').update(bytes).digest('hex');
+    const evidence = main
+      .prepare('SELECT observation_id FROM evidence WHERE memory_id = ? ORDER BY id LIMIT 1')
+      .get(item.memoryId);
+    const observation = evidence?.observation_id
+      ? main.prepare('SELECT text FROM observations WHERE id = ?').get(evidence.observation_id)
+      : null;
+    if (
+      spanHash !== item.payload.spanHash ||
+      fileHash !== item.payload.sourceFileHash ||
+      payloadHash(observation?.text ?? '') !== item.payload.observationHash
+    ) {
+      throw new WriteError('source_bytes_changed', { memoryId: item.memoryId });
+    }
     const exists = main
       .prepare(
         "SELECT payload FROM relations WHERE type = 'pointer-change' AND json_extract(payload, '$.memoryId') = ? AND json_extract(payload, '$.basis') = 'pointer-backfill'",

package/src/import/rollback.mjs

@@ -1,16 +1,24 @@
+import { canonicalJson } from '../identity.mjs';
+
 const TABLES = ['observations', 'candidates', 'memories', 'relations', 'import_items', 'timeline', 'pointers'];
+const ID_TABLES = {
+  observations: 'id',
+  candidates: 'id',
+  memories: 'id',
+  relations: 'id',
+  import_items: 'id',
+};
+
+function rowHash(row) {
+  return canonicalJson({ ...row });
+}
 
 export function compareBusinessCounts({ db, expected = {} }) {
   const missing = [];
   const counts = {};
   for (const [table, minimum] of Object.entries(expected)) {
     if (!TABLES.includes(table)) continue;
-    let actual = 0;
-    try {
-      actual = Number(db.prepare('SELECT COUNT(*) AS n FROM ' + table).get().n);
-    } catch {
-      actual = 0;
-    }
+    const actual = Number(db.prepare('SELECT COUNT(*) AS n FROM ' + table).get().n);
     counts[table] = actual;
     if (actual < Number(minimum)) missing.push(table);
   }
@@ -20,60 +28,105 @@ export function compareBusinessCounts({ db, expected = {} }) {
 export function snapshotBusinessCounts(db) {
   const counts = {};
   for (const table of TABLES) {
-    try {
-      counts[table] = Number(db.prepare('SELECT COUNT(*) AS n FROM ' + table).get().n);
-    } catch {
-      counts[table] = 0;
-    }
+    counts[table] = Number(db.prepare('SELECT COUNT(*) AS n FROM ' + table).get().n);
   }
   return counts;
 }
 
-const ID_TABLES = {
-  observations: 'id',
-  candidates: 'id',
-  memories: 'id',
-  relations: 'id',
-  import_items: 'item_id',
-};
-
 export function snapshotBusinessRows(db) {
   const ids = {};
+  const content = {};
   for (const [table, key] of Object.entries(ID_TABLES)) {
-    try {
-      ids[table] = db.prepare('SELECT ' + key + ' AS id FROM ' + table + ' ORDER BY 1').all().map((row) => row.id);
-    } catch {
-      ids[table] = [];
-    }
+    const rows = db.prepare('SELECT * FROM ' + table + ' ORDER BY ' + key).all();
+    ids[table] = rows.map((row) => row[key]);
+    content[table] = Object.fromEntries(rows.map((row) => [row[key], rowHash(row)]));
+  }
+  const links = {};
+  for (const memoryId of ids.memories ?? []) {
+    const timeline = db.prepare('SELECT * FROM timeline WHERE memory_id = ?').get(memoryId) ?? null;
+    const pointer = db.prepare('SELECT * FROM pointers WHERE memory_id = ?').get(memoryId) ?? null;
+    const evidence = db.prepare('SELECT id FROM evidence WHERE memory_id = ? ORDER BY id').all(memoryId).map((row) => row.id);
+    links[memoryId] = {
+      timeline: timeline ? rowHash(timeline) : null,
+      pointer: pointer ? rowHash(pointer) : null,
+      evidence,
+    };
   }
-  return { counts: snapshotBusinessCounts(db), ids };
+  return { counts: snapshotBusinessCounts(db), ids, content, links };
 }
 
 export function compareBusinessRows({ db, baseline = {} }) {
   const missing = [];
   const ids = baseline.ids ?? {};
+  const content = baseline.content ?? {};
   for (const [table, key] of Object.entries(ID_TABLES)) {
     for (const id of ids[table] ?? []) {
-      let row = null;
-      try {
-        row = db.prepare('SELECT ' + key + ' AS id FROM ' + table + ' WHERE ' + key + ' = ?').get(id);
-      } catch {
-        row = null;
+      const row = db.prepare('SELECT * FROM ' + table + ' WHERE ' + key + ' = ?').get(id);
+      if (!row) {
+        missing.push(table + ':' + id);
+        continue;
+      }
+      const expectedHash = content[table]?.[id];
+      if (expectedHash && rowHash(row) !== expectedHash) {
+        missing.push(table + ':content:' + id);
       }
-      if (!row) missing.push(table + ':' + id);
     }
   }
   for (const memoryId of ids.memories ?? []) {
-    try {
-      const timeline = db.prepare('SELECT 1 AS ok FROM timeline WHERE memory_id = ?').get(memoryId);
-      const pointer = db.prepare('SELECT 1 AS ok FROM pointers WHERE memory_id = ?').get(memoryId);
-      const evidence = db.prepare('SELECT 1 AS ok FROM evidence WHERE memory_id = ? LIMIT 1').get(memoryId);
-      if (!timeline || !pointer || !evidence) missing.push('memory_links:' + memoryId);
-    } catch {
+    const expected = baseline.links?.[memoryId];
+    const timeline = db.prepare('SELECT * FROM timeline WHERE memory_id = ?').get(memoryId) ?? null;
+    const pointer = db.prepare('SELECT * FROM pointers WHERE memory_id = ?').get(memoryId) ?? null;
+    const evidence = db.prepare('SELECT id FROM evidence WHERE memory_id = ? ORDER BY id').all(memoryId).map((row) => row.id);
+    if (!timeline || !pointer || evidence.length === 0) {
       missing.push('memory_links:' + memoryId);
+      continue;
+    }
+    if (expected) {
+      if ((timeline ? rowHash(timeline) : null) !== expected.timeline) missing.push('timeline:content:' + memoryId);
+      if ((pointer ? rowHash(pointer) : null) !== expected.pointer) missing.push('pointer:content:' + memoryId);
+      if (canonicalJson(evidence) !== canonicalJson(expected.evidence)) missing.push('evidence:content:' + memoryId);
     }
   }
   const counts = compareBusinessCounts({ db, expected: baseline.counts ?? {} });
   for (const key of counts.missing) missing.push('count:' + key);
   return { ok: missing.length === 0, missing, counts: counts.counts };
 }
+
+const FREEZE_TABLES = {
+  main: ['observations', 'candidates', 'memories', 'relations', 'timeline', 'pointers', 'evidence', 'import_items', 'graph_nodes', 'graph_edges'],
+  control: ['operations', 'object_streams', 'context_snapshots', 'snapshot_groups', 'snapshot_items', 'operation_attempts'],
+  dream: ['dreams', 'propositions', 'relations', 'confirmation_snapshots'],
+};
+
+function tableFingerprint(db, table) {
+  const rows = db.prepare('SELECT * FROM ' + table + ' ORDER BY rowid').all();
+  return { count: rows.length, hash: canonicalJson(rows) };
+}
+
+export function snapshotDatabaseFreeze({ main, control, dream }) {
+  const freeze = { versions: {}, tables: {} };
+  for (const [label, db] of Object.entries({ main, control, dream })) {
+    if (!db) continue;
+    freeze.versions[label] = Number(db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations').get().version);
+    freeze.tables[label] = {};
+    for (const table of FREEZE_TABLES[label] ?? []) {
+      freeze.tables[label][table] = tableFingerprint(db, table);
+    }
+  }
+  return freeze;
+}
+
+export function compareDatabaseFreeze({ main, control, dream }, freeze = {}) {
+  const missing = [];
+  for (const [label, db] of Object.entries({ main, control, dream })) {
+    if (!db || !freeze.versions?.[label]) continue;
+    const version = Number(db.prepare('SELECT COALESCE(MAX(version), 0) AS version FROM schema_migrations').get().version);
+    if (version !== Number(freeze.versions[label])) missing.push(label + ':version');
+    for (const [table, expected] of Object.entries(freeze.tables?.[label] ?? {})) {
+      const actual = tableFingerprint(db, table);
+      if (actual.count !== expected.count) missing.push(label + ':' + table + ':count');
+      else if (actual.hash !== expected.hash) missing.push(label + ':' + table + ':content');
+    }
+  }
+  return { ok: missing.length === 0, missing };
+}

package/src/read/get.mjs

@@ -156,7 +156,7 @@ export function getMemories({
     return { status: 'error', code: 'validation_error', message: 'invalid_view', clock: reading };
   }
 
-  let state = { ids, index: 0, offset: 0, versions: null };
+  let state = { ids, index: 0, offset: 0, versions: null, evIndex: null, evOffset: 0 };
   if (cursor !== null) {
     const decoded = decodeGetCursor(cursor);
     if (!decoded || decoded.ids.join(',') !== ids.join(',')) {
@@ -166,7 +166,7 @@ export function getMemories({
     if (JSON.stringify(decoded.versions ?? {}) !== JSON.stringify(currentVersions)) {
       return { status: 'error', code: 'stale_cursor', clock: reading };
     }
-    state = { ids: decoded.ids, index: decoded.index, offset: decoded.offset, versions: decoded.versions };
+    state = { ids: decoded.ids, index: decoded.index, offset: decoded.offset, versions: decoded.versions, evIndex: decoded.evIndex ?? null, evOffset: decoded.evOffset ?? 0 };
   }
 
   const budget = clampChars(maxChars);
@@ -252,19 +252,70 @@ export function getMemories({
       history: view === 'history',
     });
     const text = formatted.text ?? '';
+    if (state.evIndex !== null) {
+      let left = budget - used;
+      const fragments = [];
+      let nextEv = null;
+      for (let e = state.evIndex; e < formatted.evidence.length; e += 1) {
+        const entry = formatted.evidence[e];
+        if (typeof entry.observation_text !== 'string' || entry.observation_text.length === 0) continue;
+        const chars = Array.from(entry.observation_text);
+        const start = e === state.evIndex ? state.evOffset : 0;
+        const take = Math.max(0, Math.min(chars.length - start, left));
+        if (take > 0) fragments.push({ ...entry, observation_text: chars.slice(start, start + take).join(''), observation_text_truncated: start + take < chars.length });
+        left -= take;
+        if (start + take < chars.length) {
+          nextEv = { evIndex: e, evOffset: start + take };
+          break;
+        }
+      }
+      items.push({ ...formatted, evidence: fragments });
+      used = budget - left;
+      if (nextEv === null) {
+        index += 1;
+        offset = 0;
+        state.evIndex = null;
+        state.evOffset = 0;
+        continue;
+      }
+      const nextCursor = encodeGetCursor({
+        ids, index, offset: 0, evIndex: nextEv.evIndex, evOffset: nextEv.evOffset,
+        versions: state.versions ?? versionMapOf(main, ids),
+      });
+      return { status: 'ok', items, missing_ids: missing, snapshot_revision: currentRevision(main), next_cursor: nextCursor, truncated: true, clock: reading };
+    }
     if (offset === 0 && used + codePoints(text) <= budget) {
       if (includeEvidence && Array.isArray(formatted.evidence)) {
         let left = budget - used - codePoints(text);
-        for (const entry of formatted.evidence) {
-          if (typeof entry.observation_text !== 'string' || entry.observation_text.length === 0) continue;
+        let nextEv = null;
+        const kept = [];
+        for (let e = 0; e < formatted.evidence.length; e += 1) {
+          const entry = formatted.evidence[e];
+          if (typeof entry.observation_text !== 'string' || entry.observation_text.length === 0) {
+            kept.push(entry);
+            continue;
+          }
           const chars = Array.from(entry.observation_text);
           if (chars.length <= left) {
             left -= chars.length;
+            kept.push(entry);
             continue;
           }
-          entry.observation_text = chars.slice(0, Math.max(0, left)).join('');
-          entry.observation_text_truncated = true;
+          const take = Math.max(0, left);
+          kept.push({ ...entry, observation_text: chars.slice(0, take).join(''), observation_text_truncated: true });
+          nextEv = { evIndex: e, evOffset: take };
           left = 0;
+          break;
+        }
+        formatted.evidence = kept;
+        if (nextEv !== null) {
+          items.push(formatted);
+          used = budget;
+          const nextCursor = encodeGetCursor({
+            ids, index, offset: 0, evIndex: nextEv.evIndex, evOffset: nextEv.evOffset,
+            versions: state.versions ?? versionMapOf(main, ids),
+          });
+          return { status: 'ok', items, missing_ids: missing, snapshot_revision: currentRevision(main), next_cursor: nextCursor, truncated: true, clock: reading };
         }
       }
       items.push(formatted);

package/src/runtime/inject-round.mjs

@@ -0,0 +1,138 @@
+import { resolveConfig } from '../config.mjs';
+import { openAll } from '../storage/open.mjs';
+import { migrateAll } from '../storage/migrate.mjs';
+import { systemClock } from '../clock.mjs';
+import { withImmediate } from '../storage/open.mjs';
+
+const TOOLS_ONLY_TEXT = '[memsys] 注入：tools-only（未取得宿主预算与回执，不作逐轮交付承诺）';
+
+function sessionIdOf(turn) {
+  return turn?.session?.header?.id ?? turn?.sessionId ?? turn?.session?.id ?? null;
+}
+
+/**
+ * Runtime bridge between session turn events and the compile pipeline.
+ * Subscription is owned here (not the section), so a new turn refreshes text
+ * before the next prompt section read; no reply receipt means delivery=unknown.
+ */
+export function createRoundInjector({
+  ctx = null,
+  dataDir,
+  modules = null,
+  compileRound,
+  tokenizer = null,
+  H = null,
+  mode = 'work',
+  clock = systemClock,
+  logger = console,
+  handles = null,
+} = {}) {
+  const ownedHandles = !handles;
+  const stores = handles ?? openAll(resolveConfig({ dataDir }));
+  if (ownedHandles) migrateAll(stores, { clock });
+  let state = {
+    text: '',
+    delivery: 'unknown',
+    delivery_level: 'empty',
+    manifest: null,
+    sessionId: null,
+    roundId: null,
+    refreshed_at: null,
+  };
+  let counter = 0;
+  let disposed = false;
+
+  const disabled = modules?.context === false;
+
+  function recordInjections(roundId, manifest) {
+    const ids = manifest?.eligible_ids ?? [];
+    if (!ids.length) return;
+    const at = clock.at().at;
+    withImmediate(stores.main, () => {
+      for (const memoryId of ids) {
+        stores.main
+          .prepare('INSERT OR IGNORE INTO injections (round_id, memory_id, slots, topic_hits, manifest_hash, receipt_id, at) VALUES (?, ?, ?, 0, ?, NULL, ?)')
+          .run(roundId, memoryId, JSON.stringify(['context']), manifest?.manifest_hash ?? null, at);
+      }
+    });
+  }
+
+  function refresh(turn = {}) {
+    if (disposed) return state;
+    if (disabled) {
+      state = { text: '', delivery: 'unknown', delivery_level: 'disabled', manifest: null, sessionId: sessionIdOf(turn), roundId: null, refreshed_at: clock.at().at };
+      return state;
+    }
+    const sessionId = sessionIdOf(turn) ?? state.sessionId;
+    counter += 1;
+    const roundId = turn?.id ?? turn?.roundId ?? `turn-${counter}`;
+    let result;
+    try {
+      result = compileRound({
+        main: stores.main,
+        control: stores.control,
+        clock,
+        sessionId: sessionId ?? 'unknown-session',
+        roundId,
+        mode,
+        tokenizer,
+        H,
+        modules,
+      });
+    } catch (err) {
+      logger?.warn?.('[dsh-memsys] compile failed: ' + err.message);
+      result = null;
+    }
+    if (!result || result.delivery_level === 'unavailable') {
+      state = {
+        text: TOOLS_ONLY_TEXT,
+        delivery: 'unknown',
+        delivery_level: 'unavailable',
+        manifest: result?.manifest ?? null,
+        sessionId,
+        roundId,
+        refreshed_at: clock.at().at,
+      };
+      return state;
+    }
+    const text = result.section?.text ?? result.sectionText ?? '';
+    state = {
+      text,
+      delivery: 'unknown',
+      delivery_level: result.delivery_level,
+      manifest: result.manifest ?? null,
+      sessionId,
+      roundId,
+      refreshed_at: clock.at().at,
+    };
+    recordInjections(roundId, state.manifest);
+    return state;
+  }
+
+  function onSessionEvent(payload) {
+    const event = payload?.event ?? payload;
+    const type = event?.type ?? event?.name ?? event?.kind ?? null;
+    if (type !== 'turn/start') return;
+    refresh(payload?.turn ?? event?.turn ?? payload ?? {});
+  }
+
+  if (!disabled && typeof ctx?.on === 'function') {
+    ctx.on('session/event', onSessionEvent);
+    ctx.on('turn/start', (payload) => refresh(payload ?? {}));
+  }
+
+  return {
+    refresh,
+    current: () => state,
+    dispose() {
+      disposed = true;
+      try {
+        if (typeof ctx?.off === 'function') {
+          ctx.off('session/event', onSessionEvent);
+        }
+      } catch {
+        // disposal must not throw
+      }
+    },
+  };
+}

package/src/runtime/inject.mjs

@@ -7,8 +7,11 @@ export const SECTION_ORDER = 500;
  * The only verified injection call shape (probe-p0):
  *   ctx.inject(['systemPrompt'], c => c.systemPrompt.section({name, order, text}))
  * Static `export const inject` would leave the plugin pending forever.
+ *
+ * `dynamicText: true` registers the resolver itself so the host re-reads it per
+ * assembly; the default keeps the historical one-shot string.
  */
-export function registerSection(ctx, { getText, diagnosticMarker = null } = {}) {
+export function registerSection(ctx, { getText, diagnosticMarker = null, dynamicText = false } = {}) {
   if (!ctx || typeof ctx.inject !== 'function') {
     const err = new Error('invalid_ctx');
     err.code = 'invalid_ctx';
@@ -20,7 +23,12 @@ export function registerSection(ctx, { getText, diagnosticMarker = null } = {})
       err.code = 'system_prompt_unavailable';
       throw err;
     }
-    const text = typeof getText === 'function' ? getText() : String(getText ?? '');
+    const resolve = () => (typeof getText === 'function' ? getText() : String(getText ?? ''));
+    // Dynamic text stays a function: the host re-evaluates it on every
+    // `systemPrompt.assemble()`, i.e. once per model step (verified on a probe
+    // profile: two assemblies produced probe-1 then probe-2). A static string
+    // would freeze the first round forever.
+    const text = dynamicText ? resolve : resolve();
     c.systemPrompt.section({ name: SECTION_NAME, order: SECTION_ORDER, text });
     if (diagnosticMarker) {
       fs.writeFileSync(
@@ -29,7 +37,8 @@ export function registerSection(ctx, { getText, diagnosticMarker = null } = {})
           {
             name: SECTION_NAME,
             order: SECTION_ORDER,
-            text_length: String(text).length,
+            text_length: String(resolve()).length,
+            dynamic: dynamicText === true,
             registered_at: new Date().toISOString(),
           },
           null,

package/src/runtime/modules.mjs

@@ -0,0 +1,20 @@
+/**
+ * Core gate facade. The single merge/persistence source is ui-config.mjs;
+ * this file must never re-implement it.
+ */
+export {
+  DEFAULT_MODULES,
+  MODULE_KEYS,
+  moduleEnabled,
+  readUiConfig,
+  resolveModules,
+  resolveModulesDetail,
+  writeUiConfig,
+} from './ui-config.mjs';
+
+import { resolveModulesDetail } from './ui-config.mjs';
+
+/** Resolve the effective gate set for one plugin instance. */
+export function modulesFor({ dataDir = null, config = null, logger = console } = {}) {
+  return resolveModulesDetail({ dataDir, profileConfig: config, logger }).modules;
+}