@dungle-scrubs/tallow 0.8.7 → 0.8.8

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

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { runGitCommandSync } from "../../_shared/shell-policy.js";
@@ -114,6 +114,48 @@ describe("SnapshotManager", () => {
 		expect(result.restored.length).toBeGreaterThan(0);
 	});
 
+	it("creates snapshots from nested subdirectories", () => {
+		const subDir = join(tmpDir, "sub");
+		mkdirSync(subDir, { recursive: true });
+
+		writeFileSync(join(tmpDir, "root.txt"), "base-root");
+		git(["add", "-A"], tmpDir);
+		git(["commit", "-m", "base"], tmpDir);
+
+		const subMgr = new SnapshotManager(subDir, "nested-session");
+		writeFileSync(join(tmpDir, "root.txt"), "changed-from-subdir");
+
+		const ref = subMgr.createSnapshot(1);
+		expect(ref).toBe("refs/tallow/rewind/nested-session/turn-1");
+	});
+
+	it("restores full repo state when manager cwd is a subdirectory", () => {
+		const subDir = join(tmpDir, "sub");
+		mkdirSync(subDir, { recursive: true });
+		writeFileSync(join(tmpDir, "root.txt"), "base-root");
+		writeFileSync(join(subDir, "a.txt"), "base-a");
+		git(["add", "-A"], tmpDir);
+		git(["commit", "-m", "base"], tmpDir);
+
+		const subMgr = new SnapshotManager(subDir, "nested-session");
+		writeFileSync(join(tmpDir, "root.txt"), "snap-root");
+		writeFileSync(join(subDir, "a.txt"), "snap-a");
+		writeFileSync(join(subDir, "new.txt"), "snap-new");
+		const ref = subMgr.createSnapshot(1);
+		expect(ref).not.toBeNull();
+
+		writeFileSync(join(tmpDir, "root.txt"), "after-root");
+		writeFileSync(join(subDir, "a.txt"), "after-a");
+		writeFileSync(join(subDir, "after-only.txt"), "after-only");
+
+		subMgr.restoreSnapshot(ref as string);
+
+		expect(readFileSync(join(tmpDir, "root.txt"), "utf-8")).toBe("snap-root");
+		expect(readFileSync(join(subDir, "a.txt"), "utf-8")).toBe("snap-a");
+		expect(readFileSync(join(subDir, "new.txt"), "utf-8")).toBe("snap-new");
+		expect(existsSync(join(subDir, "after-only.txt"))).toBe(false);
+	});
+
 	it("should remove files created after the snapshot point", () => {
 		// Snapshot at turn 1 — no new-file.ts
 		writeFileSync(join(tmpDir, "a.txt"), "v1");

package/extensions/rewind/snapshots.ts

@@ -15,7 +15,9 @@
  */
 
 import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { runGitCommandSync } from "../_shared/shell-policy.js";
 
@@ -43,7 +45,7 @@ export interface SnapshotInfo {
  * Snapshots are stored as lightweight refs that can be restored independently.
  */
 export class SnapshotManager {
-	private readonly cwd: string;
+	private readonly repoRoot: string;
 	private readonly refPrefix: string;
 
 	/**
@@ -53,10 +55,20 @@ export class SnapshotManager {
 	 * @param sessionId - Session ID for namespacing refs
 	 */
 	constructor(cwd: string, sessionId: string) {
-		this.cwd = cwd;
+		this.repoRoot = this.resolveRepoRoot(cwd) ?? cwd;
 		this.refPrefix = `refs/tallow/rewind/${sessionId}`;
 	}
 
+	/**
+	 * Resolve the canonical git repository root for the manager's cwd.
+	 *
+	 * @param cwd - Working directory that may be a nested subdirectory
+	 * @returns Absolute repo root path, or null when outside a git worktree
+	 */
+	private resolveRepoRoot(cwd: string): string | null {
+		return runGitCommandSync(["rev-parse", "--show-toplevel"], cwd, 10_000);
+	}
+
 	/**
 	 * Checks whether the cwd is inside a git repository.
 	 *
@@ -84,7 +96,7 @@ export class SnapshotManager {
 	 * @returns The ref name, or null if nothing to snapshot
 	 */
 	createSnapshot(turnIndex: number): string | null {
-		const tmpIndex = join(this.cwd, ".git", "tallow-snapshot-index");
+		const tmpIndex = join(tmpdir(), `tallow-snapshot-index-${process.pid}-${randomUUID()}`);
 
 		try {
 			// Stage everything into the temp index (captures untracked files too)
@@ -154,7 +166,7 @@ export class SnapshotManager {
 		// Use fs.unlinkSync for reliability — git rm only works for tracked files.
 		for (const file of filesToDelete) {
 			try {
-				unlinkSync(join(this.cwd, file));
+				unlinkSync(join(this.repoRoot, file));
 			} catch {
 				// File might already be gone — best effort
 			}
@@ -252,7 +264,7 @@ export class SnapshotManager {
 	 * @returns Trimmed output, or null on failure
 	 */
 	private git(args: string[]): string | null {
-		return runGitCommandSync(args, this.cwd, 10_000);
+		return runGitCommandSync(args, this.repoRoot, 10_000);
 	}
 
 	/**
@@ -267,7 +279,7 @@ export class SnapshotManager {
 	 */
 	private gitWithEnv(args: string[], env: Record<string, string>): string | null {
 		const result = spawnSync("git", args, {
-			cwd: this.cwd,
+			cwd: this.repoRoot,
 			encoding: "utf-8",
 			timeout: 10_000,
 			maxBuffer: 10 * 1024 * 1024,

package/extensions/session-memory/index.ts

@@ -19,6 +19,7 @@ import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-age
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
+import { getDefaultTallowHomeDir, getTallowHomeDir } from "../_shared/tallow-paths.js";
 import { buildCuratorPrompt } from "./curator-prompt.js";
 import { SessionIndexer } from "./indexer.js";
 import type { SearchResult } from "./types.js";
@@ -45,7 +46,7 @@ let indexer: SessionIndexer | null = null;
  * @returns Path to the tallow config directory (e.g., ~/.tallow or ~/.tallow-fuse)
  */
 function getTallowHome(): string {
-	return process.env.TALLOW_CODING_AGENT_DIR ?? join(homedir(), ".tallow");
+	return getTallowHomeDir();
 }
 
 /**
@@ -66,7 +67,7 @@ function discoverAllSessionsDirs(): string[] {
 	if (existsSync(currentSessions)) dirs.add(currentSessions);
 
 	// Default tallow home (if different from current)
-	const defaultSessions = join(homedir(), ".tallow", "sessions");
+	const defaultSessions = join(getDefaultTallowHomeDir(), "sessions");
 	if (existsSync(defaultSessions)) dirs.add(defaultSessions);
 
 	// All per-project tallow homes from work-dirs config

package/extensions/stats/stats-log.ts

@@ -7,8 +7,8 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 // ── Schema ───────────────────────────────────────────────────────────────────
 
@@ -54,8 +54,7 @@ export interface SessionStats {
  * @returns Absolute path to stats.jsonl
  */
 export function getStatsLogPath(): string {
-	const tallowHome = process.env.TALLOW_CODING_AGENT_DIR || path.join(os.homedir(), ".tallow");
-	return path.join(tallowHome, "stats.jsonl");
+	return path.join(getTallowHomeDir(), "stats.jsonl");
 }
 
 // ── Write ────────────────────────────────────────────────────────────────────

package/extensions/subagent-tool/__tests__/discovery-defaults.test.ts

@@ -10,6 +10,7 @@
  * - Agent scoring heuristics
  */
 import { describe, expect, it } from "bun:test";
+import { resolveEffectiveIsolation } from "../agents.js";
 
 // ── Helpers (mirrored from subagent-tool/index.ts) ───────────────────────────
 
@@ -319,3 +320,25 @@ describe("mergeDefaults", () => {
 		expect(result.missingAgentBehavior).toBe("match-or-ephemeral"); // built-in (others didn't set)
 	});
 });
+
+describe("resolveEffectiveIsolation", () => {
+	it("uses per-call isolation when provided", () => {
+		const effective = resolveEffectiveIsolation("worktree", undefined, undefined);
+		expect(effective).toBe("worktree");
+	});
+
+	it("falls back to agent frontmatter isolation", () => {
+		const effective = resolveEffectiveIsolation(undefined, "worktree", undefined);
+		expect(effective).toBe("worktree");
+	});
+
+	it("falls back to defaults isolation", () => {
+		const effective = resolveEffectiveIsolation(undefined, undefined, "worktree");
+		expect(effective).toBe("worktree");
+	});
+
+	it("returns undefined when isolation is unset everywhere", () => {
+		const effective = resolveEffectiveIsolation(undefined, undefined, undefined);
+		expect(effective).toBeUndefined();
+	});
+});

package/extensions/subagent-tool/__tests__/isolation-frontmatter.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, 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 { discoverAgents } from "../agents.js";
+
+const createdDirs: string[] = [];
+
+afterEach(() => {
+	for (const dir of createdDirs.splice(0)) {
+		rmSync(dir, { force: true, recursive: true });
+	}
+});
+
+/**
+ * Create a temporary project directory with a `.tallow/agents` folder.
+ *
+ * @returns Project root path
+ */
+function createProjectWithAgentsDir(): string {
+	const projectRoot = mkdtempSync(join(tmpdir(), "subagent-isolation-test-"));
+	createdDirs.push(projectRoot);
+	mkdirSync(join(projectRoot, ".tallow", "agents"), { recursive: true });
+	return projectRoot;
+}
+
+/**
+ * Write a markdown agent definition into a temp project.
+ *
+ * @param projectRoot - Project root containing `.tallow/agents`
+ * @param fileName - Markdown filename
+ * @param content - Full markdown content
+ */
+function writeAgentFile(projectRoot: string, fileName: string, content: string): void {
+	writeFileSync(join(projectRoot, ".tallow", "agents", fileName), content, "utf-8");
+}
+
+describe("agent frontmatter isolation", () => {
+	it("parses `isolation: worktree` from agent frontmatter", () => {
+		const projectRoot = createProjectWithAgentsDir();
+		writeAgentFile(
+			projectRoot,
+			"worker.md",
+			`---
+name: worker
+description: test agent
+isolation: worktree
+---
+You are a worker.
+`
+		);
+
+		const discovered = discoverAgents(projectRoot, "project");
+		expect(discovered.agents).toHaveLength(1);
+		expect(discovered.agents[0]?.isolation).toBe("worktree");
+	});
+
+	it("parses defaults isolation from _defaults.md", () => {
+		const projectRoot = createProjectWithAgentsDir();
+		writeAgentFile(
+			projectRoot,
+			"_defaults.md",
+			`---
+isolation: worktree
+---
+`
+		);
+		writeAgentFile(
+			projectRoot,
+			"worker.md",
+			`---
+name: worker
+description: test agent
+---
+You are a worker.
+`
+		);
+
+		const discovered = discoverAgents(projectRoot, "project");
+		expect(discovered.defaults.isolation).toBe("worktree");
+		expect(discovered.agents[0]?.isolation).toBeUndefined();
+	});
+
+	it("rejects invalid isolation values deterministically", () => {
+		const projectRoot = createProjectWithAgentsDir();
+		writeAgentFile(
+			projectRoot,
+			"worker.md",
+			`---
+name: worker
+description: test agent
+isolation: sandbox
+---
+You are a worker.
+`
+		);
+
+		expect(() => discoverAgents(projectRoot, "project")).toThrow(/Invalid isolation/);
+	});
+});

package/extensions/subagent-tool/__tests__/model-router.test.ts

@@ -15,6 +15,7 @@ const { loadRoutingConfig } = await import("../model-router.js");
 let testCwd = "";
 let testHome = "";
 let originalHome: string | undefined;
+let originalTallowHome: string | undefined;
 
 /**
  * Write a JSON file, creating parent directories as needed.
@@ -32,7 +33,9 @@ beforeEach(() => {
 	testCwd = mkdtempSync(join(tmpdir(), "tallow-routing-cwd-"));
 	testHome = mkdtempSync(join(tmpdir(), "tallow-routing-home-"));
 	originalHome = process.env.HOME;
+	originalTallowHome = process.env.TALLOW_CODING_AGENT_DIR;
 	process.env.HOME = testHome;
+	process.env.TALLOW_CODING_AGENT_DIR = join(testHome, ".tallow");
 });
 
 afterEach(() => {
@@ -41,6 +44,11 @@ afterEach(() => {
 	} else {
 		process.env.HOME = originalHome;
 	}
+	if (originalTallowHome === undefined) {
+		delete process.env.TALLOW_CODING_AGENT_DIR;
+	} else {
+		process.env.TALLOW_CODING_AGENT_DIR = originalTallowHome;
+	}
 	rmSync(testCwd, { recursive: true, force: true });
 	rmSync(testHome, { recursive: true, force: true });
 });

package/extensions/subagent-tool/agents.ts

@@ -12,6 +12,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { parseFrontmatter } from "@mariozechner/pi-coding-agent";
+import { getTallowPath } from "../_shared/tallow-paths.js";
+import type { IsolationMode } from "./schema.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -30,6 +32,7 @@ export interface AgentConfig {
 	mcpServers?: string[];
 	maxTurns?: number;
 	model?: string;
+	isolation?: IsolationMode;
 	systemPrompt: string;
 	source: "user" | "project";
 	filePath: string;
@@ -47,6 +50,7 @@ export interface AgentDefaults {
 	disallowedTools?: string[];
 	maxTurns?: number;
 	mcpServers?: string[];
+	isolation?: IsolationMode;
 	/** How to handle missing agent names. Default: "match-or-ephemeral" */
 	missingAgentBehavior?: "match-or-ephemeral" | "error";
 	/** Agent name to use as fallback when no match found */
@@ -81,6 +85,29 @@ export const PI_BUILTIN_TOOLS = ["read", "bash", "edit", "write", "grep", "find"
 /** Minimum score threshold for best-match to be accepted over ephemeral. */
 const MATCH_THRESHOLD = 40;
 
+/**
+ * Parse and validate isolation frontmatter/default values.
+ *
+ * @param value - Raw frontmatter/default value
+ * @param sourcePath - File path used in deterministic error messages
+ * @param fieldName - Field name used in deterministic error messages
+ * @returns Parsed isolation mode when present
+ * @throws {Error} When value is invalid
+ */
+function parseIsolationValue(
+	value: unknown,
+	sourcePath: string,
+	fieldName: "isolation"
+): IsolationMode | undefined {
+	if (value == null || value === "") return undefined;
+	if (typeof value !== "string") {
+		throw new Error(`Invalid ${fieldName} in ${sourcePath}: expected string "worktree".`);
+	}
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "worktree") return "worktree";
+	throw new Error(`Invalid ${fieldName} in ${sourcePath}: received "${value}". Allowed: worktree.`);
+}
+
 // ── Functions ────────────────────────────────────────────────────────────────
 
 /**
@@ -136,13 +163,19 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			continue;
 		}
 
-		const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
-		if (!(frontmatter.name && frontmatter.description)) continue;
+		const { frontmatter, body } = parseFrontmatter<Record<string, unknown>>(content);
+		const name = typeof frontmatter.name === "string" ? frontmatter.name.trim() : "";
+		const description =
+			typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+		if (!name || !description) continue;
 
-		const rawTools = frontmatter.tools
-			?.split(",")
-			.map((t: string) => t.trim())
-			.filter(Boolean);
+		const rawTools =
+			typeof frontmatter.tools === "string"
+				? frontmatter.tools
+						.split(",")
+						.map((t: string) => t.trim())
+						.filter(Boolean)
+				: undefined;
 
 		// Separate Task(agent_type) entries from regular tool names
 		const TASK_PATTERN = /^Task\((.+)\)$/;
@@ -171,13 +204,16 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			}
 		}
 
-		const disallowedTools = frontmatter.disallowedTools
-			?.split(",")
-			.map((t: string) => t.trim())
-			.filter(Boolean);
+		const disallowedTools =
+			typeof frontmatter.disallowedTools === "string"
+				? frontmatter.disallowedTools
+						.split(",")
+						.map((t: string) => t.trim())
+						.filter(Boolean)
+				: undefined;
 
 		const parsedMaxTurns = frontmatter.maxTurns
-			? Number.parseInt(frontmatter.maxTurns, 10)
+			? Number.parseInt(String(frontmatter.maxTurns), 10)
 			: undefined;
 		const maxTurns = parsedMaxTurns && parsedMaxTurns > 0 ? parsedMaxTurns : undefined;
 
@@ -189,7 +225,7 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 						if (typeof entry === "string") return true;
 						if (typeof entry === "object" && entry !== null) {
 							console.warn(
-								`MCP: Inline server definitions not supported in agent "${frontmatter.name}". ` +
+								`MCP: Inline server definitions not supported in agent "${name}". ` +
 									`Use a string reference to a configured server name.`
 							);
 							return false;
@@ -206,16 +242,19 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 			}
 		}
 
+		const isolation = parseIsolationValue(frontmatter.isolation, filePath, "isolation");
+
 		agents.push({
-			name: frontmatter.name,
-			description: frontmatter.description,
+			name,
+			description,
 			tools: tools.length > 0 ? tools : undefined,
 			disallowedTools: disallowedTools && disallowedTools.length > 0 ? disallowedTools : undefined,
 			skills: skills && skills.length > 0 ? skills : undefined,
 			allowedAgentTypes: allowedAgentTypes.length > 0 ? allowedAgentTypes : undefined,
 			mcpServers: mcpServers && mcpServers.length > 0 ? mcpServers : undefined,
 			maxTurns,
-			model: frontmatter.model,
+			model: typeof frontmatter.model === "string" ? frontmatter.model : undefined,
+			isolation,
 			systemPrompt: body,
 			source,
 			filePath,
@@ -307,6 +346,10 @@ function loadDefaultsFromDir(dir: string): AgentDefaults | undefined {
 			.map((s) => s.trim())
 			.filter(Boolean);
 	}
+	const isolation = parseIsolationValue(frontmatter.isolation, filePath, "isolation");
+	if (isolation) {
+		defaults.isolation = isolation;
+	}
 	if (frontmatter.missingAgentBehavior === "error") {
 		defaults.missingAgentBehavior = "error";
 	}
@@ -334,6 +377,7 @@ function mergeDefaults(...sources: (AgentDefaults | undefined)[]): AgentDefaults
 		if (src.disallowedTools) merged.disallowedTools = src.disallowedTools;
 		if (src.maxTurns != null) merged.maxTurns = src.maxTurns;
 		if (src.mcpServers) merged.mcpServers = src.mcpServers;
+		if (src.isolation) merged.isolation = src.isolation;
 		if (src.missingAgentBehavior) merged.missingAgentBehavior = src.missingAgentBehavior;
 		if (src.fallbackAgent) merged.fallbackAgent = src.fallbackAgent;
 	}
@@ -350,7 +394,7 @@ function mergeDefaults(...sources: (AgentDefaults | undefined)[]): AgentDefaults
  * @returns Discovery result with agents and project directory path
  */
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
-	const userTallowDir = path.join(os.homedir(), ".tallow", "agents");
+	const userTallowDir = getTallowPath("agents");
 	const userClaudeDir = path.join(os.homedir(), ".claude", "agents");
 	const projectDirs = findProjectAgentsDirs(cwd);
 	const projectAgentsDir = projectDirs.at(-1) ?? null;
@@ -391,6 +435,22 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
 	return { agents: Array.from(agentMap.values()), projectAgentsDir, defaults };
 }
 
+/**
+ * Resolve effective isolation by precedence: call param > agent > defaults.
+ *
+ * @param callIsolation - Isolation passed in the current tool invocation
+ * @param agentIsolation - Isolation from resolved agent frontmatter
+ * @param defaultIsolation - Isolation from `_defaults.md`
+ * @returns Effective isolation mode when configured
+ */
+export function resolveEffectiveIsolation(
+	callIsolation: IsolationMode | undefined,
+	agentIsolation: IsolationMode | undefined,
+	defaultIsolation: IsolationMode | undefined
+): IsolationMode | undefined {
+	return callIsolation ?? agentIsolation ?? defaultIsolation;
+}
+
 /**
  * Computes the effective tool list from allowlist and denylist.
  *
@@ -477,6 +537,7 @@ export function resolveAgentForExecution(
 		disallowedTools: defaults?.disallowedTools,
 		maxTurns: defaults?.maxTurns,
 		mcpServers: defaults?.mcpServers,
+		isolation: defaults?.isolation,
 		systemPrompt:
 			`You are ${agentName}, a specialized subagent. ` +
 			"Complete the delegated task thoroughly and return your results.",