brane 0.1.1 → 0.3.0

package/dist/test/membrane-palette.test.js

@@ -0,0 +1,166 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { DISTINCT_AT_L, EXCLUDED_HUE_DEG, MAX_ANCHORS, MIN_ANCHORS, MIN_ANCHOR_DE, MIN_HUE_SEP_DEG, MIN_SCHEME_DISTANCE, SCHEME_FAMILIES, abAt, anchorsDistinct, bandFade, fitToGamut, hueChromaAt, hueExcluded, hueSeparationDeg, inSrgbGamut, nextScheme, packAnchors, sampleScheme, schemeDistance, } from "../shared/membrane-palette.js";
+// Each rule here came from looking at a contact sheet (claude-1cwe8u9p:22–33):
+// the old generator's sixteen taps read as one rainbow; the first rework was
+// too uniform; then "at least three anchors", "no repeats", "not two cyans".
+// These pin the rules, not the look — a sheet is how the look gets judged.
+function mulberry32(a) {
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const DEG = 180 / Math.PI;
+const SAMPLES = 400;
+function samples(seed, n = SAMPLES) {
+    const rng = mulberry32(seed);
+    let prev = null;
+    return Array.from({ length: n }, () => (prev = nextScheme(prev, rng)));
+}
+describe("sampleScheme", () => {
+    const all = samples(1);
+    it("uses at least three anchors, and no more than the shader holds", () => {
+        for (const s of all) {
+            assert.ok(s.hues.length >= MIN_ANCHORS && s.hues.length <= MAX_ANCHORS, `${s.family}: ${s.hues.length}`);
+            assert.equal(s.chromas.length, s.hues.length);
+        }
+    });
+    it("never uses two anchors that would render alike", () => {
+        for (const s of all) {
+            const degs = s.hues.map((h) => h * DEG);
+            for (let i = 0; i < degs.length; i++) {
+                for (let j = i + 1; j < degs.length; j++) {
+                    assert.ok(hueSeparationDeg(degs[i], degs[j]) >= MIN_HUE_SEP_DEG, `${s.family}: ${degs[i]}° vs ${degs[j]}°`);
+                    for (const L of DISTINCT_AT_L) {
+                        const [, a1, b1] = fitToGamut(L, 0.3, s.hues[i]);
+                        const [, a2, b2] = fitToGamut(L, 0.3, s.hues[j]);
+                        assert.ok(Math.hypot(a1 - a2, b1 - b2) >= MIN_ANCHOR_DE);
+                    }
+                }
+            }
+        }
+    });
+    it("keeps the thin film's banding: 2.4–3.7 cycles, L from about 0.35 to 0.95", () => {
+        for (const s of all) {
+            const [cL, , mid, amp] = s.light;
+            assert.ok(cL >= 2.4 && cL <= 3.7);
+            assert.ok(mid - amp >= 0.29 && mid - amp <= 0.41, `trough ${mid - amp}`);
+            assert.ok(mid + amp >= 0.89 && mid + amp <= 1.0, `crest ${mid + amp}`);
+        }
+    });
+    it("puts no anchor between amber and green (claude-u6qlei0j:8), and still uses both sides of the band", () => {
+        let below = 0, above = 0;
+        for (const s of all) {
+            for (const h of s.hues.map((r) => r * DEG)) {
+                assert.ok(!hueExcluded(h), `${s.family}: ${h.toFixed(1)}°`);
+                assert.ok(h < EXCLUDED_HUE_DEG[0] || h > EXCLUDED_HUE_DEG[1]);
+                if (h < EXCLUDED_HUE_DEG[0] && h > EXCLUDED_HUE_DEG[0] - 20)
+                    below++;
+                if (h > EXCLUDED_HUE_DEG[1] && h < EXCLUDED_HUE_DEG[1] + 20)
+                    above++;
+            }
+        }
+        assert.ok(below > 0 && above > 0, "the oranges and the greens either side of the band are not lost with it");
+    });
+    it("passes through every anchor within one unit of thickness", () => {
+        for (const s of all)
+            assert.ok(s.hue[0] >= 1, `hue rate ${s.hue[0]}`);
+    });
+    it("reaches every family", () => {
+        const seen = new Set(all.map((s) => s.family));
+        assert.deepEqual([...seen].sort(), [...SCHEME_FAMILIES].sort());
+    });
+    it("is reproducible from its random source", () => {
+        assert.deepEqual(sampleScheme(mulberry32(42)), sampleScheme(mulberry32(42)));
+    });
+});
+describe("anchorsDistinct", () => {
+    it("rejects two cyans that are 30° apart on paper", () => {
+        // sRGB is narrow around cyan: at these hues the displayable colors nearly
+        // coincide, which is the case the angle test alone let through.
+        assert.ok(hueSeparationDeg(185, 215) >= MIN_HUE_SEP_DEG);
+        assert.equal(anchorsDistinct([185, 215, 40]), false);
+    });
+    it("accepts hues that stay apart once displayed", () => {
+        assert.equal(anchorsDistinct([30, 150, 270]), true);
+    });
+    it("rejects a repeated hue outright", () => {
+        assert.equal(anchorsDistinct([100, 100, 250]), false);
+    });
+});
+describe("nextScheme", () => {
+    it("moves each keyframe well away from the last", () => {
+        const all = samples(2);
+        for (let i = 1; i < all.length; i++) {
+            assert.ok(schemeDistance(all[i - 1], all[i]) >= MIN_SCHEME_DISTANCE);
+        }
+    });
+    it("counts a permutation of the same anchors as a different scheme", () => {
+        const s = sampleScheme(mulberry32(7));
+        const order = s.hues.map((_, i) => i).reverse();
+        const reversed = { ...s, hues: order.map((i) => s.hues[i]), chromas: order.map((i) => s.chromas[i]) };
+        assert.ok(schemeDistance(s, reversed) > 0.02, "reversed order is not the same film");
+        assert.equal(schemeDistance(s, s), 0);
+    });
+});
+describe("gamut", () => {
+    it("fits every anchor to a displayable color at every lightness the bands reach", () => {
+        for (const s of samples(3, 60)) {
+            for (const h of s.hues) {
+                for (let L = 0.3; L <= 0.96; L += 0.06)
+                    assert.ok(inSrgbGamut(...fitToGamut(L, 0.32, h)));
+            }
+        }
+    });
+});
+describe("packAnchors", () => {
+    it("repeats the first anchor after the last, so the lookup wraps without a modulo", () => {
+        const s = sampleScheme(mulberry32(9));
+        const packed = packAnchors(s);
+        const n = s.hues.length;
+        assert.equal(packed.length, (MAX_ANCHORS + 1) * 2);
+        assert.equal(packed[2 * n], Math.fround(s.hues[0]));
+        assert.equal(packed[2 * n + 1], Math.fround(s.chromas[0]));
+    });
+});
+describe("no color from the band, ever (claude-u6qlei0j:8, :17)", () => {
+    it("joins anchors by a straight line through OKLab: green to magenta fades through gray, not through yellow", () => {
+        const s = { ...sampleScheme(mulberry32(5)), hues: [145 / DEG, 330 / DEG], chromas: [0.3, 0.3] };
+        // Midway through the turn (w = 0.5 makes it linear over the whole segment).
+        const [, C] = hueChromaAt(s, 0.25, 0.5);
+        assert.ok(C < 0.06, `nearly gray in the middle, chroma ${C.toFixed(3)}`);
+        // The line does pass the band (145° to 330° the short way is through
+        // 60°), but only near the middle where there is almost no chroma, and
+        // the band takes the rest: nothing in its core, only the ramps' remnant.
+        for (let x = 0; x < 1; x += 1 / 512) {
+            const [h, c] = hueChromaAt(s, x, 0.5);
+            const hd = ((h * DEG) + 360) % 360;
+            if (hd >= 75 && hd <= 115)
+                assert.ok(c < 1e-9, `x ${x.toFixed(3)}: ${hd.toFixed(1)}° at chroma ${c.toFixed(3)}`);
+            if (hueExcluded(hd))
+                assert.ok(c <= 0.06 * (1 - bandFade(hd)) + 1e-9, `x ${x.toFixed(3)}: ${hd.toFixed(1)}° at chroma ${c.toFixed(3)}`);
+        }
+    });
+    it("what still lands in the band is neutral, ramped inside the band so an anchor just outside keeps its color", () => {
+        assert.equal(bandFade(59), 0);
+        assert.equal(bandFade(131), 0);
+        assert.equal(bandFade(95), 1);
+        assert.ok(bandFade(67) > 0 && bandFade(67) < 1);
+        for (const s of samples(4, 200)) {
+            for (let x = 0; x < 1; x += 1 / 256) {
+                const [a, b] = abAt(s, x);
+                const hd = ((Math.atan2(b, a) * DEG) + 360) % 360;
+                const C = Math.hypot(a, b);
+                if (hd >= 75 && hd <= 115)
+                    assert.ok(C < 1e-9, `${s.family} x ${x.toFixed(3)}: ${hd.toFixed(1)}° at ${C.toFixed(3)}`);
+                if (hueExcluded(hd))
+                    assert.ok(C <= 0.32 * (1 - bandFade(hd)) + 1e-9);
+            }
+        }
+    });
+});
+//# sourceMappingURL=membrane-palette.test.js.map

package/dist/test/membrane-terrain.test.js

@@ -0,0 +1,170 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { BLOCK, CELL, JITTER, SEAM, TERRAIN_ROWS, TERRAIN_TEXELS, VIEW_MARGIN, blend, blockCells, blockRows, cell, cellAt, cellScheme, cellsInView, centreCell, createTerrain, packCell, paintCells, schemesInView, seededRng, toWorld, } from "../shared/membrane-terrain.js";
+import { MIN_SCHEME_DISTANCE, SCHEME_TEXELS, nextScheme, packScheme, schemeDistance } from "../shared/membrane-palette.js";
+// The terrain exists so that a hold-and-drag scrolls the base film through
+// color space and a drag back finds the same colors (claude-xaj5pb9b:3–5),
+// and its cells are irregular so the eye finds no grid in it
+// (claude-xaj5pb9b:16). These pin the three properties the module header
+// promises — stable, very different, bounded — not the look of any one cell.
+const same = (a, b) => assert.deepEqual(a, b);
+const k = ([i, j]) => `${i},${j}`;
+/** A random walk of drags, materializing blocks as the engine would. */
+function walk(seed, steps = 40) {
+    const t = createTerrain(seed);
+    const rng = seededRng(seed + 100);
+    let drag = [0, 0];
+    for (let n = 0; n < steps; n++) {
+        blockRows(t, drag);
+        drag = [drag[0] + (rng() - 0.5) * 1.5, drag[1] + (rng() - 0.5) * 1.5];
+    }
+    return t;
+}
+describe("cell", () => {
+    it("is the same cell every time, within a terrain and across terrains of one seed", () => {
+        const t1 = createTerrain(7), t2 = createTerrain(7);
+        same(cell(t1, 3, -2), cell(t1, 3, -2));
+        same(cell(t1, 3, -2), cell(t2, 3, -2));
+        // Once shown, a cell never changes, whatever is drawn around it after.
+        const before = cell(t1, 0, 0);
+        for (const [i, j] of blockCells([0, 0]))
+            cell(t1, i, j);
+        same(cell(t1, 0, 0), before);
+    });
+    it("differs by seed, and by cell", () => {
+        const a = cellScheme(createTerrain(1), 0, 0), b = cellScheme(createTerrain(2), 0, 0);
+        assert.ok(schemeDistance(a, b) > 0);
+        const t = createTerrain(1);
+        assert.ok(schemeDistance(cellScheme(t, 0, 0), cellScheme(t, 5, 5)) > 0);
+    });
+    it("puts its seed point inside its own grid cell, JITTER from the centre at most", () => {
+        const t = walk(3);
+        for (const [key, c] of t.cells) {
+            const [i, j] = key.split(",").map(Number);
+            assert.ok(Math.abs(c.seed[0] / CELL - (i + 0.5)) <= JITTER + 1e-9, `${key}: x ${c.seed[0]}`);
+            assert.ok(Math.abs(c.seed[1] / CELL - (j + 0.5)) <= JITTER + 1e-9, `${key}: y ${c.seed[1]}`);
+            assert.equal(cellAt(c.seed[0]), i);
+            assert.equal(cellAt(c.seed[1]), j);
+        }
+        assert.ok(JITTER < 0.5);
+    });
+    it("is far from every one of its eight neighbors, whichever order they were drawn in", () => {
+        for (let seed = 0; seed < 8; seed++) {
+            const t = walk(seed);
+            for (const [key, c] of t.cells) {
+                const [i, j] = key.split(",").map(Number);
+                for (const [di, dj] of [[1, 0], [0, 1], [1, 1], [1, -1]]) {
+                    const n = t.cells.get(`${i + di},${j + dj}`);
+                    if (n)
+                        assert.ok(schemeDistance(c.scheme, n.scheme) >= MIN_SCHEME_DISTANCE, `seed ${seed}: ${key} vs ${i + di},${j + dj}`);
+                }
+            }
+        }
+    });
+});
+describe("blend", () => {
+    it("gives the nearest cell the largest share, shares to every cell within SEAM of it, none beyond, summing to one", () => {
+        const t = createTerrain(4);
+        const rng = seededRng(5);
+        for (let n = 0; n < 300; n++) {
+            const w = [(rng() - 0.5) * 10, (rng() - 0.5) * 10];
+            const shares = blend(t, w);
+            const dist = (c) => Math.hypot(w[0] - cell(t, ...c).seed[0], w[1] - cell(t, ...c).seed[1]);
+            const d1 = dist(shares[0].cell);
+            for (const c of t.cells.values())
+                assert.ok(Math.hypot(w[0] - c.seed[0], w[1] - c.seed[1]) >= d1 - 1e-12);
+            assert.ok(Math.abs(shares.reduce((a, x) => a + x.weight, 0) - 1) < 1e-9);
+            for (const { cell: c, weight } of shares) {
+                assert.ok(weight > 0 && weight <= shares[0].weight + 1e-12);
+                assert.ok(dist(c) - d1 < SEAM);
+            }
+            // Every cell within SEAM of the nearest is in.
+            const ci = cellAt(w[0]), cj = cellAt(w[1]);
+            for (let dj = -1; dj <= 1; dj++)
+                for (let di = -1; di <= 1; di++) {
+                    if (dist([ci + di, cj + dj]) - d1 < SEAM)
+                        assert.ok(shares.some(({ cell: c }) => c[0] === ci + di && c[1] === cj + dj));
+                }
+        }
+    });
+    it("is continuous: a small step never changes the color's weights by more than a little", () => {
+        // The failure this replaces: blending only the two nearest jumped
+        // wherever the runner-up changed (claude-xaj5pb9b:21).
+        const t = createTerrain(6);
+        const rng = seededRng(7);
+        const weightsOf = (w) => new Map(blend(t, w).map(({ cell: c, weight }) => [`${c[0]},${c[1]}`, weight]));
+        for (let n = 0; n < 2000; n++) {
+            const w = [(rng() - 0.5) * 6, (rng() - 0.5) * 6];
+            const step = 0.002;
+            const a = weightsOf(w), b = weightsOf([w[0] + step, w[1] + step * 0.3]);
+            for (const key of new Set([...a.keys(), ...b.keys()])) {
+                assert.ok(Math.abs((a.get(key) ?? 0) - (b.get(key) ?? 0)) < 0.05, `at ${w}: ${key} jumps`);
+            }
+        }
+    });
+});
+describe("the block", () => {
+    it("is BLOCK² rows, row-major around the centre cell", () => {
+        assert.equal(TERRAIN_ROWS, BLOCK * BLOCK);
+        const cells = blockCells([4, -1]);
+        assert.equal(cells.length, TERRAIN_ROWS);
+        const r = (BLOCK - 1) / 2;
+        same(cells[0], [4 - r, -1 - r]);
+        same(cells[(TERRAIN_ROWS - 1) / 2], [4, -1]);
+        same(cells[TERRAIN_ROWS - 1], [4 + r, -1 + r]);
+        // The shader's row for (di, dj) is (dj + R) * BLOCK + (di + R).
+        same(cells[(1 + r) * BLOCK + (-1 + r)], [3, 0]);
+        assert.equal(blockRows(createTerrain(1), [0, 0]).length, TERRAIN_ROWS);
+    });
+    it("holds every cell the window can show, and every cell their lookups touch, at any drag", () => {
+        const rng = seededRng(11);
+        const t = createTerrain(12);
+        for (let n = 0; n < 300; n++) {
+            const drag = [(rng() - 0.5) * 20, (rng() - 0.5) * 20];
+            const block = new Set(blockCells(centreCell(drag)).map(k));
+            for (const c of cellsInView(t, drag))
+                assert.ok(block.has(k(c)), `drag ${drag}: cell ${k(c)}`);
+            // The shader searches the nine cells around a point's own; the widened
+            // window's corners are the farthest points it will ask about.
+            for (const px of [-0.5, 0.5])
+                for (const py of [-0.5, 0.5]) {
+                    for (const m of [-VIEW_MARGIN, VIEW_MARGIN]) {
+                        const ci = cellAt(toWorld(px, drag[0]) + m), cj = cellAt(toWorld(py, drag[1]) + m);
+                        for (let dj = -1; dj <= 1; dj++)
+                            for (let di = -1; di <= 1; di++)
+                                assert.ok(block.has(`${ci + di},${cj + dj}`), `drag ${drag}: lookup ${ci + di},${cj + dj}`);
+                    }
+                }
+        }
+    });
+    it("scrolls with the drag: a drag of one cell moves the centre one cell, the other way", () => {
+        same(centreCell([0, 0]), [cellAt(0), cellAt(0)]);
+        same(centreCell([CELL, 0]), [centreCell([0, 0])[0] - 1, centreCell([0, 0])[1]]);
+        same(centreCell([0, -2 * CELL]), [centreCell([0, 0])[0], centreCell([0, 0])[1] + 2]);
+    });
+    it("packs a cell as its scheme's texels and then its seed point", () => {
+        assert.equal(TERRAIN_TEXELS, SCHEME_TEXELS + 1);
+        const c = cell(createTerrain(2), 1, 1);
+        const row = packCell(c);
+        assert.equal(row.length, TERRAIN_TEXELS * 4);
+        same([...row.slice(0, SCHEME_TEXELS * 4)], [...packScheme(c.scheme)]);
+        same([...row.slice(SCHEME_TEXELS * 4)], [Math.fround(c.seed[0]), Math.fround(c.seed[1]), 0, 0]);
+    });
+});
+describe("paintCells", () => {
+    it("leaves a wash's scheme on the map, seeds kept, where a drag away and back finds it", () => {
+        const t = createTerrain(5);
+        const drag = [0.3, -0.2];
+        const seeds = new Map([...t.cells].map(([key, c]) => [key, c.seed]));
+        const won = nextScheme(schemesInView(t, drag), seededRng(9));
+        paintCells(t, cellsInView(t, drag), won);
+        for (const s of schemesInView(t, drag))
+            same(s, won);
+        for (const [key, seed] of seeds)
+            same(t.cells.get(key)?.seed, seed);
+        blockRows(t, [drag[0] + 5, drag[1] + 5]); // away
+        for (const s of schemesInView(t, drag))
+            same(s, won); // and back
+    });
+});
+//# sourceMappingURL=membrane-terrain.test.js.map

package/dist/test/memory-log.test.js

@@ -0,0 +1,202 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createTestDb } from "./helpers.js";
+import { appendEvent } from "../db/events.js";
+import { parseDuration, timeSince } from "../commands/memory.js";
+// Helper to insert a narrative row
+function insertNarrative(db, id, opts = {}) {
+    db.prepare(`INSERT INTO narratives (id, brane_id, agent_type, role, status, title, summary, created_at)
+     VALUES (?, 'brane-test', ?, ?, ?, ?, ?, ?)`).run(id, opts.agent_type ?? "claude", opts.role ?? "worker", opts.status ?? "active", opts.title ?? null, opts.summary ?? null, opts.created_at ?? Date.now());
+}
+// The core log query extracted for testing (mirrors memoryLog's SQL)
+function queryLog(db, sinceMs, opts = {}) {
+    let sql = `
+    SELECT
+      n.id,
+      n.agent_type,
+      n.role,
+      n.status,
+      n.title,
+      n.summary,
+      MAX(e.time) as last_activity,
+      COUNT(e.seq) as event_count
+    FROM narratives n
+    JOIN events e ON e.narrative_id = n.id
+    WHERE e.time > ?
+  `;
+    const params = [sinceMs];
+    if (opts.status) {
+        sql += ` AND n.status = ?`;
+        params.push(opts.status);
+    }
+    if (opts.nids) {
+        const placeholders = Array.from(opts.nids)
+            .map(() => "?")
+            .join(", ");
+        sql += ` AND n.id IN (${placeholders})`;
+        params.push(...opts.nids);
+    }
+    sql += `
+    GROUP BY n.id
+    ORDER BY last_activity DESC
+    LIMIT ?
+  `;
+    params.push(opts.limit ?? 20);
+    return db.prepare(sql).all(...params);
+}
+describe("parseDuration", () => {
+    it("parses milliseconds", () => {
+        assert.equal(parseDuration("500ms"), 500);
+    });
+    it("parses seconds", () => {
+        assert.equal(parseDuration("30s"), 30_000);
+    });
+    it("parses minutes", () => {
+        assert.equal(parseDuration("5m"), 5 * 60 * 1000);
+    });
+    it("parses hours", () => {
+        assert.equal(parseDuration("2h"), 2 * 60 * 60 * 1000);
+    });
+    it("parses days", () => {
+        assert.equal(parseDuration("3d"), 3 * 24 * 60 * 60 * 1000);
+    });
+    it("parses weeks", () => {
+        assert.equal(parseDuration("1w"), 7 * 24 * 60 * 60 * 1000);
+    });
+    it("throws on invalid input", () => {
+        assert.throws(() => parseDuration("abc"), /Invalid duration/);
+        assert.throws(() => parseDuration("10x"), /Invalid duration/);
+        assert.throws(() => parseDuration(""), /Invalid duration/);
+    });
+});
+describe("timeSince", () => {
+    it("formats seconds", () => {
+        const result = timeSince(Date.now() - 30_000);
+        assert.match(result, /^\d+s ago$/);
+    });
+    it("formats minutes", () => {
+        const result = timeSince(Date.now() - 5 * 60 * 1000);
+        assert.match(result, /^\d+m ago$/);
+    });
+    it("formats hours", () => {
+        const result = timeSince(Date.now() - 3 * 60 * 60 * 1000);
+        assert.match(result, /^\d+h ago$/);
+    });
+    it("formats days", () => {
+        const result = timeSince(Date.now() - 2 * 24 * 60 * 60 * 1000);
+        assert.match(result, /^\d+d ago$/);
+    });
+});
+describe("memory log query", () => {
+    it("returns narratives sorted by last activity descending", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-old", { title: "Old one" });
+        insertNarrative(db, "n-new", { title: "New one" });
+        appendEvent(db, "n-old", "narration", { content: "old event" });
+        // Manually insert a newer event for n-new
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-new", 1, now + 1000, "narration", "new event");
+        const rows = queryLog(db, now - 60_000);
+        assert.equal(rows.length, 2);
+        assert.equal(rows[0].id, "n-new");
+        assert.equal(rows[1].id, "n-old");
+    });
+    it("filters by time window", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-recent");
+        insertNarrative(db, "n-stale");
+        // Recent event
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-recent", 1, now - 1000, "narration", "recent");
+        // Old event (2 hours ago)
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-stale", 1, now - 2 * 60 * 60 * 1000, "narration", "stale");
+        // Query with 1h window
+        const rows = queryLog(db, now - 60 * 60 * 1000);
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].id, "n-recent");
+    });
+    it("filters by status", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-active", { status: "active" });
+        insertNarrative(db, "n-ended", { status: "ended" });
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-active", 1, now, "narration", "hi");
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-ended", 1, now, "narration", "bye");
+        const rows = queryLog(db, now - 60_000, { status: "active" });
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].id, "n-active");
+    });
+    it("filters by narrative ID set (search)", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-match");
+        insertNarrative(db, "n-other");
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-match", 1, now, "narration", "relevant");
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-other", 1, now, "narration", "unrelated");
+        const rows = queryLog(db, now - 60_000, {
+            nids: new Set(["n-match"]),
+        });
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].id, "n-match");
+    });
+    it("respects limit", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        for (let i = 0; i < 5; i++) {
+            insertNarrative(db, `n-${i}`);
+            db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run(`n-${i}`, 1, now + i, "narration", `event ${i}`);
+        }
+        const rows = queryLog(db, now - 60_000, { limit: 3 });
+        assert.equal(rows.length, 3);
+    });
+    it("counts events per narrative", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-busy");
+        for (let i = 1; i <= 5; i++) {
+            db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-busy", i, now, "narration", `event ${i}`);
+        }
+        const rows = queryLog(db, now - 60_000);
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].event_count, 5);
+    });
+    it("includes title and summary from narrative", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-titled", {
+            title: "Auth Module",
+            summary: "Working on JWT",
+        });
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-titled", 1, now, "narration", "doing auth");
+        const rows = queryLog(db, now - 60_000);
+        assert.equal(rows[0].title, "Auth Module");
+        assert.equal(rows[0].summary, "Working on JWT");
+    });
+    it("returns empty when no narratives have recent events", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-old");
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-old", 1, now - 48 * 60 * 60 * 1000, "narration", "ancient");
+        const rows = queryLog(db, now - 24 * 60 * 60 * 1000);
+        assert.equal(rows.length, 0);
+    });
+    it("LIKE fallback search finds matching narratives", () => {
+        const db = createTestDb();
+        const now = Date.now();
+        insertNarrative(db, "n-auth");
+        insertNarrative(db, "n-db");
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-auth", 1, now, "narration", "implementing JWT authentication");
+        db.prepare("INSERT INTO events (narrative_id, seq, time, type, content) VALUES (?, ?, ?, ?, ?)").run("n-db", 1, now, "narration", "database migration complete");
+        // Simulate LIKE search fallback
+        const likeRows = db
+            .prepare(`SELECT DISTINCT narrative_id FROM events WHERE content LIKE ? LIMIT 1000`)
+            .all("%JWT%");
+        const nids = new Set(likeRows.map((r) => r.narrative_id));
+        assert.equal(nids.size, 1);
+        assert.ok(nids.has("n-auth"));
+        const rows = queryLog(db, now - 60_000, { nids });
+        assert.equal(rows.length, 1);
+        assert.equal(rows[0].id, "n-auth");
+    });
+});
+//# sourceMappingURL=memory-log.test.js.map