@dungle-scrubs/tallow 0.8.7 → 0.8.8

package/extensions/__integration__/plan-rejection-feedback.test.ts

@@ -0,0 +1,272 @@
+import { describe, expect, it } from "bun:test";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { ExtensionHarness } from "../../test-utils/extension-harness.js";
+import planModeExtension from "../plan-mode-tool/index.js";
+
+const PLAN_TEXT = [
+	"Plan:",
+	"1. Inspect tool failure paths in plan execution",
+	"2. Verify fallback behavior for blocked operations",
+	"3. Finalize recovery guidance for remaining step",
+].join("\n");
+
+interface ContextOptions {
+	readonly confirmResponse?: boolean;
+	readonly editorResponse?: string;
+	readonly hasUI: boolean;
+	readonly selectResponse?: string;
+}
+
+/**
+ * Create a minimal extension context with configurable UI responses.
+ *
+ * @param options - Context and UI response options
+ * @returns Extension context for direct event firing
+ */
+function createContext(options: ContextOptions): ExtensionContext {
+	const theme = {
+		bg(_token: string, value: string) {
+			return value;
+		},
+		fg(_token: string, value: string) {
+			return value;
+		},
+		strikethrough(value: string) {
+			return value;
+		},
+	};
+
+	return {
+		abort: () => {},
+		compact: () => {},
+		cwd: process.cwd(),
+		getContextUsage: () => undefined,
+		getSystemPrompt: () => "",
+		hasPendingMessages: () => false,
+		hasUI: options.hasUI,
+		isIdle: () => true,
+		model: undefined,
+		modelRegistry: {
+			getApiKeyForProvider: async () => undefined,
+		} as never,
+		sessionManager: {
+			appendEntry: () => {},
+			getEntries: () => [],
+		} as never,
+		shutdown: () => {},
+		ui: {
+			async confirm() {
+				return options.confirmResponse ?? false;
+			},
+			async custom() {
+				return undefined as never;
+			},
+			async editor() {
+				return options.editorResponse;
+			},
+			async input() {
+				return undefined;
+			},
+			notify() {},
+			pasteToEditor() {},
+			async select() {
+				return options.selectResponse;
+			},
+			setEditorComponent() {},
+			setEditorText() {},
+			setFooter() {},
+			setHeader() {},
+			setStatus() {},
+			setTitle() {},
+			setToolsExpanded() {},
+			setWidget() {},
+			setWorkingMessage() {},
+			get theme() {
+				return theme as ExtensionContext["ui"]["theme"];
+			},
+			getAllThemes() {
+				return [];
+			},
+			getEditorText() {
+				return "";
+			},
+			getTheme() {
+				return undefined;
+			},
+			getToolsExpanded() {
+				return false;
+			},
+			setTheme() {
+				return { error: "Test stub", success: false };
+			},
+		} as ExtensionContext["ui"],
+	};
+}
+
+/**
+ * Build an assistant message payload with a single text block.
+ *
+ * @param text - Assistant text content
+ * @returns Assistant message payload
+ */
+function assistantMessage(text: string): {
+	readonly content: readonly [{ readonly text: string; readonly type: "text" }];
+	readonly role: "assistant";
+} {
+	return {
+		content: [{ text, type: "text" }],
+		role: "assistant",
+	};
+}
+
+/**
+ * Initialize plan execution mode with a 3-step plan and tracking enabled.
+ *
+ * @param harness - Extension harness with plan-mode extension loaded
+ * @returns Promise that resolves once execution mode is active
+ */
+async function initializeExecutionMode(harness: ExtensionHarness): Promise<void> {
+	harness.setFlag("plan", true);
+	await harness.fireEvent(
+		"session_start",
+		{ type: "session_start" },
+		createContext({ hasUI: true })
+	);
+	await harness.fireEvent(
+		"agent_end",
+		{ messages: [assistantMessage(PLAN_TEXT)] },
+		createContext({
+			hasUI: true,
+			selectResponse: "Execute the plan (track progress)",
+		})
+	);
+}
+
+/**
+ * Fire a failed tool_result event using the documented test payload shape.
+ *
+ * @param harness - Extension harness instance
+ * @param ctx - Extension context for the event
+ * @returns Promise that resolves after handlers run
+ */
+async function fireFailedToolResult(
+	harness: ExtensionHarness,
+	ctx: ExtensionContext
+): Promise<void> {
+	await harness.fireEvent(
+		"tool_result",
+		{
+			content: [{ text: "blocked", type: "text" }],
+			input: { command: "echo blocked" },
+			isError: true,
+			toolCallId: "tool-call-1",
+			toolName: "bash",
+		},
+		ctx
+	);
+}
+
+/**
+ * Fire a turn_end event that marks a plan step as complete.
+ *
+ * @param harness - Extension harness instance
+ * @param step - Step number to mark done
+ * @returns Promise that resolves after handlers run
+ */
+async function fireDoneStep(harness: ExtensionHarness, step: number): Promise<void> {
+	await harness.fireEvent(
+		"turn_end",
+		{ message: assistantMessage(`[DONE:${step}]`) },
+		createContext({ hasUI: true })
+	);
+}
+
+describe("Plan rejection feedback", () => {
+	it("ignores tool_result during execution when hasUI is false", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(planModeExtension);
+		await initializeExecutionMode(harness);
+
+		await fireFailedToolResult(harness, createContext({ hasUI: false }));
+
+		expect(harness.sentUserMessages).toHaveLength(0);
+	});
+
+	it("sends steer guidance with Step 1 prefix when user confirms and provides guidance", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(planModeExtension);
+		await initializeExecutionMode(harness);
+
+		await fireFailedToolResult(
+			harness,
+			createContext({
+				confirmResponse: true,
+				editorResponse: "Use a narrower inspection command and continue.",
+				hasUI: true,
+			})
+		);
+
+		expect(harness.sentUserMessages).toHaveLength(1);
+		const [message] = harness.sentUserMessages;
+		if (!message || typeof message.content !== "string") {
+			throw new Error("Expected one string user message");
+		}
+		expect(message.content.startsWith("[PLAN GUIDANCE — Step 1:")).toBe(true);
+		expect(message.options?.deliverAs).toBe("steer");
+	});
+
+	it("does not send guidance when user declines confirmation", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(planModeExtension);
+		await initializeExecutionMode(harness);
+
+		await fireFailedToolResult(
+			harness,
+			createContext({
+				confirmResponse: false,
+				hasUI: true,
+			})
+		);
+
+		expect(harness.sentUserMessages).toHaveLength(0);
+	});
+
+	it("advances tracked step guidance to Step 3 and stops after all steps complete", async () => {
+		const harness = ExtensionHarness.create();
+		await harness.loadExtension(planModeExtension);
+		await initializeExecutionMode(harness);
+
+		await fireDoneStep(harness, 1);
+		await fireDoneStep(harness, 2);
+
+		await fireFailedToolResult(
+			harness,
+			createContext({
+				confirmResponse: true,
+				editorResponse: "Focus on the final verification sequence.",
+				hasUI: true,
+			})
+		);
+
+		expect(harness.sentUserMessages).toHaveLength(1);
+		const [stepThreeGuidance] = harness.sentUserMessages;
+		if (!stepThreeGuidance || typeof stepThreeGuidance.content !== "string") {
+			throw new Error("Expected one string user message");
+		}
+		expect(stepThreeGuidance.content.startsWith("[PLAN GUIDANCE — Step 3:")).toBe(true);
+		expect(stepThreeGuidance.options?.deliverAs).toBe("steer");
+
+		await fireDoneStep(harness, 3);
+
+		await fireFailedToolResult(
+			harness,
+			createContext({
+				confirmResponse: true,
+				editorResponse: "This should not be sent after completion.",
+				hasUI: true,
+			})
+		);
+
+		expect(harness.sentUserMessages).toHaveLength(1);
+	});
+});

package/extensions/__integration__/worktree.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createScriptedStreamFn } from "../../test-utils/mock-model.js";
+import { createSessionRunner, type SessionRunner } from "../../test-utils/session-runner.js";
+import worktreeExtension from "../worktree/index.js";
+import { createWorktree, removeWorktree } from "../worktree/lifecycle.js";
+
+/**
+ * Run a git command and return trimmed stdout.
+ *
+ * @param cwd - Working directory
+ * @param args - Git command args
+ * @returns Trimmed stdout
+ */
+function git(cwd: string, ...args: string[]): string {
+	const output = execFileSync("git", args, {
+		cwd,
+		encoding: "utf-8",
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+	return output.trim();
+}
+
+/**
+ * Create a temporary git repo with one commit.
+ *
+ * @returns Repository root path
+ */
+function createTempRepo(): string {
+	const repo = mkdtempSync(join(tmpdir(), "tallow-worktree-integration-"));
+	git(repo, "init");
+	git(repo, "config", "user.email", "test@example.com");
+	git(repo, "config", "user.name", "Test User");
+	writeFileSync(join(repo, "README.md"), "# test\n", "utf-8");
+	git(repo, "add", "README.md");
+	git(repo, "commit", "-m", "init");
+	return repo;
+}
+
+describe("worktree extension integration", () => {
+	let repoRoot = "";
+	let runner: SessionRunner | undefined;
+	let sessionWorktreePath = "";
+	let previousEnv: Record<string, string | undefined> = {};
+
+	beforeEach(() => {
+		repoRoot = createTempRepo();
+		const created = createWorktree(repoRoot, { scope: "session" });
+		sessionWorktreePath = created.worktreePath;
+		previousEnv = {
+			TALLOW_WORKTREE_ORIGINAL_CWD: process.env.TALLOW_WORKTREE_ORIGINAL_CWD,
+			TALLOW_WORKTREE_PATH: process.env.TALLOW_WORKTREE_PATH,
+		};
+		process.env.TALLOW_WORKTREE_ORIGINAL_CWD = repoRoot;
+		process.env.TALLOW_WORKTREE_PATH = sessionWorktreePath;
+	});
+
+	afterEach(() => {
+		runner?.dispose();
+		runner = undefined;
+		removeWorktree(sessionWorktreePath);
+		rmSync(repoRoot, { force: true, recursive: true });
+		if (previousEnv.TALLOW_WORKTREE_ORIGINAL_CWD === undefined) {
+			delete process.env.TALLOW_WORKTREE_ORIGINAL_CWD;
+		} else {
+			process.env.TALLOW_WORKTREE_ORIGINAL_CWD = previousEnv.TALLOW_WORKTREE_ORIGINAL_CWD;
+		}
+		if (previousEnv.TALLOW_WORKTREE_PATH === undefined) {
+			delete process.env.TALLOW_WORKTREE_PATH;
+		} else {
+			process.env.TALLOW_WORKTREE_PATH = previousEnv.TALLOW_WORKTREE_PATH;
+		}
+	});
+
+	it("binds and runs with session worktree metadata enabled", async () => {
+		runner = await createSessionRunner({
+			cwd: sessionWorktreePath,
+			extensionFactories: [worktreeExtension],
+			streamFn: createScriptedStreamFn([{ text: "ok" }]),
+		});
+
+		const result = await runner.run("hello");
+		expect(result.events.length).toBeGreaterThan(0);
+	});
+});

package/extensions/_icons/index.ts

@@ -15,10 +15,9 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Loader } from "@mariozechner/pi-tui";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -141,7 +140,7 @@ export function getSpinner(): string[] {
  * @returns User icon overrides
  */
 function readIconSettings(): IconOverrides {
-	const settingsPath = path.join(os.homedir(), ".tallow", "settings.json");
+	const settingsPath = getTallowSettingsPath();
 	try {
 		const raw = fs.readFileSync(settingsPath, "utf-8");
 		const settings = JSON.parse(raw) as { icons?: IconOverrides };

package/extensions/_shared/inline-preview.ts

@@ -5,8 +5,7 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
+import { getTallowSettingsPath } from "./tallow-paths.js";
 
 // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping ANSI escape sequences
 const ANSI_RE = /\x1b\[[0-9;]*m/g;
@@ -47,8 +46,7 @@ export function extractPreview(output: string, maxLines = 3, maxLineWidth = 80):
  */
 export function isInlineResultsEnabled(): boolean {
 	try {
-		const settingsPath = path.join(os.homedir(), ".tallow", "settings.json");
-		const raw = fs.readFileSync(settingsPath, "utf-8");
+		const raw = fs.readFileSync(getTallowSettingsPath(), "utf-8");
 		const settings = JSON.parse(raw) as { inlineAgentResults?: boolean };
 		return settings.inlineAgentResults !== false;
 	} catch {

package/extensions/_shared/interop-events.ts

@@ -32,6 +32,37 @@ export const INTEROP_API_CHANNELS = {
 /** Valid interop event channel names. */
 export type InteropEventName = (typeof INTEROP_EVENT_NAMES)[keyof typeof INTEROP_EVENT_NAMES];
 
+/** Canonical hook/event-bus names for worktree lifecycle notifications. */
+export const WORKTREE_LIFECYCLE_EVENT_NAMES = {
+	create: "worktree_create",
+	remove: "worktree_remove",
+} as const;
+
+/** Claude-compatible aliases for worktree lifecycle notifications. */
+export const WORKTREE_LIFECYCLE_EVENT_ALIASES = {
+	[WORKTREE_LIFECYCLE_EVENT_NAMES.create]: "WorktreeCreate",
+	[WORKTREE_LIFECYCLE_EVENT_NAMES.remove]: "WorktreeRemove",
+} as const;
+
+/** Valid worktree lifecycle event names. */
+export type WorktreeLifecycleEventName =
+	(typeof WORKTREE_LIFECYCLE_EVENT_NAMES)[keyof typeof WORKTREE_LIFECYCLE_EVENT_NAMES];
+
+/** Valid worktree scopes in lifecycle payloads. */
+export type WorktreeLifecycleScope = "session" | "subagent";
+
+/** TypeBox schema for worktree lifecycle payloads shared across extensions. */
+export const WorktreeLifecyclePayloadSchema = Type.Object({
+	agentId: Type.Optional(Type.String()),
+	repoRoot: Type.String(),
+	scope: Type.Union([Type.Literal("session"), Type.Literal("subagent")]),
+	timestamp: Type.Number(),
+	worktreePath: Type.String(),
+});
+
+/** Typed worktree lifecycle payload. */
+export type WorktreeLifecycleEventPayload = Static<typeof WorktreeLifecyclePayloadSchema>;
+
 const SubagentStatusSchema = Type.Union([
 	Type.Literal("completed"),
 	Type.Literal("failed"),
@@ -158,6 +189,23 @@ export function emitInteropEvent<TName extends InteropEventName>(
 	events.emit(eventName, nextPayload);
 }
 
+/**
+ * Emit canonical and Claude-compatible worktree lifecycle events.
+ *
+ * @param events - Shared extension event bus
+ * @param eventName - Canonical lifecycle event name
+ * @param payload - Worktree lifecycle payload
+ * @returns void
+ */
+export function emitWorktreeLifecycleEvent(
+	events: ExtensionAPI["events"],
+	eventName: WorktreeLifecycleEventName,
+	payload: WorktreeLifecycleEventPayload
+): void {
+	events.emit(eventName, payload);
+	events.emit(WORKTREE_LIFECYCLE_EVENT_ALIASES[eventName], payload);
+}
+
 /**
  * Parse and validate an interop event payload against its schema.
  *

package/extensions/_shared/shell-policy.ts

@@ -28,6 +28,7 @@ import {
 	parseRules,
 } from "./permissions.js";
 import { isProjectTrusted } from "./project-trust.js";
+import { getTallowSettingsPath } from "./tallow-paths.js";
 
 /** Trust classification for shell/process execution sources. */
 export type ShellTrustLevel = "explicit" | "implicit" | "internal";
@@ -454,7 +455,7 @@ export function isShellInterpolationEnabled(cwd: string = process.cwd()): boolea
 	if (process.env.TALLOW_ENABLE_SHELL_INTERPOLATION === "1") return true;
 	if (process.env.TALLOW_SHELL_INTERPOLATION === "1") return true;
 
-	const globalSettingsPath = join(homedir(), ".tallow", "settings.json");
+	const globalSettingsPath = getTallowSettingsPath();
 	const settingsPaths = isProjectTrusted()
 		? [join(cwd, ".tallow", "settings.json"), globalSettingsPath]
 		: [globalSettingsPath];

package/extensions/_shared/tallow-paths.ts

@@ -0,0 +1,48 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Resolve the default tallow home directory when no runtime override is set.
+ *
+ * @returns Absolute path to the default ~/.tallow directory
+ */
+export function getDefaultTallowHomeDir(): string {
+	return join(homedir(), ".tallow");
+}
+
+/**
+ * Resolve the active tallow home directory.
+ *
+ * Priority:
+ * 1. TALLOW_CODING_AGENT_DIR (tallow bootstrap)
+ * 2. PI_CODING_AGENT_DIR (framework compatibility)
+ * 3. ~/.tallow (default)
+ *
+ * @returns Absolute path to the active tallow home directory
+ */
+export function getTallowHomeDir(): string {
+	return (
+		process.env.TALLOW_CODING_AGENT_DIR ??
+		process.env.PI_CODING_AGENT_DIR ??
+		getDefaultTallowHomeDir()
+	);
+}
+
+/**
+ * Resolve a path under the active tallow home directory.
+ *
+ * @param segments - Path segments to append to the home directory
+ * @returns Absolute path under the active tallow home directory
+ */
+export function getTallowPath(...segments: string[]): string {
+	return join(getTallowHomeDir(), ...segments);
+}
+
+/**
+ * Resolve the active global settings path.
+ *
+ * @returns Absolute path to settings.json in the active tallow home
+ */
+export function getTallowSettingsPath(): string {
+	return getTallowPath("settings.json");
+}

package/extensions/agent-commands-tool/__tests__/parsing.test.ts

@@ -5,9 +5,10 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { delimiter, join, resolve } from "node:path";
 import {
 	computeEffectiveTools,
+	getPluginAgentDirsFromEnv,
 	loadAgentsFromDir,
 	PI_BUILTIN_TOOLS,
 	parseAgent,
@@ -136,6 +137,44 @@ describe("resolvePath", () => {
 	});
 });
 
+// ── getPluginAgentDirsFromEnv ───────────────────────────────────────────────
+
+describe("getPluginAgentDirsFromEnv", () => {
+	it("returns empty array for empty input", () => {
+		expect(getPluginAgentDirsFromEnv("")).toEqual([]);
+		expect(getPluginAgentDirsFromEnv(undefined)).toEqual([]);
+	});
+
+	it("parses existing directories with platform delimiter", () => {
+		const root = mkdtempSync(join(tmpdir(), "agent-plugin-dirs-"));
+		try {
+			const a = join(root, "plugin-a", "agents");
+			const b = join(root, "plugin-b", "agents");
+			mkdirSync(a, { recursive: true });
+			mkdirSync(b, { recursive: true });
+
+			const dirs = getPluginAgentDirsFromEnv(`${a}${delimiter}${b}`);
+			expect(dirs).toEqual([resolve(a), resolve(b)]);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("deduplicates and skips missing directories", () => {
+		const root = mkdtempSync(join(tmpdir(), "agent-plugin-dirs-"));
+		try {
+			const a = join(root, "plugin-a", "agents");
+			mkdirSync(a, { recursive: true });
+			const missing = join(root, "missing", "agents");
+
+			const dirs = getPluginAgentDirsFromEnv(`${a}${delimiter}${missing}${delimiter}${a}`);
+			expect(dirs).toEqual([resolve(a)]);
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+});
+
 // ── loadAgentsFromDir ────────────────────────────────────────────────────────
 
 describe("loadAgentsFromDir", () => {

package/extensions/agent-commands-tool/index.ts

@@ -12,6 +12,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getTallowHomeDir } from "../_shared/tallow-paths.js";
 
 export interface AgentFrontmatter {
 	name?: string;
@@ -237,14 +238,42 @@ export function getPackageAgentDirs(settingsPath: string): string[] {
 }
 
 /**
- * Loads agents from user, project, package, and .claude/ directories.
- * Priority: bundled → packages → .claude/user → .tallow/user → .claude/project → .tallow/project
+ * Read plugin agent directories from the SDK-injected env var.
+ *
+ * SDK populates `TALLOW_PLUGIN_AGENTS_DIRS` with absolute `agents/` paths
+ * for resolved Claude-style plugins.
+ *
+ * @param envValue - Optional env value override for tests
+ * @returns Existing agent directories from the env var (deduplicated)
+ */
+export function getPluginAgentDirsFromEnv(envValue?: string): string[] {
+	const raw = (envValue ?? process.env.TALLOW_PLUGIN_AGENTS_DIRS ?? "").trim();
+	if (!raw) return [];
+
+	const seen = new Set<string>();
+	const dirs: string[] = [];
+	for (const dir of raw
+		.split(path.delimiter)
+		.map((v) => v.trim())
+		.filter(Boolean)) {
+		const normalized = path.resolve(dir);
+		if (!fs.existsSync(normalized) || seen.has(normalized)) continue;
+		seen.add(normalized);
+		dirs.push(normalized);
+	}
+
+	return dirs;
+}
+
+/**
+ * Loads agents from user, project, package/plugin, and .claude/ directories.
+ * Priority: bundled → packages/plugins → .claude/user → .tallow/user → .claude/project → .tallow/project
  * Last wins per name, so .tallow/ takes precedence over .claude/.
  *
  * @returns Merged array of unique agents
  */
 function loadAgents(): Agent[] {
-	const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".tallow");
+	const agentDir = getTallowHomeDir();
 	const userDir = path.join(agentDir, "agents");
 	const userClaudeDir = path.join(os.homedir(), ".claude", "agents");
 	const projectDir = path.join(process.cwd(), ".tallow", "agents");
@@ -262,11 +291,14 @@ function loadAgents(): Agent[] {
 	const globalSettingsPath = path.join(agentDir, "settings.json");
 	const projectSettingsPath = path.join(process.cwd(), ".tallow", "settings.json");
 	const packageDirs = [
-		...getPackageAgentDirs(globalSettingsPath),
-		...getPackageAgentDirs(projectSettingsPath),
+		...new Set([
+			...getPackageAgentDirs(globalSettingsPath),
+			...getPackageAgentDirs(projectSettingsPath),
+			...getPluginAgentDirsFromEnv(),
+		]),
 	];
 
-	// Load in priority order: bundled → packages → .claude/user → .tallow/user → .claude/project → .tallow/project
+	// Load in priority order: bundled → packages/plugins → .claude/user → .tallow/user → .claude/project → .tallow/project
 	const agentMap = new Map<string, Agent>();
 	for (const agent of loadAgentsFromDir(bundledDir)) agentMap.set(agent.name, agent);
 	for (const dir of packageDirs) {

package/extensions/background-task-tool/index.ts

@@ -17,7 +17,6 @@
 
 import { type ChildProcess, spawn } from "node:child_process";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import {
 	type ExtensionAPI,
@@ -47,6 +46,7 @@ import {
 } from "../_shared/interop-events.js";
 import { registerPid, unregisterPid } from "../_shared/pid-registry.js";
 import { enforceExplicitPolicy, recordAudit } from "../_shared/shell-policy.js";
+import { getTallowSettingsPath } from "../_shared/tallow-paths.js";
 import {
 	appendSection,
 	dimProcessOutputLine,
@@ -1579,7 +1579,7 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
 	pi.registerCommand("toggle-inline-results", {
 		description: "Toggle inline result notifications for background tasks and subagents",
 		handler: async (_args, ctx) => {
-			const settingsPath = path.join(os.homedir(), ".tallow", "settings.json");
+			const settingsPath = getTallowSettingsPath();
 			let settings: Record<string, unknown> = {};
 			try {
 				const raw = fs.readFileSync(settingsPath, "utf-8");