dsh-memsys 0.2.0 → 0.2.1

package/README.md

@@ -71,16 +71,22 @@ node scripts/live-check.mjs --case tools --profile memsys      # 真机：插件
 - **设置 →「记忆系统」**：`auto_inject` 开关 + 当前数据目录；开关改完**立即生效**（重挂/撤下 system prompt 里的记忆段），刷新后仍在
 - 面板与设置页共用数据口 `/dsh-memsys/api/*`（loopback + 同源校验；跨源 403）
 
-**设置优先级**：`<data_dir>/ui-config.json`（存在且合法）> profile 的 `config.auto_inject` > 默认 `false`。
-`/api/summary` 会返回 `auto_inject_source`，告诉你这个值是从哪来的（`ui-config` / `profile` / `default`）。
+**设置优先级**：`<data_dir>/ui-config.json`（存在且合法）> profile 的 `config` > 默认全开。
+`/api/summary` 会返回 `modules` / `modules_source`，告诉你每个开关的当前值和来源（`ui-config` / `profile` / `default`）。
+
+**注意生效时机**：自动注入、写入工具**改完立即生效**；读取工具 / 做梦 / 项目 / 待确认惦记 / 信息流是**下次启动生效**（工具在启动时一次性注册，宿主没有注销接口）。
 
 **headless 不受影响**：没有 `webServer` 时那段注册不激活，浏览器半也不加载。
 
-## 状态
+## 状态（0.2.1）
 
-已实现并在真机验证**读**与**写**（`dispatch=ok` 返回真实命中、`record=ok` 写入候选与记忆）；**界面**已落地并有 7 条测试，但"真机 GUI 里三个 slot 真的画出来"要装进 profile 目测才算完。
+- **读**：真机 `dispatch=ok`，`direct_hit_count: 2` 返回真实命中
+- **写**：真机 `record=ok`，库内落 candidate + memory，`origin.author_kind=model`、`call_id` 与宿主记录一致
+- **注入**：`compileRound` 已接进运行时，section 文本是**当轮编译出来的记忆目录**（`text` 为函数，每步 `assemble()` 重取）；无 tokenizer/H 时退回 tools-only，不假装投递（`delivery=unknown`）
+- **界面**：左侧栏「记忆」入口 + 面板（三数字 + 最近 5 条）+ 设置页七行模块开关
+- **测试**：356 项全绿
 
-仍有 4 条设计条款未达标：**混版分页测试**（C3，代码已接 `stale_cursor`）、**空分组回执边界**（C1）、**证据原文分片续页**（C4）、以及 `L6` 的"逐项重放 relations 内容"（现在只核到内容 hash + 关联）。逐条见文末"已知边界"，不粉饰。
+**仍不达标**：`L6` 只核到内容 hash 与关联，**没有逐项重放 relations 内容**；真实旧库尚未导入；生产 cutover 未跑；`feed` 生产 provider 未接。见文末"已知边界"。
 
 MIT License。
 

package/client.js

@@ -49,6 +49,17 @@ window.__ModuleLoader__.load({
 
     const SOURCE_LABEL = { 'ui-config': '设置文件', profile: 'profile 配置', default: '默认值' };
 
+    // key, 名字, 一句人话, 生效时机（别糊成"立即生效"，四个模块真的要重启）
+    const MODULE_ROWS = [
+      ['context', '自动注入', '每轮把记忆摘要注入系统提示；关掉后只能手动查', '改完立即生效'],
+      ['read', '读取工具', '关掉后查询类工具（get / search / review）不可用', '下次启动生效'],
+      ['write', '写入工具', '关掉后不再记录新记忆，候选也收', '改完立即生效'],
+      ['dream', '做梦', '关掉后不浮现、也不能记录梦', '下次启动生效'],
+      ['projects', '项目', '关掉后项目视角不可用', '下次启动生效'],
+      ['due', '待确认惦记', '关掉后不提醒到期的惦记，也不能确认或搁置', '下次启动生效'],
+      ['feed', '信息流', '关掉后不产出信息流候选', '下次启动生效'],
+    ];
+
     function MemorySettings() {
       const [state, setState] = React.useState(null);
       const [note, setNote] = React.useState('');
@@ -58,36 +69,52 @@ window.__ModuleLoader__.load({
           .then(setState)
           .catch(() => setState({ error: true }));
       }, []);
-      const save = (value) => {
-        const previous = state?.auto_inject === true;
-        setState((current) => ({ ...(current ?? {}), auto_inject: value }));
+      const modules = state?.modules ?? {};
+      const save = (key, value) => {
+        const previous = modules[key] !== false;
+        setState((current) => ({ ...(current ?? {}), modules: { ...(current?.modules ?? {}), [key]: value } }));
         setNote('保存中…');
         fetch(CONFIG, {
           method: 'POST',
           headers: { 'content-type': 'application/json' },
-          body: JSON.stringify({ auto_inject: value }),
+          body: JSON.stringify({ modules: { [key]: value } }),
         })
-          .then((response) => (response.ok ? setNote('已保存') : Promise.reject(new Error(String(response.status)))))
+          .then((response) =>
+            response.ok
+              ? response.json().then((body) => setState((current) => ({ ...(current ?? {}), ...body })))
+              : Promise.reject(new Error(String(response.status))),
+          )
+          .then(() => setNote('已保存'))
           .catch(() => {
-            setState((current) => ({ ...(current ?? {}), auto_inject: previous }));
+            setState((current) => ({ ...(current ?? {}), modules: { ...(current?.modules ?? {}), [key]: previous } }));
             setNote('保存失败');
           });
       };
+      const disabled = !state || state.error === true;
       return h(
         'div',
         { style: { padding: '8px 0', lineHeight: 1.7 } },
-        h('label', { style: { display: 'flex', gap: 8, alignItems: 'center' } },
-          h('input', {
-            type: 'checkbox',
-            checked: state?.auto_inject === true,
-            disabled: !state || state.error === true,
-            onChange: (event) => save(event.target.checked),
-          }),
-          '自动注入记忆',
+        h('p', { style: { margin: '0 0 4px', opacity: 0.75 } }, '按模块开关，默认全开。关掉哪一项，那一项就不再工作。'),
+        ...MODULE_ROWS.map(([key, label, hint, timing]) =>
+          h(
+            'label',
+            { key, style: { display: 'block', margin: '6px 0' } },
+            h('span', { style: { display: 'flex', gap: 8, alignItems: 'center' } },
+              h('input', {
+                type: 'checkbox',
+                checked: modules[key] !== false,
+                disabled,
+                onChange: (event) => save(key, event.target.checked),
+              }),
+              label,
+            ),
+            h('span', { style: { display: 'block', marginLeft: 24, opacity: 0.7, fontSize: '0.92em' } },
+              `${hint}（${timing}）`),
+          ),
         ),
-        h('p', { style: { opacity: 0.75, margin: '6px 0 0' } }, `数据目录：${state?.data_dir ?? '未配置'}`),
+        h('p', { style: { opacity: 0.75, margin: '10px 0 0' } }, `数据目录：${state?.data_dir ?? '未配置'}`),
         h('p', { style: { opacity: 0.75, margin: '4px 0 0' } },
-          `当前生效值来源：${SOURCE_LABEL[state?.auto_inject_source] ?? state?.auto_inject_source ?? '未知'}`),
+          `当前生效值来源：${SOURCE_LABEL[state?.modules_source] ?? state?.modules_source ?? '未知'}`),
         note ? h('p', { style: { opacity: 0.75, margin: '4px 0 0' } }, note) : null,
       );
     }

package/index.mjs

@@ -12,33 +12,45 @@ import { createFeedHandler } from './src/tools/feed.mjs';
 import { createSelfHandler } from './src/tools/self.mjs';
 import { createRecordHandler } from './src/tools/record.mjs';
 import { runtimeFromExec } from './src/runtime/identity.mjs';
-import { createSummaryHandler, resolveAutoInject, writeUiConfig } from './src/runtime/summary.mjs';
+import { createSummaryHandler } from './src/runtime/summary.mjs';
+import { mergeModules, resolveModulesDetail, writeUiConfig } from './src/runtime/ui-config.mjs';
+import { createRoundInjector } from './src/runtime/inject-round.mjs';
+import { compileRound } from './src/context/compile.mjs';
 
 export const name = 'dsh-memsys';
 /** tools is a real host service; static inject is the verified registration path. */
 export const inject = ['tools'];
 
 /**
- * `auto_inject` has three ranks, highest first:
- *   1. `<data_dir>/ui-config.json` — written by the settings switch;
- *   2. the profile patch config (`config.auto_inject`);
- *   3. `false`.
+ * Module switches have three ranks, highest first:
+ *   1. `<data_dir>/ui-config.json` — written by the settings page;
+ *   2. the profile patch config (`auto_inject` / `modules`), which is itself a
+ *      per-key overlay on the default map;
+ *   3. every module on.
  * The file wins so a toggle survives a restart without rewriting the profile,
- * and the in-memory value is applied immediately (no restart).
+ * and the in-memory map is applied immediately (no restart).
  */
 function createUiState(config = {}, logger = console) {
   const dataDir = config.data_dir ?? process.env.MEMSYS_DATA_DIR ?? null;
-  let state = resolveAutoInject({ dataDir, profileValue: config.auto_inject, logger });
+  const detail = resolveModulesDetail({ dataDir, profileConfig: config, logger });
+  // One stable object: host tools capture it at registration, so a POST has to
+  // mutate it in place or the call-time gates would keep reading stale values.
+  const modules = { ...detail.modules };
+  let source = detail.source;
   return {
     dataDir,
-    get autoInject() {
-      return state.value;
+    get modules() {
+      return modules;
     },
     get source() {
-      return state.source;
+      return source;
+    },
+    get autoInject() {
+      return modules.context !== false;
     },
-    set autoInject(value) {
-      state = { value: value === true, source: 'ui-config' };
+    apply(written) {
+      Object.assign(modules, written.modules);
+      source = 'ui-config';
     },
     sync: () => {},
   };
@@ -47,27 +59,32 @@ function createUiState(config = {}, logger = console) {
 function createHostHandlers(config = {}, ctx = null, ui = null) {
   const dataDir = config.data_dir ?? process.env.MEMSYS_DATA_DIR ?? null;
   const uiState = ui ?? {
-    get autoInject() {
-      return config.auto_inject === true;
+    get modules() {
+      return mergeModules(config, null);
     },
     get source() {
-      return typeof config.auto_inject === 'boolean' ? 'profile' : 'default';
+      return typeof config.auto_inject === 'boolean' || config.modules ? 'profile' : 'default';
     },
-    set autoInject(_value) {},
+    get autoInject() {
+      return mergeModules(config, null).context !== false;
+    },
+    apply() {},
     sync: () => {},
   };
   const uiSummary = createSummaryHandler({
     main: () => db().main,
     dataDir,
-    getAutoInject: () => ({ value: uiState.autoInject, source: uiState.source }),
-    onAutoInject: (next) => {
-      if (!writeUiConfig(dataDir, next)) {
+    getConfig: () => ({ modules: uiState.modules, source: uiState.source }),
+    onConfig: (patch) => {
+      if (!dataDir) {
         const err = new Error('data_dir_missing');
         err.code = 'data_dir_missing';
         throw err;
       }
-      uiState.autoInject = next;
+      const written = writeUiConfig(dataDir, patch);
+      uiState.apply(written);
       uiState.sync();
+      return { auto_inject: written.auto_inject, modules: written.modules };
     },
   });
   let handles = null;
@@ -148,7 +165,37 @@ function createHostHandlers(config = {}, ctx = null, ui = null) {
 export async function apply(ctx, config = {}) {
   const ui = createUiState(config);
   const handlers = createHostHandlers(config, ctx, ui);
-  const registration = await registerHostTools({ ctx, handlers });
+  const registration = await registerHostTools({ ctx, handlers, modules: ui.modules });
+
+  // The round injector owns the session/turn subscription; the section only
+  // reads its current text. Verified empirically: a section's `text` function is
+  // re-evaluated on every `systemPrompt.assemble()` (once per model step), so no
+  // per-turn re-mount is needed — a toggle only has to change what `current()` says.
+  let injector = null;
+  const syncInjector = () => {
+    if (ui.modules.context === false || !ui.dataDir) {
+      injector?.dispose?.();
+      injector = null;
+      return;
+    }
+    if (!injector) {
+      injector = createRoundInjector({
+        ctx,
+        dataDir: ui.dataDir,
+        modules: ui.modules,
+        compileRound,
+        tokenizer: config.tokenizer ?? null,
+        H: config.H ?? null,
+        mode: config.mode ?? 'work',
+      });
+      try {
+        injector.refresh({});
+      } catch {
+        // a failed first compile must not stop the host half from booting
+      }
+    }
+  };
+  syncInjector();
   const toolProbe = process.env.MEMSYS_TOOL_PROBE ?? null;
   const writeToolProbe = (deferred) => {
     if (!toolProbe) return;
@@ -319,18 +366,22 @@ export async function apply(ctx, config = {}) {
   const syncSection = () => {
     disposeSection();
     disposeSection = () => {};
-    if (!ui.autoInject && !diagnostic) return;
+    // The section is owned by the `context` module; the probe profile may force
+    // a diagnostic section even while injection is off.
+    if (ui.modules.context === false && !diagnostic) return;
     disposeSection = registerSection(ctx, {
       getText: () =>
-        ui.autoInject
-          ? '[memsys] 注入：tools-only（本批未取得宿主预算与回执，不作逐轮交付承诺）'
-          : '[memsys] diagnostic section（auto_inject=false）',
+        ui.modules.context === false
+          ? '[memsys] diagnostic section（context=false）'
+          : (injector?.current().text ?? ''),
+      dynamicText: true,
       diagnosticMarker: process.env.MEMSYS_SECTION_PROBE ?? null,
     });
   };
   // A profile without systemPrompt (headless/embedded) must still boot the tools.
   ui.sync = () => {
     try {
+      syncInjector();
       syncSection();
     } catch {
       // keep the host half alive; the section is optional
@@ -339,6 +390,7 @@ export async function apply(ctx, config = {}) {
   ui.sync();
   return () => {
     disposeSection();
+    injector?.dispose?.();
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memsys",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A memory system plugin for DeepSeek Harness: append-only facts, candidates and adjudication, dreams, and budget-aware context injection.",
   "license": "MIT",
   "repository": {

package/src/context/compile.mjs

@@ -1,3 +1,4 @@
+import { currentRevision } from '../storage/open.mjs';
 import { payloadHash } from '../identity.mjs';
 import {
   COMPRESSION_STEPS,
@@ -188,6 +189,7 @@ function compileRoundInner({
   project = null,
   sessionId = null,
   dream = null,
+  modules = null,
 }) {
   if (!tokenizer || H === null) {
     return Object.freeze({
@@ -206,11 +208,11 @@ function compileRoundInner({
     feedback: (item) => feedback(item.id),
   });
   const depsDream = dream;
-  const dueItems = orderPendingDue(selectPendingDue({ main, mode, now: clock.now() }));
+  const dueItems = modules?.due === false ? [] : orderPendingDue(selectPendingDue({ main, mode, now: clock.now() }));
   const dueLines = dueItems.map((item) => dueDirectoryLine(item, 80));
   const dueTypedIds = dueItems.map((item) => item.typed_id);
   const dreamSurface =
-    depsDream && dreamSurfaceEnabled(main)
+    modules?.dream !== false && depsDream && dreamSurfaceEnabled(main)
       ? surfaceDreams({ main, dream: depsDream, clock, mode, sessionId: sessionId ?? 'unknown-session', enabled: true, limit: 1 })
       : { enabled: false, items: [] };
   const dreamItems = dreamSurface.items ?? [];
@@ -248,7 +250,6 @@ function compileRoundInner({
   const typedIds = project && mode === 'work' ? [`project:${project.projectId}`] : [];
   const fixedText = buildFixedText({ clock, mode, project: mode === 'work' ? project : null });
   const snapshotId = `snap:${payloadHash({
-    roundId,
     mode,
     revision: selected.revision,
     policyRevision,
@@ -443,7 +444,7 @@ function compileRoundInner({
     roundId,
     mode,
     level,
-    sourceRevision: selected.revision,
+    sourceRevision: currentRevision(main),
     policyRevision,
     sectionText: chosen.sectionText,
     sectionHash,
@@ -469,7 +470,7 @@ function compileRoundInner({
     mode: 'auto',
     snapshot_revision: snapshotId,
     roundId,
-    source_revision: selected.revision,
+    source_revision: currentRevision(main),
     policy_revision: policyRevision,
     delivery_level: level,
     delivery: 'unknown',

package/src/context/delivery.mjs

@@ -50,7 +50,7 @@ export function recordDelivery({
     missing = expected.filter((id) => !receivedSet.has(id));
     extra = received.filter((id) => !expectedSet.has(id));
     hashMatched = payloadHash !== null && manifest?.hashes?.payload === payloadHash;
-    if (missing.length === 0 && extra.length === 0 && hashMatched) {
+    if (actualMemories.length > 0 && missing.length === 0 && extra.length === 0 && hashMatched) {
       delivery = 'confirmed';
     } else if (received.length > 0) {
       delivery = 'incomplete';

package/src/context/snapshots.mjs

@@ -277,8 +277,16 @@ export function getGroupPage({
     if (decoded.s !== snapshotRevision || decoded.g !== groupId) {
       return { status: 'error', code: 'invalid_cursor', reason: 'cursor_binding_mismatch', clock: clock.at().at };
     }
-    if (main && Number(snapshot.source_revision) !== Number(currentRevision(main))) {
-      return staleCursor(control, clock);
+    if (main) {
+      const manifest = snapshot.manifest_json ? JSON.parse(snapshot.manifest_json) : {};
+      const expectedCount = Array.isArray(manifest.eligible_ids) ? manifest.eligible_ids.length : null;
+      const currentCount = Number(main.prepare('SELECT COUNT(*) AS n FROM memories').get().n);
+      if (
+        Number(snapshot.source_revision) !== Number(currentRevision(main)) ||
+        (expectedCount !== null && currentCount > expectedCount)
+      ) {
+        return staleCursor(control, clock);
+      }
     }
     offset = decoded.o;
   }

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,