mixgram 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/.mixgram/index.db +0 -0
  2. package/.mixgram/test-esm.db +0 -0
  3. package/.mixgram/test-index.db +0 -0
  4. package/.mixgram/test-stage1.db +0 -0
  5. package/README.md +335 -0
  6. package/bin/mixgram.js +309 -0
  7. package/index.js +9 -0
  8. package/package.json +51 -0
  9. package/projects/castlebravo/memory/decisions/decision--architecture/sqlite-derived-index.md +17 -0
  10. package/projects/test/memory/decisions/decision--architecture/sqlite-derived-index.md +17 -0
  11. package/spec/fixtures/realistic-content.js +97 -0
  12. package/spec/reporter.js +127 -0
  13. package/spec/run-tests-runner.js +40 -0
  14. package/spec/run-tests.js +160 -0
  15. package/spec/scenarios/scenarios.js +520 -0
  16. package/spec/sdd.md +1002 -0
  17. package/spec/tdd.md +1237 -0
  18. package/src/config.js +56 -0
  19. package/src/core/documents/documents.js +207 -0
  20. package/src/core/embeddings/embedder.js +58 -0
  21. package/src/core/embeddings/queue.js +118 -0
  22. package/src/core/embeddings/vectorStore.js +127 -0
  23. package/src/core/embeddings/worker.js +27 -0
  24. package/src/core/indexing/indexer.js +131 -0
  25. package/src/core/indexing/parser.js +78 -0
  26. package/src/core/indexing/reindex.js +101 -0
  27. package/src/core/prompts/prompts.js +15 -0
  28. package/src/core/search/search.js +223 -0
  29. package/src/core/sessions/sessions.js +27 -0
  30. package/src/db/migrations/001_initial.sql +86 -0
  31. package/src/db/sqlite.js +39 -0
  32. package/src/fs/paths.js +79 -0
  33. package/src/fs/watcher.js +49 -0
  34. package/src/mcp/cli-adapter.js +118 -0
  35. package/src/mcp/server.js +47 -0
  36. package/src/mcp/tool-registry.js +138 -0
  37. package/src/mcp/tools.js +159 -0
  38. package/src/utils/hash.js +6 -0
  39. package/src/utils/ids.js +22 -0
  40. package/src/utils/markdown.js +49 -0
@@ -0,0 +1,520 @@
1
+ /**
2
+ * User-facing scenario definitions for Mixgram tests.
3
+ * Each scenario has name, goal, and run(ctx). run() returns { passed, failed }.
4
+ * ctx: { h, parse, config, fs, reporter, ok } where ok(cond, msg) counts and optionally prints check.
5
+ */
6
+
7
+ import {
8
+ decisionSqliteIndex,
9
+ decisionSqliteIndexRevision2,
10
+ patternIncrementalReindex,
11
+ patternIncrementalReindexProject,
12
+ sessionSummaryContent,
13
+ promptContent,
14
+ timelineFirst,
15
+ timelineSecond,
16
+ manualEditSnippet,
17
+ semanticPersistenceDoc,
18
+ semanticPersistenceQuery,
19
+ semanticFallbackDoc,
20
+ PROJECT_NAME
21
+ } from '../fixtures/realistic-content.js';
22
+
23
+ function parse(res) {
24
+ return JSON.parse(res.content[0].text);
25
+ }
26
+
27
+ export const scenarios = [
28
+ {
29
+ name: 'Save and find a project decision',
30
+ goal: 'Save a project-scoped decision, then find it via search and get_observation.',
31
+ run: async function (ctx) {
32
+ const { h, reporter, fs } = ctx;
33
+ const parseRes = ctx.parse || parse;
34
+ let p = 0, f = 0;
35
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
36
+
37
+ reporter.startScenario(this.name, this.goal);
38
+
39
+ const save1 = await h.mem_save(decisionSqliteIndex);
40
+ const s1 = parseRes(save1);
41
+ ctx.shared = ctx.shared || {};
42
+ ctx.shared.decisionDoc = s1;
43
+ reporter.step('mem_save', { title: decisionSqliteIndex.title, topic_key: decisionSqliteIndex.topic_key }, { id: s1.id, path: s1.path, created: s1.created });
44
+ ok(s1.success && s1.id && s1.created === true, 'save success');
45
+ ok(fs.existsSync(s1.path), 'file created');
46
+
47
+ const search1 = await h.mem_search({ query: 'derived SQLite index', project: PROJECT_NAME });
48
+ const search1Parsed = parseRes(search1);
49
+ reporter.step('mem_search', { query: 'derived SQLite index', project: PROJECT_NAME }, search1Parsed, { highlight: ['title', 'snippet', 'score'] });
50
+ ok(search1Parsed.results.length >= 1, 'searchable');
51
+
52
+ const obs1 = await h.mem_get_observation({ id: s1.id });
53
+ const obs1Parsed = parseRes(obs1);
54
+ reporter.step('mem_get_observation', { id: s1.id }, { title: obs1Parsed.title });
55
+ ok(obs1Parsed.title === decisionSqliteIndex.title, 'get_observation title');
56
+
57
+ reporter.endScenario(p, f);
58
+ return { passed: p, failed: f };
59
+ }
60
+ },
61
+ {
62
+ name: 'Home-scoped memory and merged search',
63
+ goal: 'Save a home-scoped pattern and find it in merged project search.',
64
+ run: async function (ctx) {
65
+ const { h, reporter } = ctx;
66
+ const parseRes = ctx.parse || parse;
67
+ let p = 0, f = 0;
68
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
69
+
70
+ reporter.startScenario(this.name, this.goal);
71
+
72
+ const save2 = await h.mem_save(patternIncrementalReindex);
73
+ const s2 = parseRes(save2);
74
+ reporter.step('mem_save (home)', { scope: 'home', topic_key: patternIncrementalReindex.topic_key }, { path: s2.path, created: s2.created });
75
+ ok(s2.success && s2.path && s2.path.includes('home'), 'home save');
76
+
77
+ const searchMerged = await h.mem_search({ query: 'reindex', scope_mode: 'merged', project: PROJECT_NAME });
78
+ const mergedParsed = parseRes(searchMerged);
79
+ reporter.step('mem_search (merged)', { query: 'reindex', scope_mode: 'merged' }, mergedParsed, { highlight: ['title', 'scope', 'snippet'] });
80
+ ok(mergedParsed.results.length >= 1, 'merged search');
81
+
82
+ reporter.endScenario(p, f);
83
+ return { passed: p, failed: f };
84
+ }
85
+ },
86
+ {
87
+ name: 'Update by topic_key (upsert)',
88
+ goal: 'Saving again with same topic_key updates the document instead of creating a duplicate.',
89
+ run: async function (ctx) {
90
+ const { h, reporter } = ctx;
91
+ const parseRes = ctx.parse || parse;
92
+ let p = 0, f = 0;
93
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
94
+ if (!ctx.shared?.decisionDoc) {
95
+ const save1 = await h.mem_save(decisionSqliteIndex);
96
+ ctx.shared = ctx.shared || {};
97
+ ctx.shared.decisionDoc = parseRes(save1);
98
+ }
99
+
100
+ reporter.startScenario(this.name, this.goal);
101
+
102
+ const save3 = await h.mem_save(decisionSqliteIndexRevision2);
103
+ const s3 = parseRes(save3);
104
+ reporter.step('mem_save (same topic_key)', { topic_key: decisionSqliteIndexRevision2.topic_key }, { id: s3.id, created: s3.created });
105
+ ok(s3.success && s3.created === false, 'update not create');
106
+
107
+ const obs3 = await h.mem_get_observation({ id: s3.id });
108
+ const obs3Parsed = parseRes(obs3);
109
+ reporter.step('mem_get_observation', {}, { contentPreview: (obs3Parsed.content || '').slice(0, 100) });
110
+ ok(obs3Parsed.content && obs3Parsed.content.includes('Revision two'), 'updated content');
111
+
112
+ reporter.endScenario(p, f);
113
+ return { passed: p, failed: f };
114
+ }
115
+ },
116
+ {
117
+ name: 'Update document by id',
118
+ goal: 'mem_update by id changes title and content.',
119
+ run: async function (ctx) {
120
+ const { h, reporter } = ctx;
121
+ const parseRes = ctx.parse || parse;
122
+ let p = 0, f = 0;
123
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
124
+ const s1 = ctx.shared?.decisionDoc || parseRes(await h.mem_save(decisionSqliteIndex));
125
+ if (!ctx.shared) ctx.shared = { decisionDoc: s1 }; else ctx.shared.decisionDoc = s1;
126
+
127
+ reporter.startScenario(this.name, this.goal);
128
+
129
+ const upd = await h.mem_update({ id: s1.id, title: 'Updated title', content: 'Updated body.' });
130
+ const updParsed = parseRes(upd);
131
+ reporter.step('mem_update', { id: s1.id, title: 'Updated title' }, updParsed);
132
+ ok(updParsed.success, 'update success');
133
+
134
+ const obs4 = await h.mem_get_observation({ id: s1.id });
135
+ const obs4Parsed = parseRes(obs4);
136
+ reporter.step('mem_get_observation', {}, { title: obs4Parsed.title, contentPreview: (obs4Parsed.content || '').slice(0, 50) });
137
+ ok(obs4Parsed.title === 'Updated title' && obs4Parsed.content && obs4Parsed.content.includes('Updated body'), 'content updated');
138
+
139
+ reporter.endScenario(p, f);
140
+ return { passed: p, failed: f };
141
+ }
142
+ },
143
+ {
144
+ name: 'Search returns results with snippets',
145
+ goal: 'mem_search returns an array of results with title, snippet, score.',
146
+ run: async function (ctx) {
147
+ const { h, reporter } = ctx;
148
+ const parseRes = ctx.parse || parse;
149
+ let p = 0, f = 0;
150
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
151
+
152
+ reporter.startScenario(this.name, this.goal);
153
+
154
+ const search2 = await h.mem_search({ query: 'derived index', project: PROJECT_NAME, limit: 5 });
155
+ const res = parseRes(search2).results;
156
+ reporter.step('mem_search', { query: 'derived index', limit: 5 }, { results: res }, { highlight: ['title', 'snippet', 'score'] });
157
+ ok(Array.isArray(res), 'results array');
158
+ ok(res.length >= 1 && res[0].snippet != null, 'snippets present');
159
+
160
+ reporter.endScenario(p, f);
161
+ return { passed: p, failed: f };
162
+ }
163
+ },
164
+ {
165
+ name: 'Context for project',
166
+ goal: 'mem_context returns usable context (recent or query-based).',
167
+ run: async function (ctx) {
168
+ const { h, reporter } = ctx;
169
+ let p = 0, f = 0;
170
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
171
+
172
+ reporter.startScenario(this.name, this.goal);
173
+
174
+ const ctxRes = await h.mem_context({ project: PROJECT_NAME, limit: 5 });
175
+ const text = ctxRes.content[0].text;
176
+ reporter.step('mem_context', { project: PROJECT_NAME, limit: 5 }, text?.slice(0, 300) || '(empty)');
177
+ ok(typeof text === 'string' && text.length >= 0, 'mem_context returns text');
178
+
179
+ reporter.endScenario(p, f);
180
+ return { passed: p, failed: f };
181
+ }
182
+ },
183
+ {
184
+ name: 'Stats',
185
+ goal: 'mem_stats returns document/session/prompt counts and embeddings_enabled.',
186
+ run: async function (ctx) {
187
+ const { h, reporter } = ctx;
188
+ const parseRes = ctx.parse || parse;
189
+ let p = 0, f = 0;
190
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
191
+
192
+ reporter.startScenario(this.name, this.goal);
193
+
194
+ const stats = await h.mem_stats();
195
+ const st = parseRes(stats);
196
+ reporter.step('mem_stats', {}, st);
197
+ ok(typeof st.documents === 'number' && st.embeddings_enabled === false, 'mem_stats shape');
198
+
199
+ reporter.endScenario(p, f);
200
+ return { passed: p, failed: f };
201
+ }
202
+ },
203
+ {
204
+ name: 'Session lifecycle',
205
+ goal: 'mem_session_start and mem_session_end create and close a session.',
206
+ run: async function (ctx) {
207
+ const { h, reporter } = ctx;
208
+ const parseRes = ctx.parse || parse;
209
+ let p = 0, f = 0;
210
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
211
+
212
+ reporter.startScenario(this.name, this.goal);
213
+
214
+ const sessStart = await h.mem_session_start({ project: PROJECT_NAME });
215
+ const sess = parseRes(sessStart);
216
+ reporter.step('mem_session_start', { project: PROJECT_NAME }, { session_id: sess.session_id });
217
+ ok(sess.success && sess.session_id, 'session_start');
218
+ const sessionId = sess.session_id;
219
+
220
+ const sessEnd = await h.mem_session_end({ session_id: sessionId });
221
+ const endParsed = parseRes(sessEnd);
222
+ reporter.step('mem_session_end', { session_id: sessionId }, endParsed);
223
+ ok(endParsed.success, 'session_end');
224
+
225
+ reporter.endScenario(p, f);
226
+ return { passed: p, failed: f };
227
+ }
228
+ },
229
+ {
230
+ name: 'Session summary becomes searchable',
231
+ goal: 'mem_session_summary stores a summary that appears in search.',
232
+ run: async function (ctx) {
233
+ const { h, reporter } = ctx;
234
+ const parseRes = ctx.parse || parse;
235
+ let p = 0, f = 0;
236
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
237
+
238
+ reporter.startScenario(this.name, this.goal);
239
+
240
+ const sessStart2 = await h.mem_session_start({ project: PROJECT_NAME });
241
+ const sessionId2 = parseRes(sessStart2).session_id;
242
+ const summaryRes = await h.mem_session_summary({ session_id: sessionId2, content: sessionSummaryContent });
243
+ reporter.step('mem_session_summary', { content: sessionSummaryContent.slice(0, 50) + '...' }, parseRes(summaryRes));
244
+ ok(parseRes(summaryRes).success, 'session_summary success');
245
+
246
+ const searchSummary = await h.mem_search({ query: 'decided SQLite', project: PROJECT_NAME });
247
+ const summarySearchParsed = parseRes(searchSummary);
248
+ reporter.step('mem_search (summary)', { query: 'decided SQLite' }, summarySearchParsed, { highlight: ['title', 'snippet'] });
249
+ ok(summarySearchParsed.results.length >= 1, 'summary searchable');
250
+
251
+ reporter.endScenario(p, f);
252
+ return { passed: p, failed: f };
253
+ }
254
+ },
255
+ {
256
+ name: 'Save prompt',
257
+ goal: 'mem_save_prompt stores a prompt and stats reflect it.',
258
+ run: async function (ctx) {
259
+ const { h, reporter } = ctx;
260
+ const parseRes = ctx.parse || parse;
261
+ let p = 0, f = 0;
262
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
263
+
264
+ reporter.startScenario(this.name, this.goal);
265
+ const sessStart = await h.mem_session_start({ project: PROJECT_NAME });
266
+ const sessionId2 = parseRes(sessStart).session_id;
267
+
268
+ const promptRes = await h.mem_save_prompt({ session_id: sessionId2, content: promptContent });
269
+ reporter.step('mem_save_prompt', { content: promptContent.slice(0, 40) + '...' }, parseRes(promptRes));
270
+ ok(parseRes(promptRes).success, 'mem_save_prompt success');
271
+
272
+ const stats2 = await h.mem_stats();
273
+ ok(parseRes(stats2).prompts >= 1, 'prompts count');
274
+
275
+ reporter.endScenario(p, f);
276
+ return { passed: p, failed: f };
277
+ }
278
+ },
279
+ {
280
+ name: 'Timeline around an observation',
281
+ goal: 'mem_timeline returns before/focus/after for an observation in a session.',
282
+ run: async function (ctx) {
283
+ const { h, reporter } = ctx;
284
+ const parseRes = ctx.parse || parse;
285
+ let p = 0, f = 0;
286
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
287
+
288
+ reporter.startScenario(this.name, this.goal);
289
+
290
+ const sessStart3 = await h.mem_session_start({ project: PROJECT_NAME });
291
+ const sessionId3 = parseRes(sessStart3).session_id;
292
+ const docA = parseRes(await h.mem_save({ ...timelineFirst, session_id: sessionId3 }));
293
+ const docB = parseRes(await h.mem_save({ ...timelineSecond, session_id: sessionId3 }));
294
+ reporter.step('mem_save x2 (same session)', { session_id: sessionId3 }, { docA: docA.id, docB: docB.id });
295
+
296
+ const timelineRes = await h.mem_timeline({ observation_id: docB.id });
297
+ const tl = parseRes(timelineRes);
298
+ reporter.step('mem_timeline', { observation_id: docB.id }, { focus: tl.focus?.title, beforeCount: tl.before?.length, afterCount: tl.after?.length });
299
+ ok(tl.focus && tl.focus.id === docB.id, 'timeline focus');
300
+ ok(Array.isArray(tl.before) && tl.before.length >= 1, 'timeline before');
301
+
302
+ reporter.endScenario(p, f);
303
+ return { passed: p, failed: f };
304
+ }
305
+ },
306
+ {
307
+ name: 'Manual edit and reindex',
308
+ goal: 'Editing a Markdown file and reindexing makes the new content searchable.',
309
+ run: async function (ctx) {
310
+ const { h, reporter, fs } = ctx;
311
+ const parseRes = ctx.parse || parse;
312
+ let p = 0, f = 0;
313
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
314
+ const s1 = ctx.shared?.decisionDoc;
315
+ if (!s1) throw new Error('Requires decisionDoc from earlier scenario');
316
+ const docPath = s1.path;
317
+
318
+ reporter.startScenario(this.name, this.goal);
319
+
320
+ let raw = fs.readFileSync(docPath, 'utf8');
321
+ raw = raw.replace('Updated body.', manualEditSnippet);
322
+ fs.writeFileSync(docPath, raw);
323
+ reporter.step('Manual edit', { path: docPath }, 'replaced "Updated body." with realistic snippet');
324
+
325
+ await h.mem_reindex({ full: true });
326
+ reporter.step('mem_reindex', { full: true }, {});
327
+
328
+ const searchA = await h.mem_search({ query: 'Manual edits', project: PROJECT_NAME });
329
+ const searchAParsed = parseRes(searchA);
330
+ reporter.step('mem_search (after edit)', { query: 'Manual edits' }, searchAParsed, { highlight: ['title', 'snippet'] });
331
+ ok(searchAParsed.results.length >= 1, 'edited phrase searchable');
332
+
333
+ const obsEdit = await h.mem_get_observation({ id: s1.id });
334
+ const obsEditParsed = parseRes(obsEdit);
335
+ ok(obsEditParsed.content && obsEditParsed.content.includes(manualEditSnippet.slice(0, 20)), 'get_observation reflects edit');
336
+
337
+ reporter.endScenario(p, f);
338
+ return { passed: p, failed: f };
339
+ }
340
+ },
341
+ {
342
+ name: 'Full reindex from disk',
343
+ goal: 'fullReindex rebuilds the index from Markdown files; search works after.',
344
+ run: async function (ctx) {
345
+ const { h, reporter, config } = ctx;
346
+ const parseRes = ctx.parse || parse;
347
+ let p = 0, f = 0;
348
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
349
+ if (!ctx.shared?.decisionDoc) throw new Error('Requires decisionDoc');
350
+
351
+ reporter.startScenario(this.name, this.goal);
352
+
353
+ const { fullReindex } = await import('../../src/core/indexing/reindex.js');
354
+ const reindexResult = fullReindex(config);
355
+ reporter.step('fullReindex', {}, reindexResult);
356
+ ok(reindexResult.indexed >= 1, 'full reindex indexed');
357
+
358
+ const searchAfter = await h.mem_search({ query: 'Manual edits', project: PROJECT_NAME });
359
+ ok(parseRes(searchAfter).results.length >= 1, 'searchable after rebuild');
360
+
361
+ reporter.endScenario(p, f);
362
+ return { passed: p, failed: f };
363
+ }
364
+ },
365
+ {
366
+ name: 'No duplicates after incremental reindex',
367
+ goal: 'Running incremental reindex without file changes does not duplicate documents.',
368
+ run: async function (ctx) {
369
+ const { h, reporter } = ctx;
370
+ const parseRes = ctx.parse || parse;
371
+ let p = 0, f = 0;
372
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
373
+
374
+ reporter.startScenario(this.name, this.goal);
375
+
376
+ const stats3 = await h.mem_stats();
377
+ await h.mem_reindex({ full: false });
378
+ const stats4 = await h.mem_stats();
379
+ const docs3 = parseRes(stats3).documents;
380
+ const docs4 = parseRes(stats4).documents;
381
+ reporter.step('mem_reindex (incremental)', { full: false }, { docsBefore: docs3, docsAfter: docs4 });
382
+ ok(docs4 === docs3, 'no duplicate docs');
383
+
384
+ reporter.endScenario(p, f);
385
+ return { passed: p, failed: f };
386
+ }
387
+ },
388
+ {
389
+ name: 'Home in merged search',
390
+ goal: 'Merged search returns both project and home results; home note appears.',
391
+ run: async function (ctx) {
392
+ const { h, reporter } = ctx;
393
+ const parseRes = ctx.parse || parse;
394
+ let p = 0, f = 0;
395
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
396
+
397
+ reporter.startScenario(this.name, this.goal);
398
+
399
+ const homeSearch = await h.mem_search({ query: 'reindex', scope_mode: 'merged', project: PROJECT_NAME });
400
+ const homeResults = parseRes(homeSearch).results;
401
+ reporter.step('mem_search (merged)', { query: 'reindex', scope_mode: 'merged' }, { results: homeResults }, { highlight: ['scope', 'title', 'snippet'] });
402
+ const homeInResults = homeResults.some((r) => r.scope === 'home');
403
+ ok(homeInResults, 'home in merged');
404
+
405
+ reporter.endScenario(p, f);
406
+ return { passed: p, failed: f };
407
+ }
408
+ },
409
+ {
410
+ name: 'Project outranks home in merged',
411
+ goal: 'In merged mode, project results rank before home for same topic.',
412
+ run: async function (ctx) {
413
+ const { h, reporter } = ctx;
414
+ const parseRes = ctx.parse || parse;
415
+ let p = 0, f = 0;
416
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
417
+
418
+ reporter.startScenario(this.name, this.goal);
419
+
420
+ const rankSearch = await h.mem_search({ query: 'reindex', scope_mode: 'merged', project: PROJECT_NAME, limit: 5 });
421
+ const rankResults = parseRes(rankSearch).results;
422
+ reporter.step('mem_search (merged)', { query: 'reindex', limit: 5 }, { results: rankResults }, { highlight: ['scope', 'title', 'score'] });
423
+ const firstProject = rankResults.find((r) => r.scope === 'project');
424
+ const firstHome = rankResults.find((r) => r.scope === 'home');
425
+ const projectFirst = !firstHome || !firstProject || rankResults.indexOf(firstProject) <= rankResults.indexOf(firstHome);
426
+ ok(projectFirst, 'project first');
427
+
428
+ reporter.endScenario(p, f);
429
+ return { passed: p, failed: f };
430
+ }
431
+ },
432
+ {
433
+ name: 'Project save does not overwrite home',
434
+ goal: 'Saving a project-scoped note with same topic_key as home does not overwrite the home note.',
435
+ run: async function (ctx) {
436
+ const { h, reporter } = ctx;
437
+ const parseRes = ctx.parse || parse;
438
+ let p = 0, f = 0;
439
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
440
+
441
+ reporter.startScenario(this.name, this.goal);
442
+
443
+ await h.mem_save(patternIncrementalReindexProject);
444
+ reporter.step('mem_save (project, same topic_key)', { topic_key: patternIncrementalReindexProject.topic_key }, {});
445
+
446
+ const homeObs = await h.mem_search({ query: 'Reindex only changed', scope_mode: 'home-only' });
447
+ const homeObsParsed = parseRes(homeObs);
448
+ reporter.step('mem_search (home-only)', { query: 'Reindex only changed', scope_mode: 'home-only' }, homeObsParsed, { highlight: ['title', 'snippet'] });
449
+ ok(homeObsParsed.results.length >= 1, 'home note intact');
450
+
451
+ reporter.endScenario(p, f);
452
+ return { passed: p, failed: f };
453
+ }
454
+ },
455
+ {
456
+ name: 'Semantic / embeddings (save and search)',
457
+ goal: 'With embeddings enabled, save and search work (FTS or hybrid).',
458
+ run: async function (ctx) {
459
+ const { reporter } = ctx;
460
+ const hSemantic = ctx.hSemantic;
461
+ const parseRes = ctx.parse || parse;
462
+ if (!hSemantic) {
463
+ reporter.startScenario(this.name, this.goal);
464
+ reporter.check('skipped (embeddings not in use)', true);
465
+ reporter.endScenario(1, 0);
466
+ return { passed: 1, failed: 0 };
467
+ }
468
+ let p = 0, f = 0;
469
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
470
+
471
+ reporter.startScenario(this.name, this.goal);
472
+
473
+ const saveSem = await hSemantic.mem_save(semanticFallbackDoc);
474
+ const saveSemParsed = parseRes(saveSem);
475
+ reporter.step('mem_save (embeddings on)', { title: semanticFallbackDoc.title }, saveSemParsed);
476
+ ok(saveSemParsed.success, 'save with embeddings');
477
+
478
+ const searchSem = await hSemantic.mem_search({ query: 'semantic fallback', project: PROJECT_NAME });
479
+ const searchSemParsed = parseRes(searchSem);
480
+ reporter.step('mem_search', { query: 'semantic fallback' }, searchSemParsed, { highlight: ['title', 'snippet', 'score'] });
481
+ ok(searchSemParsed.results.length >= 1, 'search returns results');
482
+
483
+ reporter.endScenario(p, f);
484
+ return { passed: p, failed: f };
485
+ }
486
+ },
487
+ {
488
+ name: 'Error handling: update/get invalid id',
489
+ goal: 'mem_update and mem_get_observation with non-existent id return clear errors.',
490
+ run: async function (ctx) {
491
+ const { h, reporter } = ctx;
492
+ const parseRes = ctx.parse || parse;
493
+ let p = 0, f = 0;
494
+ const ok = (cond, msg) => { if (cond) p++; else f++; reporter.check(msg, cond); };
495
+
496
+ reporter.startScenario(this.name, this.goal);
497
+
498
+ const updBad = await h.mem_update({ id: 'obs_nonexistent123', title: 'No', content: 'No' });
499
+ const updBadParsed = parseRes(updBad);
500
+ reporter.step('mem_update (bad id)', { id: 'obs_nonexistent123' }, updBadParsed);
501
+ ok(updBadParsed.success === false && updBadParsed.error, 'update fails cleanly');
502
+
503
+ const getBad = await h.mem_get_observation({ id: 'obs_nonexistent456' });
504
+ const getBadParsed = parseRes(getBad);
505
+ reporter.step('mem_get_observation (bad id)', { id: 'obs_nonexistent456' }, getBadParsed);
506
+ ok(getBadParsed.error === 'Observation not found' || !!getBadParsed.error, 'get_observation error');
507
+
508
+ reporter.endScenario(p, f);
509
+ return { passed: p, failed: f };
510
+ }
511
+ }
512
+ ];
513
+
514
+ // Fix binding of `this` for each scenario's run()
515
+ scenarios.forEach((s) => {
516
+ const run = s.run;
517
+ s.run = function (ctx) {
518
+ return run.call(s, ctx);
519
+ };
520
+ });