@oh-my-pi/pi-coding-agent 5.5.0 → 5.6.7

package/src/core/settings-manager.ts

@@ -46,6 +46,10 @@ export interface TerminalSettings {
 	showImages?: boolean; // default: true (only relevant if terminal supports images)
 }
 
+export interface StartupSettings {
+	quiet?: boolean; // default: false - suppress welcome screen and startup info
+}
+
 export interface ImageSettings {
 	autoResize?: boolean; // default: true (resize images to 2000x2000 max for better model compatibility)
 	blockImages?: boolean; // default: false - when true, prevents all images from being sent to LLM providers
@@ -108,6 +112,15 @@ export interface LspSettings {
 	diagnosticsOnEdit?: boolean; // default: false (return LSP diagnostics after edit tool edits code files)
 }
 
+export type PythonToolMode = "ipy-only" | "bash-only" | "both";
+export type PythonKernelMode = "session" | "per-call";
+
+export interface PythonSettings {
+	toolMode?: PythonToolMode;
+	kernelMode?: PythonKernelMode;
+	sharedGateway?: boolean;
+}
+
 export interface EditSettings {
 	fuzzyMatch?: boolean; // default: true (accept high-confidence fuzzy matches for whitespace/indentation)
 }
@@ -194,6 +207,7 @@ export interface Settings {
 	hideThinkingBlock?: boolean;
 	shellPath?: string; // Custom shell path (e.g., for Cygwin users on Windows)
 	collapseChangelog?: boolean; // Show condensed changelog after update (use /changelog for full)
+	startup?: StartupSettings;
 	doubleEscapeAction?: "branch" | "tree"; // Action for double-escape with empty editor (default: "tree")
 	thinkingBudgets?: ThinkingBudgetsSettings; // Custom token budgets for thinking levels
 	/** Environment variables to set automatically on startup */
@@ -210,6 +224,7 @@ export interface Settings {
 	git?: GitSettings;
 	mcp?: MCPSettings;
 	lsp?: LspSettings;
+	python?: PythonSettings;
 	edit?: EditSettings;
 	ttsr?: TtsrSettings;
 	todoCompletion?: TodoCompletionSettings;
@@ -218,6 +233,7 @@ export interface Settings {
 	disabledProviders?: string[]; // Discovery provider IDs that are disabled
 	disabledExtensions?: string[]; // Individual extension IDs that are disabled (e.g., "skill:commit")
 	statusLine?: StatusLineSettings; // Status line configuration
+	showHardwareCursor?: boolean; // Show terminal cursor while still positioning it for IME
 }
 
 export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
@@ -301,6 +317,7 @@ const DEFAULT_SETTINGS: Settings = {
 	git: { enabled: false },
 	mcp: { enableProjectConfig: true },
 	lsp: { formatOnWrite: false, diagnosticsOnWrite: true, diagnosticsOnEdit: false },
+	python: { toolMode: "both", kernelMode: "session", sharedGateway: true },
 	edit: { fuzzyMatch: true },
 	ttsr: { enabled: true, contextMode: "discard", repeatMode: "once", repeatGap: 10 },
 	voice: {
@@ -377,6 +394,25 @@ function normalizeSettings(settings: Settings): Settings {
 		...merged,
 		symbolPreset,
 		bashInterceptor: normalizeBashInterceptorSettings(merged.bashInterceptor),
+		python: normalizePythonSettings(merged.python),
+	};
+}
+
+function normalizePythonSettings(settings: PythonSettings | undefined): PythonSettings {
+	const toolMode = settings?.toolMode;
+	const kernelMode = settings?.kernelMode;
+	const sharedGateway = settings?.sharedGateway;
+	return {
+		toolMode:
+			toolMode === "ipy-only" || toolMode === "bash-only" || toolMode === "both"
+				? toolMode
+				: (DEFAULT_SETTINGS.python?.toolMode ?? "both"),
+		kernelMode:
+			kernelMode === "session" || kernelMode === "per-call"
+				? kernelMode
+				: (DEFAULT_SETTINGS.python?.kernelMode ?? "session"),
+		sharedGateway:
+			typeof sharedGateway === "boolean" ? sharedGateway : (DEFAULT_SETTINGS.python?.sharedGateway ?? true),
 	};
 }
 
@@ -781,6 +817,30 @@ export class SettingsManager {
 		};
 	}
 
+	getRetryMaxRetries(): number {
+		return this.settings.retry?.maxRetries ?? 3;
+	}
+
+	async setRetryMaxRetries(maxRetries: number): Promise<void> {
+		if (!this.globalSettings.retry) {
+			this.globalSettings.retry = {};
+		}
+		this.globalSettings.retry.maxRetries = maxRetries;
+		await this.save();
+	}
+
+	getRetryBaseDelayMs(): number {
+		return this.settings.retry?.baseDelayMs ?? 2000;
+	}
+
+	async setRetryBaseDelayMs(baseDelayMs: number): Promise<void> {
+		if (!this.globalSettings.retry) {
+			this.globalSettings.retry = {};
+		}
+		this.globalSettings.retry.baseDelayMs = baseDelayMs;
+		await this.save();
+	}
+
 	getTodoCompletionSettings(): { enabled: boolean; maxReminders: number } {
 		return {
 			enabled: this.settings.todoCompletion?.enabled ?? false,
@@ -843,6 +903,18 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getStartupQuiet(): boolean {
+		return this.settings.startup?.quiet ?? false;
+	}
+
+	async setStartupQuiet(quiet: boolean): Promise<void> {
+		if (!this.globalSettings.startup) {
+			this.globalSettings.startup = {};
+		}
+		this.globalSettings.startup.quiet = quiet;
+		await this.save();
+	}
+
 	getExtensionPaths(): string[] {
 		return [...(this.settings.extensions ?? [])];
 	}
@@ -883,6 +955,14 @@ export class SettingsManager {
 		return this.settings.skills?.enableSkillCommands ?? true;
 	}
 
+	async setEnableSkillCommands(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.skills) {
+			this.globalSettings.skills = {};
+		}
+		this.globalSettings.skills.enableSkillCommands = enabled;
+		await this.save();
+	}
+
 	getCommandsSettings(): Required<CommandsSettings> {
 		return {
 			enableClaudeUser: this.settings.commands?.enableClaudeUser ?? true,
@@ -890,6 +970,30 @@ export class SettingsManager {
 		};
 	}
 
+	getCommandsEnableClaudeUser(): boolean {
+		return this.settings.commands?.enableClaudeUser ?? true;
+	}
+
+	async setCommandsEnableClaudeUser(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.commands) {
+			this.globalSettings.commands = {};
+		}
+		this.globalSettings.commands.enableClaudeUser = enabled;
+		await this.save();
+	}
+
+	getCommandsEnableClaudeProject(): boolean {
+		return this.settings.commands?.enableClaudeProject ?? true;
+	}
+
+	async setCommandsEnableClaudeProject(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.commands) {
+			this.globalSettings.commands = {};
+		}
+		this.globalSettings.commands.enableClaudeProject = enabled;
+		await this.save();
+	}
+
 	getShowImages(): boolean {
 		return this.settings.terminal?.showImages ?? true;
 	}
@@ -1046,10 +1150,54 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	async setBashInterceptorSimpleLsEnabled(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.bashInterceptor) {
+			this.globalSettings.bashInterceptor = {};
+		}
+		this.globalSettings.bashInterceptor.simpleLs = enabled;
+		await this.save();
+	}
+
 	getGitToolEnabled(): boolean {
 		return this.settings.git?.enabled ?? false;
 	}
 
+	getPythonToolMode(): PythonToolMode {
+		return this.settings.python?.toolMode ?? "both";
+	}
+
+	async setPythonToolMode(mode: PythonToolMode): Promise<void> {
+		if (!this.globalSettings.python) {
+			this.globalSettings.python = {};
+		}
+		this.globalSettings.python.toolMode = mode;
+		await this.save();
+	}
+
+	getPythonKernelMode(): PythonKernelMode {
+		return this.settings.python?.kernelMode ?? "session";
+	}
+
+	async setPythonKernelMode(mode: PythonKernelMode): Promise<void> {
+		if (!this.globalSettings.python) {
+			this.globalSettings.python = {};
+		}
+		this.globalSettings.python.kernelMode = mode;
+		await this.save();
+	}
+
+	getPythonSharedGateway(): boolean {
+		return this.settings.python?.sharedGateway ?? true;
+	}
+
+	async setPythonSharedGateway(enabled: boolean): Promise<void> {
+		if (!this.globalSettings.python) {
+			this.globalSettings.python = {};
+		}
+		this.globalSettings.python.sharedGateway = enabled;
+		await this.save();
+	}
+
 	async setGitToolEnabled(enabled: boolean): Promise<void> {
 		if (!this.globalSettings.git) {
 			this.globalSettings.git = {};
@@ -1244,6 +1392,42 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getVoiceTtsModel(): string {
+		return this.settings.voice?.ttsModel ?? "gpt-4o-mini-tts";
+	}
+
+	async setVoiceTtsModel(model: string): Promise<void> {
+		if (!this.globalSettings.voice) {
+			this.globalSettings.voice = {};
+		}
+		this.globalSettings.voice.ttsModel = model;
+		await this.save();
+	}
+
+	getVoiceTtsVoice(): string {
+		return this.settings.voice?.ttsVoice ?? "alloy";
+	}
+
+	async setVoiceTtsVoice(voice: string): Promise<void> {
+		if (!this.globalSettings.voice) {
+			this.globalSettings.voice = {};
+		}
+		this.globalSettings.voice.ttsVoice = voice;
+		await this.save();
+	}
+
+	getVoiceTtsFormat(): "wav" | "mp3" | "opus" | "aac" | "flac" {
+		return this.settings.voice?.ttsFormat ?? "wav";
+	}
+
+	async setVoiceTtsFormat(format: "wav" | "mp3" | "opus" | "aac" | "flac"): Promise<void> {
+		if (!this.globalSettings.voice) {
+			this.globalSettings.voice = {};
+		}
+		this.globalSettings.voice.ttsFormat = format;
+		await this.save();
+	}
+
 	// ═══════════════════════════════════════════════════════════════════════════
 	// Status Line Settings
 	// ═══════════════════════════════════════════════════════════════════════════
@@ -1374,6 +1558,24 @@ export class SettingsManager {
 		await this.save();
 	}
 
+	getShowHardwareCursor(): boolean {
+		// Check settings first
+		if (this.settings.showHardwareCursor !== undefined) {
+			return this.settings.showHardwareCursor;
+		}
+		// Check env var override
+		const envVar = process.env.OMP_HARDWARE_CURSOR?.toLowerCase();
+		if (envVar === "0" || envVar === "false") return false;
+		if (envVar === "1" || envVar === "true") return true;
+		// Default to true on Linux/macOS for IME support
+		return process.platform === "linux" || process.platform === "darwin";
+	}
+
+	async setShowHardwareCursor(show: boolean): Promise<void> {
+		this.globalSettings.showHardwareCursor = show;
+		await this.save();
+	}
+
 	/**
 	 * Get environment variables from settings
 	 */

package/src/core/streaming-output.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "bun:test";
+import { createOutputSink } from "./streaming-output";
+
+function makeLargeOutput(size: number): string {
+	return "x".repeat(size);
+}
+
+describe("createOutputSink", () => {
+	it("spills to disk and truncates large output", async () => {
+		const largeOutput = makeLargeOutput(60_000);
+		const sink = createOutputSink(10, 70_000);
+		const writer = sink.getWriter();
+
+		await writer.write(largeOutput);
+		await writer.close();
+
+		const result = sink.dump();
+
+		expect(result.truncated).toBe(true);
+		expect(result.fullOutputPath).toBeDefined();
+		expect(result.output.length).toBeLessThan(largeOutput.length);
+
+		const fullOutput = await Bun.file(result.fullOutputPath!).text();
+		expect(fullOutput).toBe(largeOutput);
+	});
+});

package/src/core/streaming-output.ts

@@ -0,0 +1,100 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { nanoid } from "nanoid";
+import stripAnsi from "strip-ansi";
+import { sanitizeBinaryOutput } from "../utils/shell";
+import { truncateTail } from "./tools/truncate";
+
+interface OutputFileSink {
+	write(data: string): number | Promise<number>;
+	end(): void;
+}
+
+export function createSanitizer(): TransformStream<Uint8Array, string> {
+	const decoder = new TextDecoder();
+	const sanitizeText = (text: string) => sanitizeBinaryOutput(stripAnsi(text)).replace(/\r/g, "");
+	return new TransformStream({
+		transform(chunk, controller) {
+			const text = sanitizeText(decoder.decode(chunk, { stream: true }));
+			if (text) {
+				controller.enqueue(text);
+			}
+		},
+		flush(controller) {
+			const text = sanitizeText(decoder.decode());
+			if (text) {
+				controller.enqueue(text);
+			}
+		},
+	});
+}
+
+export async function pumpStream(readable: ReadableStream<Uint8Array>, writer: WritableStreamDefaultWriter<string>) {
+	const reader = readable.pipeThrough(createSanitizer()).getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			await writer.write(value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+export function createOutputSink(
+	spillThreshold: number,
+	maxBuffer: number,
+	onChunk?: (text: string) => void,
+): WritableStream<string> & {
+	dump: (annotation?: string) => { output: string; truncated: boolean; fullOutputPath?: string };
+} {
+	const chunks: Array<{ text: string; bytes: number }> = [];
+	let chunkBytes = 0;
+	let totalBytes = 0;
+	let fullOutputPath: string | undefined;
+	let fullOutputStream: OutputFileSink | undefined;
+
+	const sink = new WritableStream<string>({
+		write(text) {
+			const bytes = Buffer.byteLength(text, "utf-8");
+			totalBytes += bytes;
+
+			if (totalBytes > spillThreshold && !fullOutputPath) {
+				fullOutputPath = join(tmpdir(), `omp-${nanoid()}.buffer`);
+				const stream = Bun.file(fullOutputPath).writer();
+				for (const chunk of chunks) {
+					stream.write(chunk.text);
+				}
+				fullOutputStream = stream;
+			}
+			fullOutputStream?.write(text);
+
+			chunks.push({ text, bytes });
+			chunkBytes += bytes;
+			while (chunkBytes > maxBuffer && chunks.length > 1) {
+				const removed = chunks.shift();
+				if (removed) {
+					chunkBytes -= removed.bytes;
+				}
+			}
+
+			onChunk?.(text);
+		},
+		close() {
+			fullOutputStream?.end();
+		},
+	});
+
+	return Object.assign(sink, {
+		dump(annotation?: string) {
+			if (annotation) {
+				const text = `\n\n${annotation}`;
+				chunks.push({ text, bytes: Buffer.byteLength(text, "utf-8") });
+			}
+			const full = chunks.map((chunk) => chunk.text).join("");
+			const { content, truncated } = truncateTail(full);
+			return { output: truncated ? content : full, truncated, fullOutputPath };
+		},
+	});
+}

package/src/core/system-prompt.python.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "bun:test";
+import { buildSystemPrompt } from "./system-prompt";
+
+describe("buildSystemPrompt", () => {
+	it("includes python tool details when enabled", async () => {
+		const prompt = await buildSystemPrompt({
+			cwd: "/tmp",
+			toolNames: ["python"],
+			contextFiles: [],
+			skills: [],
+			rules: [],
+		});
+
+		expect(prompt).toContain("python: Execute Python code via a session-backed IPython kernel");
+		expect(prompt).toContain("What python IS for");
+	});
+});

package/src/core/system-prompt.ts

@@ -76,6 +76,7 @@ const toolDescriptions: Record<ToolName, string> = {
 	ask: "Ask user for input or clarification",
 	read: "Read file contents",
 	bash: "Execute bash commands (npm, docker, etc.)",
+	python: "Execute Python code via a session-backed IPython kernel",
 	calc: "{ calculations: array of { expression: string, prefix: string, suffix: string } } Basic calculations.",
 	ssh: "Execute commands on remote hosts via SSH",
 	edit: "Make surgical edits to files (find exact text and replace)",
@@ -672,7 +673,8 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 
 	// Build tool descriptions array
 	// Priority: toolNames (explicit list) > tools (Map) > defaults
-	const defaultToolNames: ToolName[] = ["read", "bash", "edit", "write"];
+	// Default includes both bash and python; actual availability determined by settings in createTools
+	const defaultToolNames: ToolName[] = ["read", "bash", "python", "edit", "write"];
 	let toolNamesArray: string[];
 	if (toolNames !== undefined) {
 		// Explicit toolNames list provided (could be empty)

package/src/core/timings.ts

@@ -3,7 +3,7 @@
  * Enable with OMP_TIMING=1 or PI_TIMING=1 environment variable.
  */
 
-const ENABLED = process.env.OMP_TIMING === "1" || process.env.PI_TIMING === "1";
+const ENABLED = process.env.OMP_TIMING === "1";
 const timings: Array<{ label: string; ms: number }> = [];
 let lastTime = Date.now();
 

package/src/core/tools/bash.ts

@@ -178,6 +178,8 @@ interface BashRenderContext {
 	expanded?: boolean;
 	/** Number of preview lines when collapsed */
 	previewLines?: number;
+	/** Timeout in seconds */
+	timeout?: number;
 }
 
 // Preview line limit when not expanded (matches tool-execution behavior)
@@ -236,6 +238,11 @@ export const bashToolRenderer = {
 		// Build truncation warning lines (static, doesn't depend on width)
 		const truncation = details?.truncation;
 		const fullOutputPath = details?.fullOutputPath;
+		const timeoutSeconds = renderContext?.timeout;
+		const timeoutLine =
+			typeof timeoutSeconds === "number"
+				? uiTheme.fg("dim", ui.wrapBrackets(`Timeout: ${timeoutSeconds}s`))
+				: undefined;
 		let warningLine: string | undefined;
 		if (fullOutputPath || (truncation?.truncated && !showingFullOutput)) {
 			const warnings: string[] = [];
@@ -258,7 +265,8 @@ export const bashToolRenderer = {
 
 		if (!displayOutput) {
 			// No output - just show warning if any
-			return new Text(warningLine ?? "", 0, 0);
+			const lines = [timeoutLine, warningLine].filter(Boolean) as string[];
+			return new Text(lines.join("\n"), 0, 0);
 		}
 
 		if (expanded) {
@@ -267,7 +275,7 @@ export const bashToolRenderer = {
 				.split("\n")
 				.map((line) => uiTheme.fg("toolOutput", line))
 				.join("\n");
-			const lines = warningLine ? [styledOutput, warningLine] : [styledOutput];
+			const lines = [styledOutput, timeoutLine, warningLine].filter(Boolean) as string[];
 			return new Text(lines.join("\n"), 0, 0);
 		}
 
@@ -300,6 +308,9 @@ export const bashToolRenderer = {
 					outputLines.push(truncateToWidth(skippedLine, width, uiTheme.fg("dim", uiTheme.format.ellipsis)));
 				}
 				outputLines.push(...cachedLines);
+				if (timeoutLine) {
+					outputLines.push(truncateToWidth(timeoutLine, width, uiTheme.fg("dim", uiTheme.format.ellipsis)));
+				}
 				if (warningLine) {
 					outputLines.push(truncateToWidth(warningLine, width, uiTheme.fg("warning", uiTheme.format.ellipsis)));
 				}

package/src/core/tools/edit-diff.ts

@@ -80,6 +80,13 @@ function computeRelativeIndentDepths(lines: string[]): number[] {
 	});
 }
 
+function normalizeFuzzyText(text: string): string {
+	return text
+		.replace(/[“”„‟«»]/g, '"')
+		.replace(/[‘’‚‛`´]/g, "'")
+		.replace(/[‐‑‒–—−]/g, "-");
+}
+
 function normalizeLinesForMatch(lines: string[], includeDepth = true): string[] {
 	const indentDepths = includeDepth ? computeRelativeIndentDepths(lines) : null;
 	return lines.map((line, index) => {
@@ -88,7 +95,8 @@ function normalizeLinesForMatch(lines: string[], includeDepth = true): string[]
 		if (trimmed.length === 0) {
 			return prefix;
 		}
-		const collapsed = trimmed.replace(/[ \t]+/g, " ");
+		const normalized = normalizeFuzzyText(trimmed);
+		const collapsed = normalized.replace(/[ \t]+/g, " ");
 		return `${prefix}${collapsed}`;
 	});
 }

package/src/core/tools/index.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it } from "bun:test";
 import { BUILTIN_TOOLS, createTools, HIDDEN_TOOLS, type ToolSession } from "./index";
 
+process.env.OMP_PYTHON_SKIP_CHECK = "1";
+
 function createTestSession(overrides: Partial<ToolSession> = {}): ToolSession {
 	return {
 		cwd: "/tmp/test",
@@ -11,6 +13,21 @@ function createTestSession(overrides: Partial<ToolSession> = {}): ToolSession {
 	};
 }
 
+function createBaseSettings(overrides: Partial<NonNullable<ToolSession["settings"]>> = {}) {
+	return {
+		getImageAutoResize: () => true,
+		getLspFormatOnWrite: () => true,
+		getLspDiagnosticsOnWrite: () => true,
+		getLspDiagnosticsOnEdit: () => false,
+		getEditFuzzyMatch: () => true,
+		getGitToolEnabled: () => true,
+		getBashInterceptorEnabled: () => true,
+		getBashInterceptorSimpleLsEnabled: () => true,
+		getBashInterceptorRules: () => [],
+		...overrides,
+	};
+}
+
 describe("createTools", () => {
 	it("creates all builtin tools by default", async () => {
 		const session = createTestSession();
@@ -18,7 +35,8 @@ describe("createTools", () => {
 		const names = tools.map((t) => t.name);
 
 		// Core tools should always be present
-		expect(names).toContain("bash");
+		expect(names).toContain("python");
+		expect(names).not.toContain("bash");
 		expect(names).toContain("calc");
 		expect(names).toContain("read");
 		expect(names).toContain("edit");
@@ -35,6 +53,34 @@ describe("createTools", () => {
 		expect(names).toContain("web_search");
 	});
 
+	it("includes bash and python when python mode is both", async () => {
+		const session = createTestSession({
+			settings: createBaseSettings({
+				getPythonToolMode: () => "both",
+				getPythonKernelMode: () => "session",
+			}),
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("bash");
+		expect(names).toContain("python");
+	});
+
+	it("includes bash only when python mode is bash-only", async () => {
+		const session = createTestSession({
+			settings: createBaseSettings({
+				getPythonToolMode: () => "bash-only",
+				getPythonKernelMode: () => "session",
+			}),
+		});
+		const tools = await createTools(session);
+		const names = tools.map((t) => t.name);
+
+		expect(names).toContain("bash");
+		expect(names).not.toContain("python");
+	});
+
 	it("excludes lsp tool when session disables LSP", async () => {
 		const session = createTestSession({ enableLsp: false });
 		const tools = await createTools(session, ["read", "lsp", "write"]);
@@ -93,17 +139,7 @@ describe("createTools", () => {
 
 	it("excludes git tool when disabled in settings", async () => {
 		const session = createTestSession({
-			settings: {
-				getImageAutoResize: () => true,
-				getLspFormatOnWrite: () => true,
-				getLspDiagnosticsOnWrite: () => true,
-				getLspDiagnosticsOnEdit: () => false,
-				getEditFuzzyMatch: () => true,
-				getGitToolEnabled: () => false,
-				getBashInterceptorEnabled: () => true,
-				getBashInterceptorSimpleLsEnabled: () => true,
-				getBashInterceptorRules: () => [],
-			},
+			settings: createBaseSettings({ getGitToolEnabled: () => false }),
 		});
 		const tools = await createTools(session);
 		const names = tools.map((t) => t.name);
@@ -113,17 +149,7 @@ describe("createTools", () => {
 
 	it("includes git tool when enabled in settings", async () => {
 		const session = createTestSession({
-			settings: {
-				getImageAutoResize: () => true,
-				getLspFormatOnWrite: () => true,
-				getLspDiagnosticsOnWrite: () => true,
-				getLspDiagnosticsOnEdit: () => false,
-				getEditFuzzyMatch: () => true,
-				getGitToolEnabled: () => true,
-				getBashInterceptorEnabled: () => true,
-				getBashInterceptorSimpleLsEnabled: () => true,
-				getBashInterceptorRules: () => [],
-			},
+			settings: createBaseSettings({ getGitToolEnabled: () => true }),
 		});
 		const tools = await createTools(session);
 		const names = tools.map((t) => t.name);
@@ -153,6 +179,7 @@ describe("createTools", () => {
 		const expectedTools = [
 			"ask",
 			"bash",
+			"python",
 			"calc",
 			"ssh",
 			"edit",