@lebronj/pi-suite 0.1.0

package/vendor/pi-memory/src/service-controller.ts

@@ -0,0 +1,248 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export type CuratorServiceBackend = "systemd-user" | "cron" | "none";
+
+export type CuratorServiceState = {
+	enabled: boolean;
+	backend: CuratorServiceBackend;
+	schedule: string;
+	serviceName: string;
+	memoryDir: string;
+	cliPath: string;
+	installedAt?: string;
+	disabledAt?: string;
+	lastError?: string;
+};
+
+export type CuratorServiceResult = {
+	ok: boolean;
+	backend: CuratorServiceBackend;
+	message: string;
+	state: CuratorServiceState;
+};
+
+const SERVICE_NAME = "jhp-pi-memory-curator";
+const DEFAULT_SCHEDULE = "03:00";
+const CRON_MARKER = "# jhp-pi-memory-curator";
+
+function resolveHome(): string {
+	return process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+}
+
+export function resolveMemoryDir(env: NodeJS.ProcessEnv = process.env): string {
+	if (env.PI_MEMORY_DIR) return env.PI_MEMORY_DIR;
+	return join(resolveHome(), ".pi", "agent", "memory");
+}
+
+function statePath(memoryDir: string): string {
+	return join(memoryDir, ".curator-service.json");
+}
+
+function systemdUserDir(): string {
+	return join(resolveHome(), ".config", "systemd", "user");
+}
+
+function servicePath(): string {
+	return join(systemdUserDir(), `${SERVICE_NAME}.service`);
+}
+
+function timerPath(): string {
+	return join(systemdUserDir(), `${SERVICE_NAME}.timer`);
+}
+
+function defaultState(memoryDir: string, cliPath: string): CuratorServiceState {
+	return {
+		enabled: false,
+		backend: "none",
+		schedule: DEFAULT_SCHEDULE,
+		serviceName: SERVICE_NAME,
+		memoryDir,
+		cliPath,
+	};
+}
+
+function readState(memoryDir: string, cliPath: string): CuratorServiceState {
+	const path = statePath(memoryDir);
+	if (!existsSync(path)) return defaultState(memoryDir, cliPath);
+	try {
+		return { ...defaultState(memoryDir, cliPath), ...(JSON.parse(readFileSync(path, "utf-8")) as Partial<CuratorServiceState>) };
+	} catch {
+		return defaultState(memoryDir, cliPath);
+	}
+}
+
+function writeState(state: CuratorServiceState): void {
+	mkdirSync(dirname(statePath(state.memoryDir)), { recursive: true });
+	writeFileSync(statePath(state.memoryDir), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+}
+
+function hasCommand(command: string): boolean {
+	return spawnSync(command, ["--version"], { stdio: "ignore" }).status === 0;
+}
+
+function canUseSystemdUser(): boolean {
+	if (!hasCommand("systemctl")) return false;
+	const result = spawnSync("systemctl", ["--user", "show-environment"], { stdio: "ignore" });
+	return result.status === 0;
+}
+
+function shellQuote(value: string): string {
+	return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+function parseSchedule(schedule: string): { hour: string; minute: string } {
+	const match = /^(\d{1,2}):(\d{2})$/.exec(schedule);
+	if (!match) throw new Error(`Invalid schedule '${schedule}'. Expected HH:MM.`);
+	const hour = Number(match[1]);
+	const minute = Number(match[2]);
+	if (hour < 0 || hour > 23 || minute < 0 || minute > 59) throw new Error(`Invalid schedule '${schedule}'. Expected HH:MM.`);
+	return { hour: String(hour), minute: String(minute) };
+}
+
+function systemdCalendar(schedule: string): string {
+	const { hour, minute } = parseSchedule(schedule);
+	return `*-*-* ${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
+}
+
+function writeSystemdUnits(memoryDir: string, cliPath: string, schedule: string): void {
+	mkdirSync(systemdUserDir(), { recursive: true });
+	const execStart = `${process.execPath} ${cliPath} run-once --memory-dir ${memoryDir} --reason systemd-timer`;
+	writeFileSync(
+		servicePath(),
+		[
+			"[Unit]",
+			"Description=JHP pi memory curator",
+			"",
+			"[Service]",
+			"Type=oneshot",
+			`ExecStart=${execStart}`,
+			"",
+		].join("\n"),
+		"utf-8",
+	);
+	writeFileSync(
+		timerPath(),
+		[
+			"[Unit]",
+			"Description=Run JHP pi memory curator daily",
+			"",
+			"[Timer]",
+			`OnCalendar=${systemdCalendar(schedule)}`,
+			"Persistent=true",
+			"Unit=jhp-pi-memory-curator.service",
+			"",
+			"[Install]",
+			"WantedBy=timers.target",
+			"",
+		].join("\n"),
+		"utf-8",
+	);
+}
+
+function enableSystemd(memoryDir: string, cliPath: string, schedule: string): void {
+	writeSystemdUnits(memoryDir, cliPath, schedule);
+	execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+	execFileSync("systemctl", ["--user", "enable", "--now", `${SERVICE_NAME}.timer`], { stdio: "ignore" });
+}
+
+function disableSystemd(): void {
+	if (!hasCommand("systemctl")) return;
+	spawnSync("systemctl", ["--user", "disable", "--now", `${SERVICE_NAME}.timer`], { stdio: "ignore" });
+	for (const path of [servicePath(), timerPath()]) {
+		try {
+			if (existsSync(path)) unlinkSync(path);
+		} catch {
+			// best effort cleanup
+		}
+	}
+	spawnSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
+}
+
+function currentCrontab(): string {
+	const result = spawnSync("crontab", ["-l"], { encoding: "utf-8" });
+	if (result.status !== 0) return "";
+	return result.stdout;
+}
+
+function installCrontab(content: string): void {
+	const result = spawnSync("crontab", ["-"], { input: content, encoding: "utf-8" });
+	if (result.status !== 0) throw new Error(result.stderr || "failed to install crontab");
+}
+
+function removeCronLine(): void {
+	if (!hasCommand("crontab")) return;
+	const existing = currentCrontab();
+	const next = existing
+		.split(/\r?\n/)
+		.filter((line) => !line.includes(CRON_MARKER))
+		.join("\n")
+		.trim();
+	installCrontab(next ? `${next}\n` : "");
+}
+
+function enableCron(memoryDir: string, cliPath: string, schedule: string): void {
+	if (!hasCommand("crontab")) throw new Error("Neither systemd user timers nor crontab are available.");
+	const { hour, minute } = parseSchedule(schedule);
+	removeCronLine();
+	const command = `${shellQuote(process.execPath)} ${shellQuote(cliPath)} run-once --memory-dir ${shellQuote(memoryDir)} --reason cron ${CRON_MARKER}`;
+	const existing = currentCrontab().trim();
+	const next = `${existing ? `${existing}\n` : ""}${minute} ${hour} * * * ${command}\n`;
+	installCrontab(next);
+}
+
+export function enableCuratorService(options: { memoryDir?: string; cliPath: string; schedule?: string }): CuratorServiceResult {
+	const memoryDir = options.memoryDir || resolveMemoryDir();
+	const schedule = options.schedule || DEFAULT_SCHEDULE;
+	const baseState = { ...defaultState(memoryDir, options.cliPath), schedule };
+	try {
+		if (canUseSystemdUser()) {
+			enableSystemd(memoryDir, options.cliPath, schedule);
+			const state: CuratorServiceState = { ...baseState, enabled: true, backend: "systemd-user", installedAt: new Date().toISOString() };
+			writeState(state);
+			return { ok: true, backend: "systemd-user", message: "Enabled systemd user timer for daily 03:00 memory curation.", state };
+		}
+		enableCron(memoryDir, options.cliPath, schedule);
+		const state: CuratorServiceState = { ...baseState, enabled: true, backend: "cron", installedAt: new Date().toISOString() };
+		writeState(state);
+		return { ok: true, backend: "cron", message: "Enabled cron job for daily memory curation.", state };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const state: CuratorServiceState = { ...baseState, enabled: false, backend: "none", lastError: message };
+		writeState(state);
+		return { ok: false, backend: "none", message, state };
+	}
+}
+
+export function disableCuratorService(options: { memoryDir?: string; cliPath: string }): CuratorServiceResult {
+	const memoryDir = options.memoryDir || resolveMemoryDir();
+	const previous = readState(memoryDir, options.cliPath);
+	disableSystemd();
+	try {
+		removeCronLine();
+	} catch {
+		// best effort cleanup
+	}
+	const state: CuratorServiceState = { ...previous, enabled: false, backend: "none", disabledAt: new Date().toISOString() };
+	writeState(state);
+	return { ok: true, backend: previous.backend, message: "Disabled memory curator service.", state };
+}
+
+export function getCuratorServiceStatus(options: { memoryDir?: string; cliPath: string }): CuratorServiceResult {
+	const memoryDir = options.memoryDir || resolveMemoryDir();
+	const state = readState(memoryDir, options.cliPath);
+	const parts = [
+		`Memory curator service: ${state.enabled ? "enabled" : "disabled"}`,
+		`Backend: ${state.backend}`,
+		`Schedule: ${state.schedule}`,
+		`Memory dir: ${state.memoryDir}`,
+	];
+	if (state.lastError) parts.push(`Last error: ${state.lastError}`);
+	if (state.backend === "systemd-user" && hasCommand("systemctl")) {
+		const active = spawnSync("systemctl", ["--user", "is-active", `${SERVICE_NAME}.timer`], { encoding: "utf-8" });
+		parts.push(`systemd timer active: ${active.stdout.trim() || "unknown"}`);
+	}
+	return { ok: true, backend: state.backend, message: parts.join("\n"), state };
+}

package/vendor/pi-memory/test/curate.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { FileMemoryStore, JsonlAuditLog, runMemoryCuratorOnce } from "../src/index.ts";
+
+test("curates entries, deduplicates exact duplicates, and writes audit", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-curator-"));
+	const store = new FileMemoryStore(dir);
+	await store.writeEntries("state", [
+		"[type:event status:planned date:2026-06-06]\nUser plans to watch NBA.",
+		"[type:event status:planned date:2026-06-06]\nUser plans to watch NBA.",
+		"Plain note for 2026-06-06.",
+	]);
+
+	const result = await runMemoryCuratorOnce({
+		memoryStore: store,
+		auditLog: new JsonlAuditLog(dir),
+		now: () => new Date("2026-06-08T03:00:00.000Z"),
+	});
+
+	assert.equal(result.changed, 2);
+	assert.deepEqual(await store.readEntries("state"), [
+		"[type:event status:past date:2026-06-06]\nUser had planned to watch NBA. Completion status unknown.",
+		"Plain note for 2026-06-06.",
+	]);
+	assert.equal(existsSync(join(dir, "audit", "curator.jsonl")), true);
+	const auditLines = readFileSync(join(dir, "audit", "curator.jsonl"), "utf-8").trim().split("\n");
+	assert.equal(auditLines.length, 2);
+});
+
+test("dry run returns deterministic patches without writing", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-curator-"));
+	const store = new FileMemoryStore(dir);
+	const raw = "[type:event status:planned date:2026-06-06]\nUser plans to watch NBA.";
+	await store.writeEntries("state", [raw]);
+
+	const result = await runMemoryCuratorOnce({
+		memoryStore: store,
+		now: () => new Date("2026-06-08T03:00:00.000Z"),
+		dryRun: true,
+	});
+
+	assert.equal(result.patches.length, 1);
+	assert.deepEqual(await store.readEntries("state"), [raw]);
+});
+
+test("no-op curator scan does not rewrite memory or review files", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-curator-"));
+	const store = new FileMemoryStore(dir);
+	await store.writeEntries("memory", ["[type:fact]\nStable fact."]);
+	await store.writeEntries("review", ["[type:review status:candidate id:rev_test kind:preference confidence:medium seen:1 first_seen:2026-06-08 last_seen:2026-06-08]\nSignature: User prefers concise answers."]);
+	const memoryPath = join(dir, "MEMORY.md");
+	const reviewPath = join(dir, "REVIEW.md");
+	const beforeMemory = statSync(memoryPath).mtimeMs;
+	const beforeReview = statSync(reviewPath).mtimeMs;
+
+	const result = await runMemoryCuratorOnce({
+		memoryStore: store,
+		now: () => new Date("2026-06-08T03:00:00.000Z"),
+	});
+
+	assert.equal(result.patches.length, 0);
+	assert.equal(statSync(memoryPath).mtimeMs, beforeMemory);
+	assert.equal(statSync(reviewPath).mtimeMs, beforeReview);
+	assert.equal(existsSync(join(dir, "audit", "curator.jsonl")), false);
+});

package/vendor/pi-memory/test/learning-candidates.test.ts

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import {
+	FileMemoryStore,
+	createReviewCandidateId,
+	parseReviewCandidate,
+	renderReviewCandidate,
+	upsertReviewCandidate,
+	validateReviewCandidateInput,
+} from "../src/index.ts";
+
+test("renders and parses review candidate metadata", () => {
+	const entry = renderReviewCandidate(
+		{
+			kind: "bug_fix",
+			confidence: "high",
+			signature: "npm run check failed on stale metadata order",
+			summary: "Keep review metadata stable.",
+			targetHints: ["memory", "skill"],
+		},
+		new Date("2026-06-10T00:00:00.000Z"),
+	);
+
+	const candidate = parseReviewCandidate(entry);
+	assert.ok(candidate);
+	assert.equal(candidate.id, createReviewCandidateId("bug_fix", "npm run check failed on stale metadata order"));
+	assert.equal(candidate.kind, "bug_fix");
+	assert.equal(candidate.confidence, "high");
+	assert.equal(candidate.seen, 1);
+	assert.match(entry, /target_hints:memory,skill/);
+	assert.match(entry, /Signature: npm run check failed on stale metadata order/);
+});
+
+test("rejects invalid target hints", () => {
+	assert.deepEqual(
+		validateReviewCandidateInput({
+			kind: "skill_candidate",
+			confidence: "medium",
+			signature: "Reusable flow",
+			targetHints: ["workflow" as "memory"],
+		}),
+		["invalid target hint 'workflow'"],
+	);
+});
+
+test("upserts duplicate candidates by normalized signature", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-learning-"));
+	const store = new FileMemoryStore(dir);
+
+	const first = await upsertReviewCandidate(
+		store,
+		{
+			kind: "bug_fix",
+			confidence: "medium",
+			signature: "NPM run check failed: stale metadata order.",
+			evidence: "first failure",
+		},
+		new Date("2026-06-10T00:00:00.000Z"),
+	);
+	const second = await upsertReviewCandidate(
+		store,
+		{
+			kind: "bug_fix",
+			confidence: "high",
+			signature: "npm run check failed stale metadata order",
+			evidence: "second validation",
+		},
+		new Date("2026-06-11T00:00:00.000Z"),
+	);
+
+	const entries = await store.readEntries("review");
+	assert.equal(first.merged, false);
+	assert.equal(second.merged, true);
+	assert.equal(entries.length, 1);
+	const candidate = parseReviewCandidate(entries[0]);
+	assert.ok(candidate);
+	assert.equal(candidate.id, first.id);
+	assert.equal(candidate.seen, 2);
+	assert.equal(candidate.confidence, "high");
+	assert.equal(candidate.lastSeen, "2026-06-11");
+	assert.match(entries[0], /Evidence: first failure/);
+	assert.match(entries[0], /Evidence: second validation/);
+});
+
+test("does not merge unrelated candidates or malformed review entries", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-learning-"));
+	const store = new FileMemoryStore(dir);
+	await store.writeEntries("review", ["[type:review status:candidate]\nSignature: malformed"]);
+
+	await upsertReviewCandidate(store, {
+		kind: "preference",
+		confidence: "medium",
+		signature: "User prefers concise answers",
+	});
+	await upsertReviewCandidate(store, {
+		kind: "project_fact",
+		confidence: "medium",
+		signature: "Project stores specs under .pi/docs",
+	});
+
+	const entries = await store.readEntries("review");
+	assert.equal(entries.length, 3);
+	assert.equal(entries[0], "[type:review status:candidate]\nSignature: malformed");
+});

package/vendor/pi-memory/test/memory-promotions.test.ts

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import {
+	FileMemoryStore,
+	applyReviewLifecycle,
+	approveMemoryPromotion,
+	proposeMemoryPromotions,
+	rejectReviewItem,
+	upsertReviewCandidate,
+} from "../src/index.ts";
+
+test("proposes and approves memory promotion from repeated preference", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-promotions-"));
+	const store = new FileMemoryStore(dir);
+	await upsertReviewCandidate(store, { kind: "preference", confidence: "medium", signature: "User prefers direct answers", summary: "User prefers concise direct answers.", targetHints: ["memory"] });
+	await upsertReviewCandidate(store, { kind: "preference", confidence: "medium", signature: "User prefers direct answers", summary: "User prefers concise direct answers.", targetHints: ["memory"] });
+
+	const proposed = await proposeMemoryPromotions(store);
+	assert.equal(proposed.created, 1);
+	const approved = await approveMemoryPromotion(store, proposed.proposalIds[0]);
+	assert.equal(approved.target, "user");
+	assert.deepEqual(await store.readEntries("user"), ["[type:preference]\nUser prefers concise direct answers."]);
+	assert.match((await store.readEntries("review")).join("\n"), /status:approved/);
+});
+
+test("review lifecycle marks stale low-confidence candidates and reject preserves entries", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-promotions-"));
+	const store = new FileMemoryStore(dir);
+	await upsertReviewCandidate(store, { kind: "project_fact", confidence: "low", signature: "Old uncertain fact", date: "2026-01-01" });
+	const id = (await store.readEntries("review"))[0].match(/id:([^\s]+)/)?.[1];
+	assert.ok(id);
+
+	const lifecycle = await applyReviewLifecycle(store, new Date("2026-05-01T00:00:00.000Z"));
+	assert.equal(lifecycle.changed, 1);
+	assert.match((await store.readEntries("review")).join("\n"), /status:archived/);
+
+	await rejectReviewItem(store, id, "rejected");
+	const review = await store.readEntries("review");
+	assert.equal(review.length, 1);
+	assert.match(review[0], /status:rejected/);
+});

package/vendor/pi-memory/test/metadata.test.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { parseEntry, parseMetadata, renderEntry } from "../src/index.ts";
+
+test("parses metadata", () => {
+	assert.deepEqual(parseMetadata("[type:event status:planned date:2026-06-06]"), {
+		type: "event",
+		status: "planned",
+		date: "2026-06-06",
+	});
+});
+
+test("leaves malformed metadata as plain body", () => {
+	const entry = parseEntry("[type:event status:planned\nUser plans to watch NBA.");
+	assert.equal(entry.hasMetadata, false);
+	assert.equal(renderEntry(entry), "[type:event status:planned\nUser plans to watch NBA.");
+});

package/vendor/pi-memory/test/skill-drafts.test.ts

@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { FileMemoryStore, approveSkillDraft, listSkillDraftProposals, proposeSkillDrafts, upsertReviewCandidate } from "../src/index.ts";
+
+test("proposes skill draft from repeated skill candidate", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-skills-"));
+	const store = new FileMemoryStore(join(dir, "memory"));
+	const draftsDir = join(dir, "skill-drafts");
+	for (const evidence of ["first pass", "second pass", "third pass"]) {
+		await upsertReviewCandidate(store, {
+			kind: "skill_candidate",
+			confidence: "medium",
+			signature: "fix non erasable TypeScript syntax in pi source",
+			summary: "Replace enum and parameter properties with erasable syntax.",
+			targetHints: ["skill"],
+			evidence,
+		});
+	}
+
+	const result = await proposeSkillDrafts(store, { draftsDir });
+	assert.equal(result.created, 1);
+	assert.equal(result.proposals[0].id.startsWith("skill_"), true);
+	assert.match(result.proposals[0].promotesTo, /skill-drafts/);
+	const review = await store.readEntries("review");
+	assert.equal(review.filter((entry) => entry.includes("kind:skill_promotion")).length, 1);
+
+	const second = await proposeSkillDrafts(store, { draftsDir });
+	assert.equal(second.created, 0);
+});
+
+test("approves skill proposal into disabled draft and marks proposal approved", async () => {
+	const dir = mkdtempSync(join(tmpdir(), "pi-memory-skills-"));
+	const store = new FileMemoryStore(join(dir, "memory"));
+	const draftsDir = join(dir, "skill-drafts");
+	for (const evidence of ["first pass", "second pass", "third pass"]) {
+		await upsertReviewCandidate(store, {
+			kind: "skill_candidate",
+			confidence: "medium",
+			signature: "fix non erasable TypeScript syntax in pi source",
+			summary: "Replace enum and parameter properties with erasable syntax.",
+			targetHints: ["skill"],
+			evidence,
+		});
+	}
+	const proposed = await proposeSkillDrafts(store, { draftsDir });
+
+	const approved = await approveSkillDraft(store, proposed.proposals[0].id);
+	assert.equal(existsSync(approved.path), true);
+	assert.match(readFileSync(approved.path, "utf-8"), /description: Use when fix non erasable typescript syntax in pi source\./);
+	const proposals = await listSkillDraftProposals(store);
+	assert.equal(proposals.length, 1);
+	const review = await store.readEntries("review");
+	assert.match(review.join("\n"), /status:approved/);
+});

package/vendor/pi-memory/test/transition-handoff.test.ts

@@ -0,0 +1,86 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+	buildTransitionHandoff,
+	getMemoryLearningMode,
+	getMemorySkillDraftsMode,
+	parseLearningExtractorResponse,
+	shouldSkipExitSummaryForReason,
+	shouldWriteTransitionHandoffForReason,
+} from "../index.ts";
+
+function message(role: "user" | "assistant", text: string) {
+	return {
+		type: "message" as const,
+		message: {
+			role,
+			content: [{ type: "text" as const, text }],
+			timestamp: 0,
+		},
+	};
+}
+
+function ctx(branch: ReturnType<typeof message>[]) {
+	return {
+		sessionManager: {
+			getBranch: () => branch,
+		},
+	} as any;
+}
+
+test("writes lightweight handoffs only for new and fork transitions", () => {
+	assert.equal(shouldSkipExitSummaryForReason("reload"), true);
+	assert.equal(shouldSkipExitSummaryForReason("resume"), true);
+	assert.equal(shouldSkipExitSummaryForReason("new"), true);
+	assert.equal(shouldSkipExitSummaryForReason("fork"), true);
+
+	assert.equal(shouldWriteTransitionHandoffForReason("reload"), false);
+	assert.equal(shouldWriteTransitionHandoffForReason("resume"), false);
+	assert.equal(shouldWriteTransitionHandoffForReason("new"), true);
+	assert.equal(shouldWriteTransitionHandoffForReason("fork"), true);
+});
+
+test("memory learning defaults to review mode", () => {
+	assert.equal(getMemoryLearningMode({}), "review");
+	assert.equal(getMemoryLearningMode({ PI_MEMORY_LEARNING: "off" }), "off");
+	assert.equal(getMemoryLearningMode({ PI_MEMORY_LEARNING: "auto-review" }), "auto-review");
+	assert.equal(getMemorySkillDraftsMode({}), "review");
+	assert.equal(getMemorySkillDraftsMode({ PI_MEMORY_SKILL_DRAFTS: "off" }), "off");
+});
+
+test("learning extractor response accepts only valid review candidates", () => {
+	const candidates = parseLearningExtractorResponse(JSON.stringify({
+		candidates: [
+			{ kind: "preference", confidence: "medium", signature: "User prefers concise answers", targetHints: ["memory", "workflow"] },
+			{ kind: "workflow", confidence: "high", signature: "workflow artifact" },
+			{ kind: "project_fact", confidence: "low", signature: "low confidence fact" },
+		],
+	}));
+
+	assert.deepEqual(candidates, [{
+		kind: "preference",
+		confidence: "medium",
+		signature: "User prefers concise answers",
+		summary: undefined,
+		targetHints: ["memory"],
+		evidence: undefined,
+		source: "session_shutdown",
+	}]);
+});
+
+test("buildTransitionHandoff captures recent conversation without LLM summary", () => {
+	const handoff = buildTransitionHandoff(
+		ctx([
+			message("user", "Please investigate the memory shutdown behavior."),
+			message("assistant", "I found that /reload and /resume should stay silent."),
+		]),
+		"new",
+		"abcdef12",
+		"2026-06-10 02:00:00",
+	);
+
+	assert.ok(handoff);
+	assert.match(handoff, /Session Handoff \(auto, transition: \/new\)/);
+	assert.match(handoff, /Please investigate the memory shutdown behavior/);
+	assert.match(handoff, /reload and \/resume should stay silent/);
+});