dsh-memsys 0.1.0 → 0.2.0

package/README.md

@@ -10,9 +10,18 @@ node scripts/live-check.mjs --case tools        # 真机：插件能否装进宿
 
 已实测（隔离 profile，带 key）：插件加载 → 10 个 `memsys_*` 工具注册进宿主 → 模型调用 `memsys_search` 返回真实命中 → 模型调用 `memsys_record` 写入候选与记忆，`origin.author_kind=model`、会话与调用 ID 与宿主记录一致。
 
-## 从 GitHub 安装
+## 安装
 
-**尚未发布到 npm**，所以 `npm install dsh-memsys` 装不到。现在的装法是先克隆再让 DSH 从本地路径安装：
+**已发布到 npm**：`dsh-memsys@0.1.0`（https://www.npmjs.com/package/dsh-memsys）。
+
+装进一个**独立 profile**（不要直接装进你日常用的那个）：
+
+```bash
+dsh --profile memsys headless --from-default-profile --dump-config   # 初始化隔离 profile
+dsh plugin --profile memsys add dsh-memsys                            # 从 npm 装
+```
+
+或者不依赖 npm，从源码装：
 
 ```bash
 git clone https://github.com/tok-ryan/dsh-memsys.git dsh-memsys
@@ -20,10 +29,7 @@ cd dsh-memsys
 npm test                    # 先跑一遍，确认本地环境能过（Node >= 22.13）
 ```
 
-然后用一个**独立 profile** 装进去（不要直接装进你日常用的那个）：
-
 ```bash
-dsh --profile memsys headless --from-default-profile --dump-config   # 初始化一个隔离 profile
 dsh plugin --profile memsys add "file:///全/路径/dsh-memsys"          # 按实际路径改
 ```
 
@@ -57,9 +63,24 @@ node scripts/live-check.mjs --case tools --profile memsys      # 真机：插件
 
 **设计原则**：事实只追加；当前状态是可重建投影；模型只能提交候选，不能直接落事实；一切写后读回按固化预期比对，不是"行还在就算成功"。
 
+## 界面（0.2.0 起）
+
+装上之后 Web GUI 里会多三样东西，都来自同一个浏览器半 `client.js`：
+
+- **左侧栏「🐳 记忆」**：点开是一块面板——记忆条数 / 候选条数 / 待确认惦记数，加最近 5 条记忆正文（超长截断）
+- **设置 →「记忆系统」**：`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`）。
+
+**headless 不受影响**：没有 `webServer` 时那段注册不激活，浏览器半也不加载。
+
 ## 状态
 
-已实现并在真机验证**读**与**写**；仍有 6 条设计条款未达标（合并时 due 语义、回退证明深度、门牌与骨架核验、混版分页测试等）。逐条列在本文件末尾"已知边界"一节，不粉饰。
+已实现并在真机验证**读**与**写**（`dispatch=ok` 返回真实命中、`record=ok` 写入候选与记忆）；**界面**已落地并有 7 条测试，但"真机 GUI 里三个 slot 真的画出来"要装进 profile 目测才算完。
+
+仍有 4 条设计条款未达标：**混版分页测试**（C3，代码已接 `stale_cursor`）、**空分组回执边界**（C1）、**证据原文分片续页**（C4）、以及 `L6` 的"逐项重放 relations 内容"（现在只核到内容 hash + 关联）。逐条见文末"已知边界"，不粉饰。
 
 MIT License。
 

package/client.js

@@ -0,0 +1,110 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-memsys',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+    const NS = 'dsh-memsys';
+    const API = '/dsh-memsys/api/summary';
+    const CONFIG = '/dsh-memsys/api/config';
+
+    function useSummary() {
+      const [state, setState] = React.useState(null);
+      React.useEffect(() => {
+        let alive = true;
+        const load = () => {
+          fetch(API)
+            .then((response) => (response.ok ? response.json() : Promise.reject(new Error(String(response.status)))))
+            .then((data) => alive && setState(data))
+            .catch(() => alive && setState({ error: true }));
+        };
+        load();
+        const timer = setInterval(load, 15000);
+        return () => {
+          alive = false;
+          clearInterval(timer);
+        };
+      }, []);
+      return [state, setState];
+    }
+
+    function MemoryPanel() {
+      const [state] = useSummary();
+      if (!state) return h('p', { style: { padding: 16 } }, '读取记忆…');
+      if (state.error) return h('p', { style: { padding: 16 } }, '暂时读不到记忆数据。');
+      return h(
+        'div',
+        { style: { padding: 16, lineHeight: 1.7 } },
+        h('h2', { style: { margin: '0 0 8px' } }, '记忆'),
+        h('p', null, `记忆 ${state.memories} 条 · 候选 ${state.candidates} 条 · 待确认惦记 ${state.pending_due} 条`),
+        h('h3', { style: { margin: '16px 0 6px' } }, '最近 5 条'),
+        state.recent.length === 0
+          ? h('p', null, '还没有记忆。')
+          : h('ul', null, state.recent.map((memory) => h('li', { key: memory.id }, memory.text))),
+      );
+    }
+
+    function MemoryIcon() {
+      return h('span', { 'aria-hidden': true, role: 'img', title: '记忆' }, '🐳');
+    }
+
+    const SOURCE_LABEL = { 'ui-config': '设置文件', profile: 'profile 配置', default: '默认值' };
+
+    function MemorySettings() {
+      const [state, setState] = React.useState(null);
+      const [note, setNote] = React.useState('');
+      React.useEffect(() => {
+        fetch(API)
+          .then((response) => (response.ok ? response.json() : Promise.reject(new Error(String(response.status)))))
+          .then(setState)
+          .catch(() => setState({ error: true }));
+      }, []);
+      const save = (value) => {
+        const previous = state?.auto_inject === true;
+        setState((current) => ({ ...(current ?? {}), auto_inject: value }));
+        setNote('保存中…');
+        fetch(CONFIG, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ auto_inject: value }),
+        })
+          .then((response) => (response.ok ? setNote('已保存') : Promise.reject(new Error(String(response.status)))))
+          .catch(() => {
+            setState((current) => ({ ...(current ?? {}), auto_inject: previous }));
+            setNote('保存失败');
+          });
+      };
+      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: { opacity: 0.75, margin: '6px 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 ?? '未知'}`),
+        note ? h('p', { style: { opacity: 0.75, margin: '4px 0 0' } }, note) : null,
+      );
+    }
+
+    return {
+      inject: ['slots'],
+      apply(ctx) {
+        ctx.slots.inject('main', () =>
+          ctx.slots.register({ name: 'main', key: NS }, MemoryPanel),
+        );
+        ctx.slots.inject('sidebar.panellist', () =>
+          ctx.slots.register({ name: 'sidebar.panellist', id: NS, order: 30, label: () => '记忆' }, MemoryIcon),
+        );
+        ctx.slots.inject('settings.section', () =>
+          ctx.slots.register({ name: 'settings.section', id: NS, order: 40, label: () => '记忆系统' }, MemorySettings),
+        );
+      },
+    };
+  },
+});

package/index.mjs

@@ -12,13 +12,64 @@ 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';
 
 export const name = 'dsh-memsys';
 /** tools is a real host service; static inject is the verified registration path. */
 export const inject = ['tools'];
 
-function createHostHandlers(config = {}, ctx = null) {
+/**
+ * `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`.
+ * The file wins so a toggle survives a restart without rewriting the profile,
+ * and the in-memory value 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 });
+  return {
+    dataDir,
+    get autoInject() {
+      return state.value;
+    },
+    get source() {
+      return state.source;
+    },
+    set autoInject(value) {
+      state = { value: value === true, source: 'ui-config' };
+    },
+    sync: () => {},
+  };
+}
+
+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 source() {
+      return typeof config.auto_inject === 'boolean' ? 'profile' : 'default';
+    },
+    set autoInject(_value) {},
+    sync: () => {},
+  };
+  const uiSummary = createSummaryHandler({
+    main: () => db().main,
+    dataDir,
+    getAutoInject: () => ({ value: uiState.autoInject, source: uiState.source }),
+    onAutoInject: (next) => {
+      if (!writeUiConfig(dataDir, next)) {
+        const err = new Error('data_dir_missing');
+        err.code = 'data_dir_missing';
+        throw err;
+      }
+      uiState.autoInject = next;
+      uiState.sync();
+    },
+  });
   let handles = null;
   const db = () => {
     if (!dataDir) {
@@ -67,6 +118,7 @@ function createHostHandlers(config = {}, ctx = null) {
     memsys_project_get: (args) => createProjectHandler({ main: db().main, clock: systemClock }).get(args),
     memsys_self_get: (args) => createSelfHandler({ main: db().main, clock: systemClock }).get(args),
     memsys_feed: (args) => createFeedHandler({ clock: systemClock }).feed(args),
+    memsys_ui_summary: (req, res) => uiSummary(req, res),
     memsys_record: (args, exec) => {
       const identity = runtimeFromExec({ exec, ctx, tool: 'record', args });
       if (!identity.ok) return { status: 'error', code: identity.code, ...identity };
@@ -94,7 +146,8 @@ function createHostHandlers(config = {}, ctx = null) {
  * section exists only for the isolated probe profile.
  */
 export async function apply(ctx, config = {}) {
-  const handlers = createHostHandlers(config, ctx);
+  const ui = createUiState(config);
+  const handlers = createHostHandlers(config, ctx, ui);
   const registration = await registerHostTools({ ctx, handlers });
   const toolProbe = process.env.MEMSYS_TOOL_PROBE ?? null;
   const writeToolProbe = (deferred) => {
@@ -235,19 +288,55 @@ export async function apply(ctx, config = {}) {
     write();
   }
 
-  const autoInject = config.auto_inject === true;
+  if (typeof ctx?.inject === 'function') {
+    try {
+      ctx.inject(['webServer'], (web) => {
+        web.effect(
+          () =>
+            web.webServer.register({
+              kind: 'exact',
+              path: '/dsh-memsys/api/summary',
+              handler: (req, res) => handlers.memsys_ui_summary(req, res),
+            }),
+          'memsys: ui summary route',
+        );
+        web.effect(
+          () =>
+            web.webServer.register({
+              kind: 'exact',
+              path: '/dsh-memsys/api/config',
+              handler: (req, res) => handlers.memsys_ui_summary(req, res),
+            }),
+          'memsys: ui config route',
+        );
+      });
+    } catch {
+      // profiles without webServer stay headless
+    }
+  }
   const diagnostic = config.diagnostic_section === true;
   let disposeSection = () => {};
-  if (autoInject || diagnostic) {
-    const getText = () =>
-      autoInject
-        ? '[memsys] 注入：tools-only（本批未取得宿主预算与回执，不作逐轮交付承诺）'
-        : '[memsys] diagnostic section（auto_inject=false）';
+  const syncSection = () => {
+    disposeSection();
+    disposeSection = () => {};
+    if (!ui.autoInject && !diagnostic) return;
     disposeSection = registerSection(ctx, {
-      getText,
+      getText: () =>
+        ui.autoInject
+          ? '[memsys] 注入：tools-only（本批未取得宿主预算与回执，不作逐轮交付承诺）'
+          : '[memsys] diagnostic section（auto_inject=false）',
       diagnosticMarker: process.env.MEMSYS_SECTION_PROBE ?? null,
     });
-  }
+  };
+  // A profile without systemPrompt (headless/embedded) must still boot the tools.
+  ui.sync = () => {
+    try {
+      syncSection();
+    } catch {
+      // keep the host half alive; the section is optional
+    }
+  };
+  ui.sync();
   return () => {
     disposeSection();
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-memsys",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A memory system plugin for DeepSeek Harness: append-only facts, candidates and adjudication, dreams, and budget-aware context injection.",
   "license": "MIT",
   "repository": {
@@ -28,15 +28,22 @@
     "node": ">=22.13"
   },
   "exports": {
-    ".": "./index.mjs"
+    ".": "./index.mjs",
+    "./client": "./client.js"
   },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": []
     }
   },
   "files": [
     "index.mjs",
+    "client.js",
     "cordis.patch.yml",
     "src",
     "scripts",

package/scripts/build.mjs

@@ -12,7 +12,8 @@ function walk(dir, out = []) {
     if (SKIP_DIRS.has(entry.name)) continue;
     const full = path.join(dir, entry.name);
     if (entry.isDirectory()) walk(full, out);
-    else if (entry.name.endsWith('.mjs')) out.push(full);
+    else if (entry.name.endsWith('.mjs') || (entry.name.endsWith('.js') && entry.name !== 'client.js')) out.push(full);
+    else if (entry.name === 'client.js') out.push(full);
   }
   return out;
 }

package/scripts/import-legacy.mjs

@@ -178,8 +178,10 @@ async function main() {
     required(deploymentDir, 'USAGE: activate --plan <plan.json> --data-dir <dir> --restore-report <report.json> --deployment-dir <dir>');
     const activateTarget = openTarget(dataDir);
     let businessRows = null;
+    let databaseFreeze = null;
     try {
       businessRows = rollback.snapshotBusinessRows(activateTarget.handles.main);
+      databaseFreeze = rollback.snapshotDatabaseFreeze(activateTarget.handles);
     } finally {
       closeAll(activateTarget.handles);
     }
@@ -193,6 +195,7 @@ async function main() {
         restoreBatch: restore.selected_batch,
         business_counts: businessRows?.counts ?? null,
         business_rows: businessRows,
+        db_freeze: databaseFreeze,
         activatedAt: systemClock.at().at,
       }, null, 2)}\n`,
       'utf8',
@@ -225,6 +228,7 @@ async function main() {
     }
     const restored = openAll(resolveConfig({ dataDir: restoredDir }));
     let comparison;
+    let freezeComparison = { ok: true, missing: [] };
     try {
       comparison = config.business_rows
         ? rollback.compareBusinessRows({ db: restored.main, baseline: config.business_rows })
@@ -232,11 +236,17 @@ async function main() {
             db: restored.main,
             expected: config.business_counts ?? {},
           });
+      if (config.db_freeze) {
+        freezeComparison = rollback.compareDatabaseFreeze(
+          { main: restored.main, control: restored.control, dream: restored.dream },
+          config.db_freeze,
+        );
+      }
     } finally {
       closeAll(restored);
     }
-    if (!comparison.ok) {
-      console.log(`ROLLBACK_CHECK_FAILED business_missing=${comparison.missing.join(',')}`);
+    if (!comparison.ok || !freezeComparison.ok) {
+      console.log(`ROLLBACK_CHECK_FAILED business_missing=${comparison.missing.join(',')} freeze_missing=${freezeComparison.missing.join(',')}`);
       process.exitCode = 1;
       return;
     }

package/scripts/live-check.mjs

@@ -125,7 +125,7 @@ record('profile_prepared', dumpBefore.status === 0, {
 // 2. Stage an ASCII copy; the live source tree is never linked into a profile.
 fs.rmSync(STAGE, { recursive: true, force: true });
 fs.mkdirSync(STAGE, { recursive: true });
-for (const name of ['package.json', 'index.mjs', 'cordis.patch.yml']) {
+for (const name of ['package.json', 'index.mjs', 'client.js', 'cordis.patch.yml']) {
   fs.copyFileSync(path.join(ROOT, name), path.join(STAGE, name));
 }
 fs.cpSync(path.join(ROOT, 'src'), path.join(STAGE, 'src'), { recursive: true });

package/src/dream/organize.mjs

@@ -37,6 +37,19 @@ function dueDeadline(main, memoryId) {
   return queue?.deadline_at ?? null;
 }
 
+/** Merge may not silently erase due semantics; anything due-bearing is refused. */
+function assertMergeAdmissible(main, memory) {
+  if (['open', 'pending-due', 'pending-done', 'cooled-due', 'shelved-due', 'done', 'dropped'].includes(memory.due_state)) {
+    throw new WriteError('blocked_by_due_state', { memoryId: memory.id, dueState: memory.due_state });
+  }
+  if (memory.type === 'promise') {
+    throw new WriteError('blocked_by_due_state', { memoryId: memory.id, reason: 'promise' });
+  }
+  if (memory.due_at || dueDeadline(main, memory.id)) {
+    throw new WriteError('blocked_by_due_state', { memoryId: memory.id, reason: 'deadline' });
+  }
+}
+
 /**
  * Mechanical exact merge only: no similarity, no NFKC, no negation stripping.
  * Endpoints must be active, resolved and accepted; dream-linked rows only yield a
@@ -58,9 +71,7 @@ export function mergeExact(deps, { runtime, ids }) {
     }
   }
   for (const memory of memories) {
-    if (['open', 'pending-due', 'pending-done', 'cooled-due', 'shelved-due'].includes(memory.due_state)) {
-      throw new WriteError('blocked_by_due_state', { memoryId: memory.id, dueState: memory.due_state });
-    }
+    assertMergeAdmissible(main, memory);
     if (memory.key_status !== 'resolved') throw new WriteError('unresolved_forbidden', { memoryId: memory.id });
     if (memory.binding_status !== 'accepted') throw new WriteError('binding_not_accepted', { memoryId: memory.id });
   }
@@ -163,6 +174,10 @@ export function mergeExact(deps, { runtime, ids }) {
   };
   let returnStorage = null;
   withImmediate(main, () => {
+    for (const id of unique) {
+      const fresh = getMemory(main, id);
+      assertMergeAdmissible(main, fresh);
+    }
     insertObservation(main, {
       id: observationId,
       idempotency_key: `obs:merge:${mergeKey}`,

package/src/import/legacy.mjs

@@ -481,8 +481,27 @@ export function verifyPlan(deps, plan) {
       continue;
     }
     report.items += 1;
-    if (item.itemKind === 'graph_node') report.graph_nodes += 1;
-    if (item.itemKind === 'graph_edge') report.graph_edges += 1;
+    if (item.itemKind === 'graph_node') {
+      report.graph_nodes += 1;
+      const node = main.prepare('SELECT * FROM graph_nodes WHERE id = ?').get(item.payload.id);
+      if (!node) report.missing.push(`${item.itemId}:graph_node`);
+      else if (node.label !== item.payload.label || node.kind !== item.payload.kind || node.source_ref !== `node:${item.payload.id}`) {
+        report.missing.push(`${item.itemId}:graph_node_content`);
+      }
+    }
+    if (item.itemKind === 'graph_edge') {
+      report.graph_edges += 1;
+      const edge = main.prepare('SELECT * FROM graph_edges WHERE id = ?').get(item.payload.id);
+      if (!edge) report.missing.push(`${item.itemId}:graph_edge`);
+      else if (
+        edge.from_id !== item.payload.from ||
+        edge.to_id !== item.payload.to ||
+        edge.kind !== item.payload.kind ||
+        edge.source_ref !== `edge:${item.payload.id}`
+      ) {
+        report.missing.push(`${item.itemId}:graph_edge_content`);
+      }
+    }
     if (item.itemKind === 'memory') {
       const targets = JSON.parse(row.target_ids);
       const observation = targets[0] ? getObservation(main, targets[0]) : null;

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'",