@askjo/pi-mem 1.0.0

package/tests/memory-context.test.ts

@@ -0,0 +1,150 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import * as fs from "node:fs";
+import { buildMemoryContext, ensureDirs, todayStr, yesterdayStr } from "../lib.ts";
+import { makeTempDir, cleanup, makeConfig, writeFile } from "./helpers.ts";
+
+let tmpDir: string;
+
+beforeEach(() => { tmpDir = makeTempDir(); });
+afterEach(() => { cleanup(tmpDir); });
+
+describe("buildMemoryContext", () => {
+	it("returns empty string when no files exist", () => {
+		const config = makeConfig(tmpDir);
+		assert.strictEqual(buildMemoryContext(config), "");
+	});
+
+	it("includes MEMORY.md content", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "Important fact", "utf-8");
+		const result = buildMemoryContext(config);
+		assert.ok(result.includes("# Memory"));
+		assert.ok(result.includes("## MEMORY.md (long-term)"));
+		assert.ok(result.includes("Important fact"));
+	});
+
+	it("includes open scratchpad items only", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.scratchpadFile, "# Scratchpad\n\n- [ ] Open task\n- [x] Done task\n", "utf-8");
+		const result = buildMemoryContext(config);
+		assert.ok(result.includes("## SCRATCHPAD.md (working context)"));
+		assert.ok(result.includes("Open task"));
+		assert.ok(!result.includes("Done task"));
+	});
+
+	it("skips scratchpad section when all items are done", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.scratchpadFile, "# Scratchpad\n\n- [x] Done\n", "utf-8");
+		const result = buildMemoryContext(config);
+		assert.ok(!result.includes("SCRATCHPAD"));
+	});
+
+	it("skips scratchpad section when file is empty", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.scratchpadFile, "", "utf-8");
+		const result = buildMemoryContext(config);
+		assert.ok(!result.includes("SCRATCHPAD"));
+	});
+
+	it("includes today's daily log", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		const today = todayStr();
+		writeFile(`${config.dailyDir}/${today}.md`, "Today's entry");
+		const result = buildMemoryContext(config);
+		assert.ok(result.includes(`## Daily log: ${today} (today)`));
+		assert.ok(result.includes("Today's entry"));
+	});
+
+	it("includes yesterday's daily log", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		const yesterday = yesterdayStr();
+		writeFile(`${config.dailyDir}/${yesterday}.md`, "Yesterday's entry");
+		const result = buildMemoryContext(config);
+		assert.ok(result.includes(`## Daily log: ${yesterday} (yesterday)`));
+		assert.ok(result.includes("Yesterday's entry"));
+	});
+
+	it("does not include day-before-yesterday logs", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		writeFile(`${config.dailyDir}/2020-01-01.md`, "Old entry");
+		const result = buildMemoryContext(config);
+		assert.ok(!result.includes("Old entry"));
+	});
+
+	it("includes context files when configured", () => {
+		const config = makeConfig(tmpDir, { contextFiles: ["SOUL.md"] });
+		ensureDirs(config);
+		writeFile(`${config.memoryDir}/SOUL.md`, "I am a helpful assistant");
+		const result = buildMemoryContext(config);
+		assert.ok(result.includes("## SOUL.md"));
+		assert.ok(result.includes("I am a helpful assistant"));
+	});
+
+	it("skips missing context files", () => {
+		const config = makeConfig(tmpDir, { contextFiles: ["MISSING.md"] });
+		ensureDirs(config);
+		const result = buildMemoryContext(config);
+		assert.ok(!result.includes("MISSING.md"));
+	});
+
+	it("skips empty context files", () => {
+		const config = makeConfig(tmpDir, { contextFiles: ["EMPTY.md"] });
+		ensureDirs(config);
+		writeFile(`${config.memoryDir}/EMPTY.md`, "   \n  ");
+		const result = buildMemoryContext(config);
+		assert.ok(!result.includes("EMPTY.md"));
+	});
+
+	it("separates sections with ---", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "Memory content", "utf-8");
+		fs.writeFileSync(config.scratchpadFile, "# Scratchpad\n\n- [ ] Task\n", "utf-8");
+		const result = buildMemoryContext(config);
+		assert.ok(result.includes("---"));
+	});
+
+	it("assembles sections in correct order: context files, memory, scratchpad, today, yesterday", () => {
+		const config = makeConfig(tmpDir, { contextFiles: ["SOUL.md"] });
+		ensureDirs(config);
+		writeFile(`${config.memoryDir}/SOUL.md`, "Soul content");
+		fs.writeFileSync(config.memoryFile, "Memory content", "utf-8");
+		fs.writeFileSync(config.scratchpadFile, "# Scratchpad\n\n- [ ] Task\n", "utf-8");
+		writeFile(`${config.dailyDir}/${todayStr()}.md`, "Today content");
+		writeFile(`${config.dailyDir}/${yesterdayStr()}.md`, "Yesterday content");
+
+		const result = buildMemoryContext(config);
+		const soulIdx = result.indexOf("## SOUL.md");
+		const memIdx = result.indexOf("## MEMORY.md");
+		const spIdx = result.indexOf("## SCRATCHPAD.md");
+		const todayIdx = result.indexOf("(today)");
+		const yesterdayIdx = result.indexOf("(yesterday)");
+
+		assert.ok(soulIdx < memIdx, "SOUL.md should come before MEMORY.md");
+		assert.ok(memIdx < spIdx, "MEMORY.md should come before SCRATCHPAD.md");
+		assert.ok(spIdx < todayIdx, "SCRATCHPAD should come before today");
+		assert.ok(todayIdx < yesterdayIdx, "today should come before yesterday");
+	});
+
+	it("includes multiple context files in order", () => {
+		const config = makeConfig(tmpDir, { contextFiles: ["A.md", "B.md", "C.md"] });
+		ensureDirs(config);
+		writeFile(`${config.memoryDir}/A.md`, "File A");
+		writeFile(`${config.memoryDir}/B.md`, "File B");
+		writeFile(`${config.memoryDir}/C.md`, "File C");
+		const result = buildMemoryContext(config);
+		const aIdx = result.indexOf("## A.md");
+		const bIdx = result.indexOf("## B.md");
+		const cIdx = result.indexOf("## C.md");
+		assert.ok(aIdx < bIdx);
+		assert.ok(bIdx < cIdx);
+	});
+});

package/tests/scratchpad.test.ts

@@ -0,0 +1,191 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { parseScratchpad, serializeScratchpad, type ScratchpadItem } from "../lib.ts";
+
+describe("parseScratchpad", () => {
+	it("parses open items", () => {
+		const items = parseScratchpad("- [ ] Fix the bug\n- [ ] Write tests");
+		assert.strictEqual(items.length, 2);
+		assert.strictEqual(items[0].done, false);
+		assert.strictEqual(items[0].text, "Fix the bug");
+		assert.strictEqual(items[1].text, "Write tests");
+	});
+
+	it("parses done items", () => {
+		const items = parseScratchpad("- [x] Done task\n- [X] Also done");
+		assert.strictEqual(items.length, 2);
+		assert.strictEqual(items[0].done, true);
+		assert.strictEqual(items[1].done, true);
+	});
+
+	it("parses mixed open and done items", () => {
+		const items = parseScratchpad("- [ ] Open\n- [x] Done\n- [ ] Another open");
+		assert.strictEqual(items.length, 3);
+		assert.strictEqual(items[0].done, false);
+		assert.strictEqual(items[1].done, true);
+		assert.strictEqual(items[2].done, false);
+	});
+
+	it("captures meta comment from preceding line", () => {
+		const content = "<!-- 2026-02-18 10:00:00 [abc12345] -->\n- [ ] Task with meta";
+		const items = parseScratchpad(content);
+		assert.strictEqual(items.length, 1);
+		assert.strictEqual(items[0].meta, "<!-- 2026-02-18 10:00:00 [abc12345] -->");
+		assert.strictEqual(items[0].text, "Task with meta");
+	});
+
+	it("does not capture non-comment preceding lines as meta", () => {
+		const content = "Some random text\n- [ ] Task without meta";
+		const items = parseScratchpad(content);
+		assert.strictEqual(items.length, 1);
+		assert.strictEqual(items[0].meta, "");
+	});
+
+	it("ignores non-checklist lines", () => {
+		const content = "# Scratchpad\n\nSome preamble\n- [ ] Real item\n\nMore text";
+		const items = parseScratchpad(content);
+		assert.strictEqual(items.length, 1);
+		assert.strictEqual(items[0].text, "Real item");
+	});
+
+	it("handles empty content", () => {
+		assert.deepStrictEqual(parseScratchpad(""), []);
+	});
+
+	it("handles content with only headers and whitespace", () => {
+		assert.deepStrictEqual(parseScratchpad("# Scratchpad\n\n"), []);
+	});
+
+	it("handles items with special characters", () => {
+		const items = parseScratchpad("- [ ] Fix `regex` in $PATH (urgent!)");
+		assert.strictEqual(items.length, 1);
+		assert.strictEqual(items[0].text, "Fix `regex` in $PATH (urgent!)");
+	});
+
+	it("requires space after checkbox bracket", () => {
+		const items = parseScratchpad("- []No space\n- [ ] Has space");
+		assert.strictEqual(items.length, 1);
+		assert.strictEqual(items[0].text, "Has space");
+	});
+
+	it("parses realistic scratchpad with header and meta", () => {
+		const content = `# Scratchpad
+
+<!-- 2026-02-16 18:16:01 [12950572] -->
+- [ ] Kill sniper module
+<!-- 2026-02-17 17:27:00 [b54e290c] -->
+- [x] Add integration tests
+<!-- 2026-02-18 01:37:44 [3b717a40] -->
+- [ ] Conditional delivery`;
+
+		const items = parseScratchpad(content);
+		assert.strictEqual(items.length, 3);
+		assert.strictEqual(items[0].done, false);
+		assert.strictEqual(items[0].text, "Kill sniper module");
+		assert.ok(items[0].meta.includes("12950572"));
+		assert.strictEqual(items[1].done, true);
+		assert.strictEqual(items[1].text, "Add integration tests");
+		assert.strictEqual(items[2].done, false);
+		assert.strictEqual(items[2].text, "Conditional delivery");
+	});
+});
+
+describe("serializeScratchpad", () => {
+	it("serializes empty list", () => {
+		const result = serializeScratchpad([]);
+		assert.strictEqual(result, "# Scratchpad\n\n");
+	});
+
+	it("serializes open items", () => {
+		const items: ScratchpadItem[] = [
+			{ done: false, text: "First", meta: "" },
+			{ done: false, text: "Second", meta: "" },
+		];
+		const result = serializeScratchpad(items);
+		assert.ok(result.includes("- [ ] First"));
+		assert.ok(result.includes("- [ ] Second"));
+	});
+
+	it("serializes done items", () => {
+		const items: ScratchpadItem[] = [{ done: true, text: "Completed", meta: "" }];
+		const result = serializeScratchpad(items);
+		assert.ok(result.includes("- [x] Completed"));
+	});
+
+	it("includes meta comments before items", () => {
+		const items: ScratchpadItem[] = [
+			{ done: false, text: "Task", meta: "<!-- 2026-02-18 [abc] -->" },
+		];
+		const result = serializeScratchpad(items);
+		const lines = result.split("\n");
+		const metaIdx = lines.findIndex(l => l.includes("<!-- 2026-02-18"));
+		const taskIdx = lines.findIndex(l => l.includes("- [ ] Task"));
+		assert.ok(metaIdx >= 0);
+		assert.ok(taskIdx >= 0);
+		assert.strictEqual(taskIdx, metaIdx + 1);
+	});
+
+	it("skips meta when empty string", () => {
+		const items: ScratchpadItem[] = [{ done: false, text: "No meta", meta: "" }];
+		const result = serializeScratchpad(items);
+		assert.ok(!result.includes("<!--"));
+	});
+
+	it("starts with # Scratchpad header", () => {
+		const result = serializeScratchpad([{ done: false, text: "X", meta: "" }]);
+		assert.ok(result.startsWith("# Scratchpad\n"));
+	});
+
+	it("ends with newline", () => {
+		const result = serializeScratchpad([{ done: false, text: "X", meta: "" }]);
+		assert.ok(result.endsWith("\n"));
+	});
+});
+
+describe("parseScratchpad + serializeScratchpad round-trip", () => {
+	it("round-trips a simple list", () => {
+		const items: ScratchpadItem[] = [
+			{ done: false, text: "Open item", meta: "<!-- ts [sid] -->" },
+			{ done: true, text: "Done item", meta: "<!-- ts2 [sid2] -->" },
+		];
+		const serialized = serializeScratchpad(items);
+		const parsed = parseScratchpad(serialized);
+		assert.strictEqual(parsed.length, 2);
+		assert.strictEqual(parsed[0].done, false);
+		assert.strictEqual(parsed[0].text, "Open item");
+		assert.strictEqual(parsed[0].meta, "<!-- ts [sid] -->");
+		assert.strictEqual(parsed[1].done, true);
+		assert.strictEqual(parsed[1].text, "Done item");
+	});
+
+	it("round-trips items without meta", () => {
+		const items: ScratchpadItem[] = [
+			{ done: false, text: "No meta here", meta: "" },
+		];
+		const serialized = serializeScratchpad(items);
+		const parsed = parseScratchpad(serialized);
+		assert.strictEqual(parsed.length, 1);
+		assert.strictEqual(parsed[0].text, "No meta here");
+		assert.strictEqual(parsed[0].meta, "");
+	});
+
+	it("round-trips empty list", () => {
+		const serialized = serializeScratchpad([]);
+		const parsed = parseScratchpad(serialized);
+		assert.strictEqual(parsed.length, 0);
+	});
+
+	it("round-trips complex content with special chars", () => {
+		const items: ScratchpadItem[] = [
+			{ done: false, text: "Fix `regex` in $PATH (urgent!) — ref #123", meta: "<!-- 2026-02-18 01:37:44 [3b717a40] -->" },
+			{ done: true, text: "Deploy v2.0.1 to prod", meta: "<!-- 2026-02-17 09:00:00 [deadbeef] -->" },
+			{ done: false, text: "Check if BTC < $90K", meta: "" },
+		];
+		const serialized = serializeScratchpad(items);
+		const parsed = parseScratchpad(serialized);
+		assert.strictEqual(parsed.length, 3);
+		assert.strictEqual(parsed[0].text, items[0].text);
+		assert.strictEqual(parsed[1].done, true);
+		assert.strictEqual(parsed[2].meta, "");
+	});
+});

package/tests/search.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import * as fs from "node:fs";
+import { searchMemory, ensureDirs } from "../lib.ts";
+import { makeTempDir, cleanup, makeConfig, writeFile } from "./helpers.ts";
+
+let tmpDir: string;
+
+beforeEach(() => { tmpDir = makeTempDir(); });
+afterEach(() => { cleanup(tmpDir); });
+
+describe("searchMemory", () => {
+	it("finds content in MEMORY.md", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "Important decision: use PostgreSQL", "utf-8");
+		const result = searchMemory(config, "postgresql");
+		assert.strictEqual(result.lineResults.length, 1);
+		assert.ok(result.lineResults[0].text.includes("PostgreSQL"));
+		assert.strictEqual(result.lineResults[0].file, "MEMORY.md");
+		assert.strictEqual(result.lineResults[0].line, 1);
+	});
+
+	it("finds content in daily logs", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		writeFile(`${config.dailyDir}/2026-02-18.md`, "line one\nDeployed trading bot\nline three");
+		const result = searchMemory(config, "trading bot");
+		assert.strictEqual(result.lineResults.length, 1);
+		assert.strictEqual(result.lineResults[0].file, "daily/2026-02-18.md");
+		assert.strictEqual(result.lineResults[0].line, 2);
+	});
+
+	it("finds content in notes", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		writeFile(`${config.notesDir}/lessons.md`, "Lesson learned: always test");
+		const result = searchMemory(config, "lesson");
+		assert.strictEqual(result.lineResults.length, 1);
+		assert.strictEqual(result.lineResults[0].file, "notes/lessons.md");
+	});
+
+	it("is case-insensitive", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "PostgreSQL is great", "utf-8");
+		const result = searchMemory(config, "POSTGRESQL");
+		assert.strictEqual(result.lineResults.length, 1);
+	});
+
+	it("matches filenames", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "some content", "utf-8");
+		const result = searchMemory(config, "memory");
+		assert.ok(result.fileMatches.includes("MEMORY.md"));
+	});
+
+	it("respects maxResults limit", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		const lines = Array.from({ length: 50 }, (_, i) => `match line ${i}`).join("\n");
+		fs.writeFileSync(config.memoryFile, lines, "utf-8");
+		const result = searchMemory(config, "match", 5);
+		assert.strictEqual(result.lineResults.length, 5);
+	});
+
+	it("returns empty results for no matches", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "nothing relevant here", "utf-8");
+		const result = searchMemory(config, "xyznonexistent");
+		assert.strictEqual(result.fileMatches.length, 0);
+		assert.strictEqual(result.lineResults.length, 0);
+	});
+
+	it("returns empty results when no files exist", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		const result = searchMemory(config, "anything");
+		assert.strictEqual(result.fileMatches.length, 0);
+		assert.strictEqual(result.lineResults.length, 0);
+	});
+
+	it("searches across all directories", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "target in memory", "utf-8");
+		writeFile(`${config.dailyDir}/2026-02-18.md`, "target in daily");
+		writeFile(`${config.notesDir}/work.md`, "target in notes");
+		const result = searchMemory(config, "target");
+		assert.strictEqual(result.lineResults.length, 3);
+		const files = result.lineResults.map(r => r.file);
+		assert.ok(files.includes("MEMORY.md"));
+		assert.ok(files.some(f => f.startsWith("daily/")));
+		assert.ok(files.some(f => f.startsWith("notes/")));
+	});
+
+	it("does not deduplicate filename matches", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		writeFile(`${config.dailyDir}/2026-02-18.md`, "some content");
+		// Searching for "2026-02-18" matches the filename
+		const result = searchMemory(config, "2026-02-18");
+		assert.ok(result.fileMatches.includes("daily/2026-02-18.md"));
+	});
+
+	it("trims trailing whitespace from matched lines", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		fs.writeFileSync(config.memoryFile, "match with trailing spaces   \n", "utf-8");
+		const result = searchMemory(config, "match");
+		assert.strictEqual(result.lineResults[0].text, "match with trailing spaces");
+	});
+
+	it("only searches .md files", () => {
+		const config = makeConfig(tmpDir);
+		ensureDirs(config);
+		writeFile(`${config.memoryDir}/data.json`, '{"target": true}');
+		writeFile(`${config.memoryDir}/notes.md`, "target in md");
+		// json file should not be content-searched (searchDir filters to .md)
+		const result = searchMemory(config, "target");
+		assert.strictEqual(result.lineResults.length, 1);
+		assert.strictEqual(result.lineResults[0].file, "notes.md");
+	});
+});

package/tests/session-scanner.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { scanSession, isHousekeeping } from "../lib.ts";
+import { makeTempDir, cleanup } from "./helpers.ts";
+
+let tmpDir: string;
+
+beforeEach(() => { tmpDir = makeTempDir(); });
+afterEach(() => { cleanup(tmpDir); });
+
+function writeSessionFile(dir: string, name: string, lines: any[]): string {
+	const filePath = path.join(dir, name);
+	fs.writeFileSync(filePath, lines.map(l => JSON.stringify(l)).join("\n") + "\n", "utf-8");
+	return filePath;
+}
+
+describe("scanSession", () => {
+	it("extracts title from session_info entry", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString(), cwd: "/project" },
+			{ type: "session_info", name: "Fix memory bug" },
+			{ type: "message", message: { role: "user", content: "hello" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.title, "Fix memory bug");
+		assert.strictEqual(result.cwd, "/project");
+	});
+
+	it("falls back to first user message when no session_info", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "assistant", content: "Hi" } },
+			{ type: "message", message: { role: "user", content: "Can you fix the tests?" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.title, "Can you fix the tests?");
+	});
+
+	it("handles array content in user message fallback", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "user", content: [{ type: "text", text: "Array content message" }] } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.title, "Array content message");
+	});
+
+	it("truncates long titles to 80 chars", async () => {
+		const longMsg = "A".repeat(200);
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "user", content: longMsg } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.title.length, 80);
+	});
+
+	it("returns (untitled) when no title or user messages", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "assistant", content: "response" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.title, "(untitled)");
+	});
+
+	it("sums costs from assistant messages", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "assistant", content: "r1", usage: { cost: { total: 0.05 } } } },
+			{ type: "message", message: { role: "assistant", content: "r2", usage: { cost: { total: 0.10 } } } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.ok(Math.abs(result.cost - 0.15) < 0.001);
+	});
+
+	it("detects child sessions", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString(), parentSession: "parent-123" },
+			{ type: "message", message: { role: "user", content: "sub-task" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.isChild, true);
+		assert.strictEqual(result.parentSession, "parent-123");
+	});
+
+	it("detects root sessions (no parent)", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "user", content: "root task" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.isChild, false);
+		assert.strictEqual(result.parentSession, undefined);
+	});
+
+	it("returns null for old sessions outside lookback window", async () => {
+		const oldDate = new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString();
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: oldDate },
+			{ type: "message", message: { role: "user", content: "old stuff" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.strictEqual(result, null);
+	});
+
+	it("returns null for invalid JSON header", async () => {
+		const filePath = path.join(tmpDir, "bad.jsonl");
+		fs.writeFileSync(filePath, "not json\n", "utf-8");
+		const result = await scanSession(filePath);
+		assert.strictEqual(result, null);
+	});
+
+	it("returns null for header without timestamp", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ cwd: "/project" },
+		]);
+		const result = await scanSession(filePath);
+		assert.strictEqual(result, null);
+	});
+
+	it("returns null for non-existent file", async () => {
+		const result = await scanSession(path.join(tmpDir, "nope.jsonl"));
+		assert.strictEqual(result, null);
+	});
+
+	it("handles lines with invalid JSON gracefully (skips them)", async () => {
+		const filePath = path.join(tmpDir, "mixed.jsonl");
+		const header = JSON.stringify({ timestamp: new Date().toISOString() });
+		const good = JSON.stringify({ type: "session_info", name: "Good Title" });
+		fs.writeFileSync(filePath, `${header}\ngarbage line\n${good}\n`, "utf-8");
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.title, "Good Title");
+	});
+
+	it("defaults cost to 0 when no usage data", async () => {
+		const filePath = writeSessionFile(tmpDir, "session.jsonl", [
+			{ timestamp: new Date().toISOString() },
+			{ type: "message", message: { role: "assistant", content: "no cost" } },
+		]);
+		const result = await scanSession(filePath);
+		assert.ok(result);
+		assert.strictEqual(result.cost, 0);
+	});
+});
+
+describe("isHousekeeping", () => {
+	it("detects 'clear done' titles", () => {
+		assert.ok(isHousekeeping("Clear done items"));
+		assert.ok(isHousekeeping("clear scratchpad"));
+	});
+
+	it("detects 'review scratchpad' titles", () => {
+		assert.ok(isHousekeeping("Review scratchpad items"));
+		assert.ok(isHousekeeping("Read daily log"));
+	});
+
+	it("detects '(untitled)' as housekeeping", () => {
+		assert.ok(isHousekeeping("(untitled)"));
+	});
+
+	it("detects bare slash commands", () => {
+		assert.ok(isHousekeeping("/reload"));
+		assert.ok(isHousekeeping("/new"));
+	});
+
+	it("detects 'write daily log'", () => {
+		assert.ok(isHousekeeping("Write daily log for today"));
+	});
+
+	it("detects scratchpad management titles", () => {
+		assert.ok(isHousekeeping("Scratchpad maintenance"));
+		assert.ok(isHousekeeping("Scratchpad reviewed"));
+		assert.ok(isHousekeeping("scratchpad items update"));
+	});
+
+	it("detects dash-prefixed housekeeping", () => {
+		assert.ok(isHousekeeping("- no done items left"));
+		assert.ok(isHousekeeping("- scratchpad cleaned up"));
+		assert.ok(isHousekeeping("- cleared all items"));
+	});
+
+	it("does not flag real work titles", () => {
+		assert.ok(!isHousekeeping("Fix memory bug"));
+		assert.ok(!isHousekeeping("Deploy trading bot"));
+		assert.ok(!isHousekeeping("Write tests for pi-mem"));
+		assert.ok(!isHousekeeping("Review PR #42"));
+		assert.ok(!isHousekeeping("Debug WebSocket connection"));
+	});
+
+	it("is case insensitive", () => {
+		assert.ok(isHousekeeping("CLEAR DONE"));
+		assert.ok(isHousekeeping("Clear Done Items"));
+	});
+});