@try-works/dsh-memory 0.1.28 → 0.1.29

package/STATUS.md

@@ -3,8 +3,9 @@
 A tracker and planner: what exists, what is verified working, what is written but not
 loaded, and what is left. Kept as a record of MEASURED state, not intention.
 
-**Last measured: 2026-10-17** (408 tests passing; plugin at 0.1.27, published and installed
-byte-identical and confirmed LOADED by the running host; queue terminal-clean).
+**Last measured: 2026-10-17** (408 tests passing; plugin at 0.1.28, published and installed
+byte-identical and confirmed LOADED by the running harness at 0.2.1-rc.2; queue terminal-clean;
+the Memory tab reads the published map under the new event name).
 
 ## How to read this
 
@@ -67,6 +68,7 @@ Observed in the running host. Each row names the effect that was seen, not a cla
 | Boot tasks backup + restore ran live | at boot (2026-10-10T22:03:14Z) the log records `tasks-backup ok:true written:0 refreshed:5` and `tasks-restore ok:true owner:session-6e8d9a10 present:5 added:0 paused:0` — the restore reached the schedule service, found everything present, and duplicated nothing |
 | Git sync works live | after the 0.1.22+ boot the log shows real `sync` events, `state/sync.json` records `ok:true remote:https://github.com/try-works/dsh-memory-store` (2026-10-11T10:34:54Z), and `git log` in the store holds `memory(store): update [dsh-memory]` commits — the first syncs this plugin has ever performed |
 | History ingest works live | `history-check ok=true` entries after the boot, including `count=1` at 09:37Z — a commit was actually ingested; the hourly `null.run` error era is over |
+| Map publishing works on harness 0.2.1 | after the 0.1.28 boot the log shows `map-publish ok:true` on every cadence, the live session log carries `plugin:memory/map` rows with `ignorable:true`, the harness's own `validateStoredEvents` accepts the log, and the Memory tab renders (confirmed in the UI). The 0.2.1 contract is different from what 0.1.27 assumed: `Session.append` takes options only for surface event types, so an out-of-repo record is written with `appendPluginRecord` under the `plugin:` namespace |
 
 ## Shipped and LOADED
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@try-works/dsh-memory",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Git-backed, workspace-scoped memory for the DeepSeek Harness (global layer + per-workspace layers)",
   "type": "module",
   "main": "src/index.js",

package/src/fts.js

@@ -54,11 +54,43 @@ export function buildTrigramQuery(input) {
 /**
  * Create both indexes when missing. The word table serves normal queries; the trigram table
  * serves substring queries (no-space scripts), which the word tokenizer cannot express.
+ *
+ * MANDATORY, both tables. The trigram table is the ONLY route for a no-space script such as
+ * Chinese or Japanese, and the fallback for a partial-word query that the word table missed, so
+ * failing to create it must not be swallowed: a store without it silently makes a whole class of
+ * queries unanswerable, and the caller sees "no results" rather than an error. Throw here, where
+ * the cause is still visible, instead of degrading search quietly.
  */
 function ensureTables(db) {
   db.exec('CREATE VIRTUAL TABLE IF NOT EXISTS mem_fts USING fts5(file, line, section, content)')
-  try { db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS " + SUBSTRING_TABLE + " USING fts5(file, line, section, content, tokenize='trigram')") }
-  catch { /* a build without trigram still works, just without substring search */ }
+  try {
+    db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS " + SUBSTRING_TABLE + " USING fts5(file, line, section, content, tokenize='trigram')")
+  } catch (error) {
+    throw new Error('the substring (trigram) index is required and could not be created: ' + String((error && error.message) || error))
+  }
+}
+
+/**
+ * Run a block of writes inside ONE transaction.
+ *
+ * Without this, every INSERT is its own implicit transaction, so a row costs a commit and an
+ * fsync. A full rebuild of this store writes ~292,000 rows (word table + trigram table), and a
+ * measured rebuild did not finish in ten minutes. Batched, the same work is seconds - which is
+ * what makes "the index is derived, delete it and rebuild" a safe recovery step instead of an
+ * outage for every query.
+ * @param run - the work to perform inside the transaction.
+ * @returns whatever `run` returned, after the transaction commits.
+ */
+function inTransaction(db, run) {
+  db.exec('BEGIN')
+  try {
+    const result = run()
+    db.exec('COMMIT')
+    return result
+  } catch (error) {
+    try { db.exec('ROLLBACK') } catch { /* a failed rollback must not mask the real error */ }
+    throw error
+  }
 }
 
 /**
@@ -122,11 +154,13 @@ export function updateIndex(root, files) {
   let dropTri
   try { dropTri = db.prepare('DELETE FROM ' + SUBSTRING_TABLE + ' WHERE file = ?') } catch { dropTri = undefined }
   let rows = 0
-  for (const file of list) {
-    drop.run(relOf(root, file))
-    if (dropTri) try { dropTri.run(relOf(root, file)) } catch {}
-    try { rows += indexFile(db, root, file) } catch {}
-  }
+  inTransaction(db, () => {
+    for (const file of list) {
+      drop.run(relOf(root, file))
+      if (dropTri) try { dropTri.run(relOf(root, file)) } catch {}
+      try { rows += indexFile(db, root, file) } catch {}
+    }
+  })
   db.close()
   return { rows, files: list.length }
 }
@@ -159,8 +193,11 @@ export function buildIndex(root) {
   db.exec('DROP TABLE IF EXISTS mem_fts')
   db.exec('DROP TABLE IF EXISTS ' + SUBSTRING_TABLE)
   ensureTables(db)
-  let rows = 0
-  for (const file of indexedFiles(root)) rows += indexFile(db, root, file)
+  const rows = inTransaction(db, () => {
+    let total = 0
+    for (const file of indexedFiles(root)) total += indexFile(db, root, file)
+    return total
+  })
   db.close()
   return { dbPath, rows }
 }

package/scripts/probe-open.ts

@@ -1,13 +0,0 @@
-import { Context } from "@deepseek-ai/cordis"
-import { SessionStore } from "@deepseek-ai/dsh-session"
-import JsonlSessionPersistence from "@deepseek-ai/dsh-session-persistence-jsonl"
-const ctx = new Context()
-await ctx.plugin(SessionStore)
-await ctx.plugin(JsonlSessionPersistence, { root: "C:/Users/erikb/.dsh/sessions", compression: "zstd" })
-const p = ctx.get("sessionPersistence")
-const id = "session-b21ecc7e-7743-4b06-b07f-453541dbcde5"
-try {
-  const h = await p.open(id, "read")
-  const snap = await h.read()
-  console.log("REAL OPEN OK — events:", snap?.events?.length ?? snap?.log?.length ?? "(shape)")
-} catch (e) { console.log("REAL OPEN FAILED:", String(e.message).slice(0, 300)) }

package/scripts/probe-rows.ts

@@ -1,16 +0,0 @@
-import { readFileSync } from "node:fs"
-import { scanZstdFrames, decompressZstdFrame, decompressZstdPrefix } from "file:///D:/deepseek-harness/packages/session/session-persistence-jsonl/src/zstd.ts"
-import { validateStoredEvents } from "file:///D:/deepseek-harness/packages/session/session-persistence/src/storage-contract.ts"
-const buf = readFileSync(process.argv[2])
-const scan = scanZstdFrames(buf)
-let text = ""
-for (const f of scan.frames) text += (await decompressZstdFrame(buf.subarray(f.start, f.end))).toString("utf8")
-if (scan.tornStart !== undefined) text += (await decompressZstdPrefix(buf.subarray(scan.tornStart))).toString("utf8")
-const rows = text.split("\n").filter(Boolean).map(l => JSON.parse(l))
-const meta = rows[0]; const events = rows.slice(1)
-const dups = new Map(); for (const e of events) dups.set(e.seq, (dups.get(e.seq) ?? 0) + 1)
-console.log("events:", events.length, "| duplicate seqs:", [...dups].filter(([,n]) => n > 1).slice(0, 5))
-const bad = events.filter(e => e.type === "memory/map" && e.ignorable !== true)
-console.log("memory/map without marker:", bad.length)
-try { validateStoredEvents(meta, events, { kind: "jsonl", path: process.argv[2] }); console.log("VALIDATOR: OK") }
-catch (e) { console.log("VALIDATOR THREW:", String(e.message).slice(0, 300)) }