@dungle-scrubs/tallow 0.9.4 → 0.9.7

package/extensions/render-stabilizer/__tests__/render-stabilizer.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "bun:test";
 import renderStabilizerExtension from "../index.js";
 
 describe("render-stabilizer extension", () => {
-	it("registers session_start and session_before_switch handlers", () => {
+	it("registers only the legacy session_before_switch hook", () => {
 		const handlers = new Map<string, unknown[]>();
 
 		const mockPi = {
@@ -14,8 +14,7 @@ describe("render-stabilizer extension", () => {
 
 		renderStabilizerExtension(mockPi as never);
 
-		expect(handlers.has("session_start")).toBe(true);
-		expect(handlers.get("session_start")?.length).toBe(1);
+		expect(handlers.has("session_start")).toBe(false);
 		expect(handlers.has("session_before_switch")).toBe(true);
 		expect(handlers.get("session_before_switch")?.length).toBe(1);
 	});

package/extensions/render-stabilizer/index.ts

@@ -43,15 +43,15 @@ function captureTuiRef(ui: {
 /**
  * Register render stabilization hooks.
  *
+ * The shared reset helper now owns reset-grace handling for the main
+ * interactive reset paths. This extension remains as a compatibility shim
+ * for any remaining session-switch surfaces that still depend on an
+ * extension-side hook.
+ *
  * @param pi - Extension API
  */
 export default function renderStabilizerExtension(pi: ExtensionAPI): void {
-	// Capture the TUI reference on first session_start
-	pi.on("session_start", async (_event, ctx) => {
-		captureTuiRef(ctx.ui);
-	});
-
-	// Reset the render grace period before a session switch so the
+	// Reset the render grace period before a legacy session switch so the
 	// chatContainer.clear() → renderInitialMessages() transition uses
 	// gentle line-by-line redraws instead of screen-clearing redraws.
 	pi.on("session_before_switch", async (_event, ctx) => {

package/extensions/rewind/__tests__/session-files.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { listLiveSessionIdsForCwd } from "../session-files.js";
+
+/**
+ * Encode a cwd into the session directory name used by tallow.
+ *
+ * @param cwd - Absolute working directory path
+ * @returns Encoded directory name
+ */
+function encodeSessionDirName(cwd: string): string {
+	const withoutLeadingSlash = cwd.startsWith("/") || cwd.startsWith("\\") ? cwd.slice(1) : cwd;
+	const safeName = withoutLeadingSlash
+		.replaceAll("/", "-")
+		.replaceAll("\\", "-")
+		.replaceAll(":", "-");
+	return `--${safeName}--`;
+}
+
+/**
+ * Create a minimal JSONL session file for a test home/cwd pair.
+ *
+ * @param homeDir - Tallow home directory
+ * @param cwd - Session working directory
+ * @param sessionId - Session id to persist in the header
+ * @param fileName - Session filename to create
+ * @returns Absolute path to the created session file
+ */
+function createSessionFile(
+	homeDir: string,
+	cwd: string,
+	sessionId: string,
+	fileName: string
+): string {
+	const sessionDir = join(homeDir, "sessions", encodeSessionDirName(cwd));
+	mkdirSync(sessionDir, { recursive: true });
+	const filePath = join(sessionDir, fileName);
+	writeFileSync(
+		filePath,
+		`${JSON.stringify({ cwd, id: sessionId, timestamp: new Date().toISOString(), type: "session", version: 3 })}\n`
+	);
+	return filePath;
+}
+
+describe("listLiveSessionIdsForCwd", () => {
+	const originalHome = process.env.HOME;
+	const originalTallowHome = process.env.TALLOW_CODING_AGENT_DIR;
+	const originalPiHome = process.env.PI_CODING_AGENT_DIR;
+	let tmpRoot: string;
+
+	beforeEach(() => {
+		tmpRoot = mkdtempSync(join(tmpdir(), "rewind-session-files-"));
+		process.env.HOME = tmpRoot;
+		delete process.env.PI_CODING_AGENT_DIR;
+		delete process.env.TALLOW_CODING_AGENT_DIR;
+	});
+
+	afterEach(() => {
+		if (originalHome === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = originalHome;
+		}
+
+		if (originalTallowHome === undefined) {
+			delete process.env.TALLOW_CODING_AGENT_DIR;
+		} else {
+			process.env.TALLOW_CODING_AGENT_DIR = originalTallowHome;
+		}
+
+		if (originalPiHome === undefined) {
+			delete process.env.PI_CODING_AGENT_DIR;
+		} else {
+			process.env.PI_CODING_AGENT_DIR = originalPiHome;
+		}
+
+		rmSync(tmpRoot, { force: true, recursive: true });
+	});
+
+	it("finds live session ids across the default and active tallow homes", () => {
+		const cwd = "/Users/kevin/dev/tallow";
+		const defaultHome = join(tmpRoot, ".tallow");
+		const activeHome = join(tmpRoot, ".tallow-project");
+		process.env.TALLOW_CODING_AGENT_DIR = activeHome;
+
+		createSessionFile(defaultHome, cwd, "default-session", "2026-04-20_default-session.jsonl");
+		createSessionFile(activeHome, cwd, "active-session", "2026-04-20_active-session.jsonl");
+		createSessionFile(
+			activeHome,
+			"/Users/kevin/dev/other",
+			"other-project",
+			"2026-04-20_other.jsonl"
+		);
+
+		const ids = listLiveSessionIdsForCwd(cwd, [defaultHome, activeHome]);
+		expect([...ids].sort((a, b) => a.localeCompare(b))).toEqual([
+			"active-session",
+			"default-session",
+		]);
+	});
+
+	it("ignores unreadable or corrupt session files", () => {
+		const cwd = "/Users/kevin/dev/tallow";
+		const defaultHome = join(tmpRoot, ".tallow");
+		const sessionDir = join(defaultHome, "sessions", encodeSessionDirName(cwd));
+		mkdirSync(sessionDir, { recursive: true });
+		writeFileSync(join(sessionDir, "corrupt.jsonl"), "not-json\n");
+		createSessionFile(defaultHome, cwd, "valid-session", "2026-04-20_valid-session.jsonl");
+
+		const ids = listLiveSessionIdsForCwd(cwd, [defaultHome]);
+		expect([...ids]).toEqual(["valid-session"]);
+	});
+});

package/extensions/rewind/__tests__/snapshots.test.ts

@@ -247,6 +247,29 @@ describe("SnapshotManager", () => {
 		otherMgr.cleanup();
 	});
 
+	it("should prune stale session refs while preserving live sessions", () => {
+		const otherMgr = new SnapshotManager(tmpDir, "other-session");
+		const staleMgr = new SnapshotManager(tmpDir, "stale-session");
+
+		writeFileSync(join(tmpDir, "a.txt"), "live-1");
+		mgr.createSnapshot(1);
+		writeFileSync(join(tmpDir, "a.txt"), "live-2");
+		otherMgr.createSnapshot(1);
+		writeFileSync(join(tmpDir, "a.txt"), "stale");
+		staleMgr.createSnapshot(1);
+
+		const deletedRefs = mgr.cleanupStaleSessions(new Set(["other-session", "test-session"]));
+		expect(deletedRefs).toBe(1);
+
+		const staleRefs = git(["for-each-ref", "refs/tallow/rewind/stale-session/"], tmpDir);
+		expect(staleRefs.trim()).toBe("");
+
+		const liveRefs = git(["for-each-ref", "refs/tallow/rewind/test-session/"], tmpDir);
+		expect(liveRefs.trim()).not.toBe("");
+		const otherRefs = git(["for-each-ref", "refs/tallow/rewind/other-session/"], tmpDir);
+		expect(otherRefs.trim()).not.toBe("");
+	});
+
 	it("should return empty list when no snapshots exist", () => {
 		expect(mgr.listSnapshots()).toHaveLength(0);
 	});

package/extensions/rewind/index.ts

@@ -14,6 +14,7 @@
  */
 
 import type { CustomEntry, ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { listLiveSessionIdsForCwd } from "./session-files.js";
 import { SnapshotManager } from "./snapshots.js";
 import type { RewindSnapshotEntry } from "./tracker.js";
 import { FileTracker } from "./tracker.js";
@@ -50,6 +51,10 @@ export default function rewind(pi: ExtensionAPI): void {
 		snapshots = mgr;
 		tracker.reset();
 
+		const liveSessionIds = listLiveSessionIdsForCwd(context.cwd);
+		liveSessionIds.add(sessionId);
+		mgr.cleanupStaleSessions(liveSessionIds);
+
 		// Restore tracker state from persisted session entries
 		const entries = context.sessionManager.getEntries();
 		const snapshotEntries = entries

package/extensions/rewind/session-files.ts

@@ -0,0 +1,138 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { SessionHeader } from "@mariozechner/pi-coding-agent";
+import { getDefaultTallowHomeDir, getTallowHomeDir } from "../_shared/tallow-paths.js";
+
+/**
+ * Encode a cwd into the per-project session directory name used by tallow.
+ *
+ * @param cwd - Absolute working directory path
+ * @returns Encoded directory name (for example `--Users-kevin-dev-tallow--`)
+ */
+function encodeSessionDirName(cwd: string): string {
+	const withoutLeadingSlash = cwd.startsWith("/") || cwd.startsWith("\\") ? cwd.slice(1) : cwd;
+	const safeName = withoutLeadingSlash
+		.replaceAll("/", "-")
+		.replaceAll("\\", "-")
+		.replaceAll(":", "-");
+	return `--${safeName}--`;
+}
+
+/**
+ * Read additional tallow home directories from the maintainer's work-dir config.
+ *
+ * @returns Extra configured tallow home directories
+ */
+function readConfiguredHomeDirs(): string[] {
+	const workDirsPath = join(homedir(), ".config", "tallow-work-dirs");
+
+	try {
+		const content = readFileSync(workDirsPath, "utf-8");
+		return content
+			.split("\n")
+			.map((line) => line.trim())
+			.filter((line) => line.length > 0 && !line.startsWith("#"))
+			.map((line) => {
+				const colonIndex = line.indexOf(":");
+				return colonIndex === -1 ? "" : line.slice(colonIndex + 1).trim();
+			})
+			.filter((configDir) => configDir.length > 0);
+	} catch {
+		// Missing or unreadable work-dir config means there are no extra homes to scan.
+		return [];
+	}
+}
+
+/**
+ * Build the set of tallow homes that should be searched for session files.
+ *
+ * @param homeDirs - Optional explicit home directories (used by tests to avoid scanning real homes)
+ * @returns Unique tallow home directories to inspect
+ */
+function resolveHomeDirs(homeDirs?: readonly string[]): Set<string> {
+	if (homeDirs) {
+		return new Set(homeDirs);
+	}
+
+	return new Set<string>([
+		getDefaultTallowHomeDir(),
+		getTallowHomeDir(),
+		...readConfiguredHomeDirs(),
+	]);
+}
+
+/**
+ * Discover every session directory that can contain sessions for a specific cwd.
+ *
+ * Tallow can store sessions under the default home, the active runtime home,
+ * and any per-project homes listed in `~/.config/tallow-work-dirs`.
+ *
+ * @param cwd - Working directory whose session subdirectory should be resolved
+ * @param homeDirs - Optional explicit home directories (used by tests to avoid scanning real homes)
+ * @returns Existing session directory paths across all known tallow homes
+ */
+function discoverSessionDirsForCwd(cwd: string, homeDirs?: readonly string[]): string[] {
+	const dirName = encodeSessionDirName(cwd);
+	const dirs = new Set<string>();
+
+	for (const home of resolveHomeDirs(homeDirs)) {
+		const sessionsDir = join(home, "sessions", dirName);
+		if (existsSync(sessionsDir)) {
+			dirs.add(sessionsDir);
+		}
+	}
+
+	return [...dirs];
+}
+
+/**
+ * Read the session id from a JSONL session file.
+ *
+ * The conventional filename already contains the id, but parsing the header is
+ * more robust for renamed or migrated session files.
+ *
+ * @param filePath - Absolute path to the session JSONL file
+ * @returns Session id when readable and valid, otherwise null
+ */
+function readSessionId(filePath: string): string | null {
+	try {
+		const content = readFileSync(filePath, "utf-8");
+		const firstNewline = content.indexOf("\n");
+		const headerLine = firstNewline === -1 ? content : content.slice(0, firstNewline);
+		const header = JSON.parse(headerLine) as SessionHeader;
+		if (header.type !== "session") return null;
+		return typeof header.id === "string" && header.id.length > 0 ? header.id : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * List every live session id for the current cwd across all known tallow homes.
+ *
+ * @param cwd - Working directory whose sessions should be considered live
+ * @param homeDirs - Optional explicit home directories to scan instead of runtime discovery
+ * @returns Set of live session ids
+ */
+export function listLiveSessionIdsForCwd(cwd: string, homeDirs?: readonly string[]): Set<string> {
+	const ids = new Set<string>();
+
+	for (const sessionsDir of discoverSessionDirsForCwd(cwd, homeDirs)) {
+		let files: string[];
+		try {
+			files = readdirSync(sessionsDir).filter((file) => file.endsWith(".jsonl"));
+		} catch {
+			continue;
+		}
+
+		for (const file of files) {
+			const sessionId = readSessionId(join(sessionsDir, file));
+			if (sessionId) {
+				ids.add(sessionId);
+			}
+		}
+	}
+
+	return ids;
+}

package/extensions/rewind/snapshots.ts

@@ -277,13 +277,112 @@ export class SnapshotManager {
 	}
 
 	/**
-	 * Removes all refs for the current session.
+	 * Remove all refs for the current session.
+	 *
+	 * @returns Number of refs deleted for this session
+	 */
+	cleanup(): number {
+		return this.cleanupSession(this.getSessionIdFromPrefix(this.refPrefix));
+	}
+
+	/**
+	 * Remove rewind refs whose session ids no longer exist on disk.
+	 *
+	 * @param liveSessionIds - Session ids that still have backing session files
+	 * @returns Count of deleted refs across all stale sessions
+	 */
+	cleanupStaleSessions(liveSessionIds: ReadonlySet<string>): number {
+		let deletedRefs = 0;
+
+		for (const sessionId of this.listSessionIds()) {
+			if (liveSessionIds.has(sessionId)) continue;
+			deletedRefs += this.cleanupSession(sessionId);
+		}
+
+		return deletedRefs;
+	}
+
+	/**
+	 * List every session id that currently has rewind refs in this repository.
+	 *
+	 * @returns Ordered unique session ids extracted from `refs/tallow/rewind/*`
+	 */
+	private listSessionIds(): string[] {
+		const raw = this.git(["for-each-ref", "--format=%(refname)", "refs/tallow/rewind/"]);
+		if (!raw) return [];
+
+		const ids = new Set<string>();
+		for (const line of raw.split("\n")) {
+			const ref = this.normalizeRefName(line);
+			if (!ref) continue;
+			const sessionId = this.parseSessionIdFromRef(ref);
+			if (sessionId) {
+				ids.add(sessionId);
+			}
+		}
+
+		return [...ids].sort((a, b) => a.localeCompare(b));
+	}
+
+	/**
+	 * Remove every rewind ref for a single session id.
+	 *
+	 * @param sessionId - Session id whose namespaced rewind refs should be deleted
+	 * @returns Count of deleted refs
 	 */
-	cleanup(): void {
-		const snapshots = this.listSnapshots();
-		for (const snap of snapshots) {
-			this.git(["update-ref", "-d", snap.ref]);
+	private cleanupSession(sessionId: string): number {
+		const raw = this.git([
+			"for-each-ref",
+			"--format=%(refname)",
+			`refs/tallow/rewind/${sessionId}/`,
+		]);
+		if (!raw) return 0;
+
+		let deletedRefs = 0;
+		for (const line of raw.split("\n")) {
+			const ref = this.normalizeRefName(line);
+			if (!ref) continue;
+			if (this.git(["update-ref", "-d", ref]) !== null) {
+				deletedRefs++;
+			}
 		}
+
+		return deletedRefs;
+	}
+
+	/**
+	 * Parse a session id from a full rewind ref name.
+	 *
+	 * @param ref - Full rewind ref name
+	 * @returns Session id when the ref matches the rewind namespace, otherwise null
+	 */
+	private parseSessionIdFromRef(ref: string): string | null {
+		const match = /^refs\/tallow\/rewind\/([^/]+)\/turn-\d+$/.exec(ref);
+		return match?.[1] ?? null;
+	}
+
+	/**
+	 * Normalize a raw ref name line from git output.
+	 *
+	 * @param line - Raw line returned by `git for-each-ref`
+	 * @returns Trimmed ref name without surrounding quotes
+	 */
+	private normalizeRefName(line: string): string {
+		const trimmed = line.trim();
+		if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+			return trimmed.slice(1, -1);
+		}
+		return trimmed;
+	}
+
+	/**
+	 * Extract the current manager's session id from its ref prefix.
+	 *
+	 * @param refPrefix - Session-scoped rewind ref prefix
+	 * @returns Session id portion of the prefix
+	 */
+	private getSessionIdFromPrefix(refPrefix: string): string {
+		return refPrefix.replace(/^refs\/tallow\/rewind\//, "");
 	}
 
 	/**

package/extensions/skill-commands/index.ts

@@ -199,7 +199,12 @@ export default function (pi: ExtensionAPI) {
 	// Load skills synchronously during extension init for autocomplete to work.
 	// includeDefaults: true picks up ~/.tallow/skills/ and ./skills/ (project).
 	// extraSkillPaths adds shared dirs + Claude bridge paths.
-	const { skills } = loadSkills({ agentDir, skillPaths: extraSkillPaths });
+	const { skills } = loadSkills({
+		cwd: process.cwd(),
+		agentDir,
+		skillPaths: extraSkillPaths,
+		includeDefaults: true,
+	});
 
 	for (const skill of skills) {
 		// Validate name before registration — invalid names produce broken commands

package/extensions/slash-command-bridge/__tests__/slash-command-bridge.test.ts

@@ -13,6 +13,10 @@ import type {
 	ExtensionUIContext,
 	TurnEndEvent,
 } from "@mariozechner/pi-coding-agent";
+import {
+	getResetDiagnosticsForTests,
+	resetResetDiagnosticsForTests,
+} from "../../../src/reset-diagnostics.js";
 import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
 import { ManualTimerScheduler } from "../../../test-utils/manual-timer-scheduler.js";
 import slashCommandBridge, {
@@ -40,6 +44,7 @@ beforeEach(async () => {
 });
 
 afterEach(() => {
+	resetResetDiagnosticsForTests();
 	resetSlashCommandBridgeStateForTests();
 });
 
@@ -314,6 +319,11 @@ describe("compact", () => {
 		const continuation = harness.sentMessages.find(
 			(message) => message.customType === "compact-continue"
 		);
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) => event.kind === "deferred_registered" && event.source === "slash-command-bridge"
+			)
+		).toBe(true);
 		expect(continuation?.display).toBe(false);
 		expect(continuation?.options?.triggerTurn).toBe(true);
 		expect(continuation?.content).toContain("compaction is complete");
@@ -344,6 +354,14 @@ describe("compact", () => {
 		await harness.fireEvent("turn_start", { type: "turn_start", turnIndex: 0, timestamp: 0 }, ctx);
 		scheduler.advanceBy(200);
 
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) =>
+					event.kind === "deferred_cancelled" &&
+					event.source === "slash-command-bridge" &&
+					event.reason === "turn_start"
+			)
+		).toBe(true);
 		expect(harness.sentMessages).toHaveLength(0);
 		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 	});
@@ -374,6 +392,14 @@ describe("compact", () => {
 		compactOptions?.onComplete?.();
 		scheduler.advanceBy(200);
 
+		expect(
+			getResetDiagnosticsForTests().some(
+				(event) =>
+					event.kind === "deferred_dropped" &&
+					event.source === "slash-command-bridge" &&
+					event.reason === "session_not_idle"
+			)
+		).toBe(true);
 		expect(harness.sentMessages).toHaveLength(0);
 		expect(widgetUpdates.at(-1)).toEqual({ key: "compact-progress", content: undefined });
 		expect(workingMessages.at(-1)).toBeUndefined();

package/extensions/slash-command-bridge/index.ts

@@ -17,6 +17,7 @@ import type {
 } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { recordResetDiagnostic } from "../../src/reset-diagnostics.js";
 
 /**
  * Deferred compact request — set by the tool handler, consumed on the first
@@ -154,13 +155,18 @@ function stopCompactProgress(ctx?: ExtensionContext): void {
  *
  * @returns Nothing
  */
-function clearContinuationTimer(): void {
+function clearContinuationTimer(reason?: string): void {
 	if (!continuationTimer) {
 		return;
 	}
 
 	timerScheduler.clearTimeout(continuationTimer);
 	continuationTimer = null;
+	recordResetDiagnostic({
+		kind: "deferred_cancelled",
+		reason: reason ?? "clear_continuation_timer",
+		source: "slash-command-bridge",
+	});
 }
 
 /**
@@ -338,6 +344,7 @@ function startDeferredCompact(
 			// 200ms gives session.prompt()'s async setup (API key resolution,
 			// compaction check) time to settle. The turn_start listener cancels
 			// this timer if a turn starts before it fires (defense-in-depth).
+			recordResetDiagnostic({ kind: "deferred_registered", source: "slash-command-bridge" });
 			continuationTimer = timerScheduler.setTimeout(() => {
 				continuationTimer = null;
 				if (ctx.isIdle()) {
@@ -354,6 +361,11 @@ function startDeferredCompact(
 				} else {
 					// User sent a message during compaction — their turn is
 					// handling things, clean up our indicators.
+					recordResetDiagnostic({
+						kind: "deferred_dropped",
+						reason: "session_not_idle",
+						source: "slash-command-bridge",
+					});
 					resumingAfterCompact = false;
 					ctx.ui?.setWidget?.("compact-progress", undefined);
 					ctx.ui?.setWorkingMessage?.();
@@ -601,7 +613,7 @@ WHEN NOT TO USE:
 	 * now active and showing the pending working message ("Resuming task…").
 	 */
 	pi.on("turn_start", (_event, ctx) => {
-		clearContinuationTimer();
+		clearContinuationTimer("turn_start");
 		if (!resumingAfterCompact) return;
 		resumingAfterCompact = false;
 		ctx.ui?.setWidget?.("compact-progress", undefined);