@askjo/pi-mem 1.0.0 → 1.2.0

package/lib.ts

@@ -5,6 +5,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
+import * as os from "node:os";
 import { createReadStream } from "node:fs";
 import { createInterface } from "node:readline";
 
@@ -17,17 +18,77 @@ export interface MemoryConfig {
 	dailyDir: string;
 	notesDir: string;
 	contextFiles: string[];
+	searchDirs: string[];
 	autocommit: boolean;
+	timezone: string;
+}
+
+export interface FileConfig {
+	dailyDir?: string;
+	contextFiles?: string[];
+	searchDirs?: string[];
+	autocommit?: boolean;
+}
+
+export function loadConfigFile(memoryDir: string): FileConfig {
+	try {
+		const raw = fs.readFileSync(path.join(memoryDir, ".pi-mem.json"), "utf-8");
+		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+		const result: FileConfig = {};
+		if (typeof parsed.dailyDir === "string") result.dailyDir = parsed.dailyDir;
+		if (Array.isArray(parsed.contextFiles)) result.contextFiles = parsed.contextFiles.filter((s: unknown) => typeof s === "string");
+		if (Array.isArray(parsed.searchDirs)) result.searchDirs = parsed.searchDirs.filter((s: unknown) => typeof s === "string");
+		if (typeof parsed.autocommit === "boolean") result.autocommit = parsed.autocommit;
+		return result;
+	} catch {
+		return {};
+	}
+}
+
+function parseCommaSeparated(value: string | undefined): string[] | undefined {
+	if (value === undefined) return undefined;
+	const items = value.split(",").map(f => f.trim()).filter(Boolean);
+	return items;
+}
+
+export function resolveHomeDir(
+	env: Record<string, string | undefined> = process.env,
+	fallback = os.homedir(),
+): string {
+	return env.HOME
+		?? env.USERPROFILE
+		?? (env.HOMEDRIVE && env.HOMEPATH ? `${env.HOMEDRIVE}${env.HOMEPATH}` : undefined)
+		?? fallback;
+}
+
+export function resolveAgentDir(
+	env: Record<string, string | undefined> = process.env,
+	fallbackHome = os.homedir(),
+): string {
+	return env.PI_CODING_AGENT_DIR ?? path.join(resolveHomeDir(env, fallbackHome), ".pi", "agent");
+}
+
+export function resolveSessionsDir(
+	env: Record<string, string | undefined> = process.env,
+	fallbackHome = os.homedir(),
+): string {
+	return path.join(resolveAgentDir(env, fallbackHome), "sessions");
 }
 
 export function buildConfig(env: Record<string, string | undefined> = process.env): MemoryConfig {
-	const memoryDir = env.PI_MEMORY_DIR ?? path.join(env.HOME ?? "~", ".pi", "agent", "memory");
-	const dailyDir = env.PI_DAILY_DIR ?? path.join(memoryDir, "daily");
-	const contextFiles = (env.PI_CONTEXT_FILES ?? "")
-		.split(",")
-		.map(f => f.trim())
-		.filter(Boolean);
-	const autocommit = env.PI_AUTOCOMMIT === "1" || env.PI_AUTOCOMMIT === "true";
+	const memoryDir = env.PI_MEMORY_DIR ?? path.join(resolveAgentDir(env), "memory");
+
+	// Load config.json from memory dir (env vars override file values)
+	const fileConfig = loadConfigFile(memoryDir);
+
+	const dailyDir = env.PI_DAILY_DIR ?? fileConfig.dailyDir ?? path.join(memoryDir, "daily");
+	const contextFiles = parseCommaSeparated(env.PI_CONTEXT_FILES) ?? fileConfig.contextFiles ?? [];
+	const searchDirs = parseCommaSeparated(env.PI_SEARCH_DIRS) ?? fileConfig.searchDirs ?? [];
+	const autocommit = env.PI_AUTOCOMMIT !== undefined
+		? (env.PI_AUTOCOMMIT === "1" || env.PI_AUTOCOMMIT === "true")
+		: (fileConfig.autocommit ?? false);
+	const timezone = normalizeTimeZone(env.PI_TIMEZONE ?? env.TZ ?? "UTC");
 
 	return {
 		memoryDir,
@@ -36,20 +97,52 @@ export function buildConfig(env: Record<string, string | undefined> = process.en
 		dailyDir,
 		notesDir: path.join(memoryDir, "notes"),
 		contextFiles,
+		searchDirs,
 		autocommit,
+		timezone,
 	};
 }
 
+export function normalizeTimeZone(timeZone: string | undefined): string {
+	const candidate = timeZone?.trim() || "UTC";
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: candidate }).format(new Date());
+		return candidate;
+	} catch {
+		return "UTC";
+	}
+}
+
 // --- Date/time helpers ---
 
-export function todayStr(): string {
-	return new Date().toISOString().slice(0, 10);
+function localDateParts(date: Date, timeZone: string): { year: number; month: number; day: number } {
+	const parts = new Intl.DateTimeFormat("en-US", {
+		timeZone: normalizeTimeZone(timeZone),
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+	}).formatToParts(date);
+	const values = Object.fromEntries(parts.filter(part => part.type !== "literal").map(part => [part.type, Number(part.value)]));
+	return { year: values.year, month: values.month, day: values.day };
+}
+
+function formatDateParts(parts: { year: number; month: number; day: number }): string {
+	return `${parts.year}-${String(parts.month).padStart(2, "0")}-${String(parts.day).padStart(2, "0")}`;
+}
+
+export function todayStr(timeZone = "UTC", now = new Date()): string {
+	return formatDateParts(localDateParts(now, timeZone));
+}
+
+export function yesterdayStr(timeZone = "UTC", now = new Date()): string {
+	return daysAgoStr(1, timeZone, now);
 }
 
-export function yesterdayStr(): string {
-	const d = new Date();
-	d.setDate(d.getDate() - 1);
-	return d.toISOString().slice(0, 10);
+/** Get a date string N days ago from today. */
+export function daysAgoStr(n: number, timeZone = "UTC", now = new Date()): string {
+	const parts = localDateParts(now, timeZone);
+	const shifted = new Date(Date.UTC(parts.year, parts.month - 1, parts.day - n, 12, 0, 0, 0));
+	return formatDateParts(localDateParts(shifted, timeZone));
 }
 
 export function nowTimestamp(): string {
@@ -74,6 +167,165 @@ export function dailyPath(dailyDir: string, date: string): string {
 	return path.join(dailyDir, `${date}.md`);
 }
 
+/** Validate and normalize a relative file path within the memory directory. Returns null if path escapes memoryDir. */
+export function safeResolvePath(memoryDir: string, filename: string): { resolved: string; normalized: string } | null {
+	const normalized = path.normalize(filename).replace(/^\/+/, "");
+	if (normalized.startsWith("..") || path.isAbsolute(filename)) return null;
+	return { resolved: path.join(memoryDir, normalized), normalized };
+}
+
+export interface IndexEntry {
+	directory: string;
+	filename: string;
+	title: string;
+	line: string;
+}
+
+export interface MemoryReadResult {
+	text: string;
+	details: Record<string, unknown>;
+}
+
+function normalizeLookupText(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/\.md$/i, "")
+		.replace(/[\p{Emoji_Presentation}\p{Extended_Pictographic}]/gu, " ")
+		.replace(/[_-]+/g, " ")
+		.replace(/[^a-z0-9]+/g, " ")
+		.trim()
+		.replace(/\s+/g, " ");
+}
+
+function titleFromIndexLine(line: string): string {
+	const withoutFileComment = line.replace(/<!--\s*file:[^>]+-->/i, "").trim();
+	const parts = withoutFileComment.split(/\s+—\s+/);
+	const titlePart = parts[0] ?? withoutFileComment;
+	return titlePart
+		.replace(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s]+/u, "")
+		.replace(/^[^:]{1,32}:\s*/i, "")
+		.trim();
+}
+
+export function parseIndexFile(directory: string, content: string): IndexEntry[] {
+	const entries: IndexEntry[] = [];
+	for (const line of content.split("\n")) {
+		const match = line.match(/<!--\s*file:([^>]+?)\s*-->/i);
+		if (!match) continue;
+		const filename = match[1].trim();
+		if (!filename || filename.includes("/") || filename.includes("..")) continue;
+		entries.push({ directory, filename, title: titleFromIndexLine(line), line: line.trim() });
+	}
+	return entries;
+}
+
+function scoreIndexEntry(entry: IndexEntry, query: string): number {
+	const normalizedQuery = normalizeLookupText(query);
+	if (!normalizedQuery) return 0;
+	const normalizedTitle = normalizeLookupText(entry.title);
+	const normalizedFilename = normalizeLookupText(entry.filename);
+	const normalizedLine = normalizeLookupText(entry.line);
+	const haystack = `${normalizedTitle} ${normalizedFilename} ${normalizedLine}`;
+	if (normalizedTitle === normalizedQuery || normalizedFilename === normalizedQuery) return 100;
+	if (normalizedTitle.includes(normalizedQuery) || normalizedFilename.includes(normalizedQuery)) return 80;
+	const tokens = normalizedQuery.split(" ").filter(Boolean);
+	if (tokens.length === 0) return 0;
+	const hits = tokens.filter(token => haystack.includes(token)).length;
+	if (hits === 0) return 0;
+	return hits / tokens.length;
+}
+
+function formatIndexCandidates(directory: string, entries: IndexEntry[], heading: string): string {
+	const lines = [heading, "", ...entries.map(e => `- ${directory}/${e.filename} — ${e.title || e.filename}`)];
+	return lines.join("\n");
+}
+
+function listSiblingIndexedDirectories(config: MemoryConfig, directory: string): string[] {
+	const parent = path.dirname(directory);
+	try {
+		const parentPath = path.join(config.memoryDir, parent);
+		return fs.readdirSync(parentPath)
+			.map(name => parent === "." ? name : `${parent}/${name}`)
+			.filter(candidate => {
+				try { return fs.statSync(path.join(config.memoryDir, candidate)).isDirectory(); } catch { return false; }
+			})
+			.filter(candidate => readFileSafe(path.join(config.memoryDir, candidate, "INDEX.md")))
+			.sort()
+			.reverse()
+			.slice(0, 10);
+	} catch {
+		return [];
+	}
+}
+
+export function resolveIndexedFile(config: MemoryConfig, directory: string, query: string): MemoryReadResult {
+	const indexPath = path.join(config.memoryDir, directory, "INDEX.md");
+	const indexContent = readFileSafe(indexPath);
+	if (!indexContent) {
+		const alternatives = listSiblingIndexedDirectories(config, directory);
+		const suffix = alternatives.length > 0 ? ` Indexed directories nearby: ${alternatives.map(d => `${d}/`).join(", ")}` : "";
+		return { text: `No INDEX.md for ${directory}.${suffix}`, details: { directory, found: false, reason: "missing_index" } };
+	}
+
+	const entries = parseIndexFile(directory, indexContent);
+	if (entries.length === 0) {
+		return { text: `No indexed entries found in ${directory}/INDEX.md.`, details: { directory, found: false, reason: "empty_index" } };
+	}
+
+	const scored = entries
+		.map(entry => ({ entry, score: scoreIndexEntry(entry, query) }))
+		.filter(item => item.score > 0)
+		.sort((a, b) => b.score - a.score || a.entry.filename.localeCompare(b.entry.filename));
+
+	if (scored.length === 0) {
+		return {
+			text: formatIndexCandidates(directory, entries, `No indexed entry matched "${query}" in ${directory}/INDEX.md. Candidates:`),
+			details: { directory, query, found: false, reason: "no_match", candidates: entries.map(e => e.filename) },
+		};
+	}
+
+	const topScore = scored[0].score;
+	const top = scored.filter(item => item.score === topScore).map(item => item.entry);
+	const queryTokens = normalizeLookupText(query).split(" ").filter(Boolean);
+	if (top.length > 1 || (queryTokens.length === 1 && scored.length > 1 && topScore < 100)) {
+		const candidates = scored.slice(0, 10).map(item => item.entry);
+		return {
+			text: formatIndexCandidates(directory, candidates, `Multiple indexed entries matched "${query}". Use one of these exact paths:`),
+			details: { directory, query, found: false, reason: "ambiguous", candidates: candidates.map(e => e.filename) },
+		};
+	}
+
+	const match = scored[0].entry;
+	const filePath = path.join(config.memoryDir, directory, match.filename);
+	const content = readFileSafe(filePath);
+	if (!content) {
+		return {
+			text: `INDEX.md points to missing file: ${directory}/${match.filename}`,
+			details: { directory, query, found: false, reason: "missing_resolved_file", filename: match.filename, path: filePath },
+		};
+	}
+	return { text: content, details: { path: filePath, filename: `${directory}/${match.filename}`, resolvedFrom: query, title: match.title } };
+}
+
+export function readMemoryFile(config: MemoryConfig, filename: string): MemoryReadResult {
+	const result = safeResolvePath(config.memoryDir, filename);
+	if (!result) {
+		return { text: `Invalid path: ${filename}`, details: { found: false, reason: "invalid_path" } };
+	}
+	const content = readFileSafe(result.resolved);
+	if (content) {
+		return { text: content, details: { path: result.resolved, filename: result.normalized } };
+	}
+
+	const directory = path.dirname(result.normalized);
+	const basename = path.basename(result.normalized).replace(/\.md$/i, "");
+	if (directory && directory !== "." && basename !== "INDEX") {
+		return resolveIndexedFile(config, directory, basename);
+	}
+
+	return { text: `File not found: ${result.normalized}`, details: { found: false, reason: "missing_file", filename: result.normalized } };
+}
+
 export function ensureDirs(config: MemoryConfig): void {
 	fs.mkdirSync(config.memoryDir, { recursive: true });
 	fs.mkdirSync(config.dailyDir, { recursive: true });
@@ -121,6 +373,39 @@ export function serializeScratchpad(items: ScratchpadItem[]): string {
 	return lines.join("\n") + "\n";
 }
 
+// --- Activity detection ---
+
+/** Minimum bytes in a daily log to count as "active" for that day. */
+const ACTIVITY_THRESHOLD_BYTES = 50;
+
+/** Number of trailing days to check for activity. */
+const ACTIVITY_LOOKBACK_DAYS = 3;
+
+/** Threshold: if fewer than this many of the lookback days have activity, user is "low activity". */
+const ACTIVITY_MIN_ACTIVE_DAYS = 1;
+
+/** Max catchup days to inject when in rollup mode. */
+const ROLLUP_CATCHUP_DAYS = 7;
+
+/** Normal catchup days (today + yesterday). */
+const NORMAL_CATCHUP_DAYS = 2;
+
+/**
+ * Detect low user activity by checking daily log sizes for the trailing N days.
+ * Returns true if the user has been inactive (daily logs mostly empty/missing).
+ */
+export function isLowActivity(config: MemoryConfig): boolean {
+	let activeDays = 0;
+	for (let i = 0; i < ACTIVITY_LOOKBACK_DAYS; i++) {
+		const date = daysAgoStr(i, config.timezone);
+		const content = readFileSafe(dailyPath(config.dailyDir, date));
+		if (content && content.trim().length >= ACTIVITY_THRESHOLD_BYTES) {
+			activeDays++;
+		}
+	}
+	return activeDays <= ACTIVITY_MIN_ACTIVE_DAYS;
+}
+
 // --- Memory context builder ---
 
 export function buildMemoryContext(config: MemoryConfig): string {
@@ -140,16 +425,8 @@ export function buildMemoryContext(config: MemoryConfig): string {
 		sections.push(`## MEMORY.md (long-term)\n\n${longTerm.trim()}`);
 	}
 
-	const scratchpad = readFileSafe(config.scratchpadFile);
-	if (scratchpad?.trim()) {
-		const openItems = parseScratchpad(scratchpad).filter((i) => !i.done);
-		if (openItems.length > 0) {
-			sections.push(`## SCRATCHPAD.md (working context)\n\n${serializeScratchpad(openItems)}`);
-		}
-	}
-
-	const today = todayStr();
-	const yesterday = yesterdayStr();
+	const today = todayStr(config.timezone);
+	const yesterday = yesterdayStr(config.timezone);
 
 	const todayContent = readFileSafe(dailyPath(config.dailyDir, today));
 	if (todayContent?.trim()) {
@@ -161,6 +438,62 @@ export function buildMemoryContext(config: MemoryConfig): string {
 		sections.push(`## Daily log: ${yesterday} (yesterday)\n\n${yesterdayContent.trim()}`);
 	}
 
+	// Auto-inject catchup INDEX.md — expand window when user has been inactive
+	const catchupDir = path.join(config.memoryDir, "catchup");
+	const lowActivity = isLowActivity(config);
+	const catchupDays = lowActivity ? ROLLUP_CATCHUP_DAYS : NORMAL_CATCHUP_DAYS;
+
+	// In rollup mode, use a smaller per-day cap to fit more days
+	const MAX_CATCHUP_BYTES_PER_DAY = lowActivity ? 1024 : 2048;
+	// Total catchup budget to prevent system prompt bloat
+	const MAX_CATCHUP_TOTAL_BYTES = 8192;
+	let catchupTotalBytes = 0;
+
+	// Collect catchup sections first, then prepend rollup header if any exist
+	const catchupSections: string[] = [];
+
+	for (let i = 0; i < catchupDays; i++) {
+		if (catchupTotalBytes >= MAX_CATCHUP_TOTAL_BYTES) break;
+		const date = daysAgoStr(i, config.timezone);
+		const label = i === 0 ? "today" : i === 1 ? "yesterday" : `${i} days ago`;
+		const indexPath = path.join(catchupDir, date, "INDEX.md");
+		let catchupContent = readFileSafe(indexPath)?.trim();
+		if (catchupContent) {
+			if (catchupContent.length > MAX_CATCHUP_BYTES_PER_DAY) {
+				const lines = catchupContent.split("\n");
+				let truncated = "";
+				let kept = 0;
+				for (const line of lines) {
+					if (truncated.length + line.length + 1 > MAX_CATCHUP_BYTES_PER_DAY) break;
+					truncated += (kept > 0 ? "\n" : "") + line;
+					kept++;
+				}
+				const remaining = lines.length - kept;
+				if (remaining > 0) {
+					truncated += `\n... (${remaining} more entries — use memory_read(target='file', filename='catchup/${date}/INDEX.md') to see all)`;
+				}
+				catchupContent = truncated;
+			}
+			const header = `## Catchup: ${date} (${label})`;
+			const hint = `_Read full details: memory_read(target='file', filename='catchup/${date}/FILENAME.md')_`;
+			catchupSections.push(`${header}\n${hint}\n\n${catchupContent}`);
+			catchupTotalBytes += catchupContent.length;
+		}
+	}
+
+	// Only inject rollup mode header if there's actually catchup data to show
+	if (lowActivity && catchupSections.length > 0) {
+		sections.push(
+			"## \u26a1 Rollup Mode\n" +
+			`_Low activity detected over the last ${ACTIVITY_LOOKBACK_DAYS} days. ` +
+			`Catchup window expanded from ${NORMAL_CATCHUP_DAYS} to ${catchupDays} days._`
+		);
+	}
+
+	for (const s of catchupSections) {
+		sections.push(s);
+	}
+
 	if (sections.length === 0) {
 		return "";
 	}
@@ -300,5 +633,26 @@ export function searchMemory(config: MemoryConfig, query: string, maxResults: nu
 	searchDir(config.dailyDir, "daily");
 	searchDir(config.notesDir, "notes");
 
+	// Search extra dirs configured via PI_SEARCH_DIRS
+	for (const dirName of config.searchDirs) {
+		if (lineResults.length >= maxResults) break;
+		const dirPath = path.join(config.memoryDir, dirName);
+		try {
+			const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+			// Search .md files directly in the dir
+			const mdFiles = entries.filter(e => e.isFile() && e.name.endsWith(".md"));
+			for (const f of mdFiles) {
+				if (lineResults.length >= maxResults) break;
+				searchFile(path.join(dirPath, f.name), `${dirName}/${f.name}`);
+			}
+			// Search one level of subdirectories (e.g. catchup/2026-04-20/*.md)
+			const subDirs = entries.filter(e => e.isDirectory());
+			for (const sub of subDirs) {
+				if (lineResults.length >= maxResults) break;
+				searchDir(path.join(dirPath, sub.name), `${dirName}/${sub.name}`);
+			}
+		} catch {}
+	}
+
 	return { fileMatches, lineResults };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askjo/pi-mem",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Pi coding agent extension for plain-Markdown memory system — long-term memory, daily logs, and scratchpad checklist",
   "main": "index.ts",
   "type": "module",
@@ -28,7 +28,9 @@
   },
   "homepage": "https://github.com/jo-inc/pi-mem#readme",
   "pi": {
-    "extensions": ["./index.ts"],
+    "extensions": [
+      "./index.ts"
+    ],
     "image": "https://raw.githubusercontent.com/jo-inc/pi-mem/main/logo.png"
   },
   "publishConfig": {

package/release.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+BUMP="${1:-patch}"
+if [[ "$BUMP" != "patch" && "$BUMP" != "minor" && "$BUMP" != "major" ]]; then
+  echo "Usage: ./release.sh [patch|minor|major]"
+  exit 1
+fi
+
+cd "$(dirname "$0")"
+
+echo "🔍 Pre-flight checks..."
+if [[ -n "$(git status --porcelain)" ]]; then
+  echo "❌ Working tree is dirty. Commit changes first."
+  exit 1
+fi
+if [[ "$(git branch --show-current)" != "main" ]]; then
+  echo "❌ Not on main."
+  exit 1
+fi
+git fetch origin main --quiet
+if [[ "$(git rev-parse HEAD)" != "$(git rev-parse origin/main)" ]]; then
+  echo "❌ Local main differs from origin/main."
+  exit 1
+fi
+
+echo "🧪 Running tests..."
+npm test
+
+echo "📦 Bumping version: $BUMP"
+npm version "$BUMP" --message "v%s"
+NEW_VERSION=$(node -p "require('./package.json').version")
+
+echo "📤 Pushing main and v${NEW_VERSION} tag..."
+git push origin main --follow-tags
+
+echo "✅ Release v${NEW_VERSION} triggered"
+echo "   Actions: https://github.com/jo-inc/pi-mem/actions"
+echo "   Package: https://www.npmjs.com/package/@askjo/pi-mem"

package/tests/config.test.ts

@@ -1,7 +1,8 @@
 import { describe, it } from "node:test";
 import assert from "node:assert";
 import * as path from "node:path";
-import { buildConfig } from "../lib.ts";
+import { buildConfig, resolveAgentDir, resolveHomeDir, resolveSessionsDir } from "../lib.ts";
+import { makeTempDir, cleanup, writeFile } from "./helpers.ts";
 
 describe("buildConfig", () => {
 	it("uses defaults when no env vars set", () => {
@@ -13,6 +14,7 @@ describe("buildConfig", () => {
 		assert.strictEqual(config.notesDir, "/home/testuser/.pi/agent/memory/notes");
 		assert.deepStrictEqual(config.contextFiles, []);
 		assert.strictEqual(config.autocommit, false);
+		assert.strictEqual(config.timezone, "UTC");
 	});
 
 	it("respects PI_MEMORY_DIR override", () => {
@@ -64,8 +66,109 @@ describe("buildConfig", () => {
 		assert.strictEqual(config.autocommit, false);
 	});
 
-	it("falls back to ~ when HOME is undefined", () => {
-		const config = buildConfig({});
-		assert.strictEqual(config.memoryDir, "~/.pi/agent/memory");
+	it("parses PI_SEARCH_DIRS as comma-separated list", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_SEARCH_DIRS: "catchup, projects" });
+		assert.deepStrictEqual(config.searchDirs, ["catchup", "projects"]);
+	});
+
+	it("uses PI_TIMEZONE before TZ", () => {
+		const config = buildConfig({ HOME: "/home/x", TZ: "UTC", PI_TIMEZONE: "America/Los_Angeles" });
+		assert.strictEqual(config.timezone, "America/Los_Angeles");
+	});
+
+	it("falls back to TZ for timezone", () => {
+		const config = buildConfig({ HOME: "/home/x", TZ: "America/New_York" });
+		assert.strictEqual(config.timezone, "America/New_York");
+	});
+
+	it("falls back to UTC for invalid timezone", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_TIMEZONE: "not/a-zone", TZ: "also-bad" });
+		assert.strictEqual(config.timezone, "UTC");
+	});
+
+	it("defaults PI_SEARCH_DIRS to empty array", () => {
+		const config = buildConfig({ HOME: "/home/x" });
+		assert.deepStrictEqual(config.searchDirs, []);
+	});
+
+	it("handles PI_SEARCH_DIRS with extra whitespace and trailing comma", () => {
+		const config = buildConfig({ HOME: "/home/x", PI_SEARCH_DIRS: " catchup ,  projects , " });
+		assert.deepStrictEqual(config.searchDirs, ["catchup", "projects"]);
+	});
+
+	it("reads .pi-mem.json from memory dir", () => {
+		const memDir = makeTempDir();
+		writeFile(path.join(memDir, ".pi-mem.json"), JSON.stringify({
+			searchDirs: ["catchup", "projects"],
+			contextFiles: ["SOUL.md"],
+			autocommit: true,
+		}));
+		const config = buildConfig({ HOME: "/home/x", PI_MEMORY_DIR: memDir });
+		assert.deepStrictEqual(config.searchDirs, ["catchup", "projects"]);
+		assert.deepStrictEqual(config.contextFiles, ["SOUL.md"]);
+		assert.strictEqual(config.autocommit, true);
+		cleanup(memDir);
+	});
+
+	it("env vars override .pi-mem.json values", () => {
+		const memDir = makeTempDir();
+		writeFile(path.join(memDir, ".pi-mem.json"), JSON.stringify({
+			searchDirs: ["catchup"],
+			contextFiles: ["SOUL.md"],
+			autocommit: true,
+		}));
+		const config = buildConfig({
+			HOME: "/home/x",
+			PI_MEMORY_DIR: memDir,
+			PI_SEARCH_DIRS: "projects,other",
+			PI_CONTEXT_FILES: "AGENTS.md",
+			PI_AUTOCOMMIT: "0",
+		});
+		assert.deepStrictEqual(config.searchDirs, ["projects", "other"]);
+		assert.deepStrictEqual(config.contextFiles, ["AGENTS.md"]);
+		assert.strictEqual(config.autocommit, false);
+		cleanup(memDir);
+	});
+
+	it("ignores malformed .pi-mem.json", () => {
+		const memDir = makeTempDir();
+		writeFile(path.join(memDir, ".pi-mem.json"), "not json{{");
+		const config = buildConfig({ HOME: "/home/x", PI_MEMORY_DIR: memDir });
+		assert.deepStrictEqual(config.searchDirs, []);
+		assert.deepStrictEqual(config.contextFiles, []);
+		cleanup(memDir);
+	});
+
+	it("ignores .pi-mem.json with wrong types", () => {
+		const memDir = makeTempDir();
+		writeFile(path.join(memDir, ".pi-mem.json"), JSON.stringify({
+			searchDirs: "not-an-array",
+			contextFiles: 42,
+			autocommit: "yes",
+		}));
+		const config = buildConfig({ HOME: "/home/x", PI_MEMORY_DIR: memDir });
+		assert.deepStrictEqual(config.searchDirs, []);
+		assert.deepStrictEqual(config.contextFiles, []);
+		assert.strictEqual(config.autocommit, false);
+		cleanup(memDir);
+	});
+
+	it("uses the supplied platform fallback when home variables are absent", () => {
+		assert.strictEqual(resolveHomeDir({}, "/fallback/home"), "/fallback/home");
+		assert.strictEqual(resolveAgentDir({}, "/fallback/home"), "/fallback/home/.pi/agent");
+	});
+
+	it("supports Windows USERPROFILE", () => {
+		assert.strictEqual(resolveHomeDir({ USERPROFILE: "C:\\Users\\test" }, "/fallback"), "C:\\Users\\test");
+	});
+
+	it("supports Windows HOMEDRIVE and HOMEPATH", () => {
+		assert.strictEqual(resolveHomeDir({ HOMEDRIVE: "C:", HOMEPATH: "\\Users\\test" }, "/fallback"), "C:\\Users\\test");
+	});
+
+	it("respects PI_CODING_AGENT_DIR for memory and sessions", () => {
+		const env = { HOME: "/home/x", PI_CODING_AGENT_DIR: "/custom/agent" };
+		assert.strictEqual(buildConfig(env).memoryDir, "/custom/agent/memory");
+		assert.strictEqual(resolveSessionsDir(env), "/custom/agent/sessions");
 	});
 });

package/tests/date-helpers.test.ts

@@ -8,10 +8,16 @@ describe("todayStr", () => {
 		assert.match(result, /^\d{4}-\d{2}-\d{2}$/);
 	});
 
-	it("matches current date", () => {
+	it("matches current UTC date by default", () => {
 		const expected = new Date().toISOString().slice(0, 10);
 		assert.strictEqual(todayStr(), expected);
 	});
+
+	it("uses the requested timezone", () => {
+		const now = new Date("2026-06-09T03:30:00.000Z");
+		assert.strictEqual(todayStr("UTC", now), "2026-06-09");
+		assert.strictEqual(todayStr("America/Los_Angeles", now), "2026-06-08");
+	});
 });
 
 describe("yesterdayStr", () => {
@@ -26,6 +32,12 @@ describe("yesterdayStr", () => {
 		const diffMs = today.getTime() - yesterday.getTime();
 		assert.strictEqual(diffMs, 24 * 60 * 60 * 1000);
 	});
+
+	it("uses the requested timezone", () => {
+		const now = new Date("2026-06-09T03:30:00.000Z");
+		assert.strictEqual(yesterdayStr("UTC", now), "2026-06-08");
+		assert.strictEqual(yesterdayStr("America/Los_Angeles", now), "2026-06-07");
+	});
 });
 
 describe("nowTimestamp", () => {