@oh-my-pi/pi-coding-agent 13.18.0 → 13.19.0

package/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## [Unreleased]
 
+## [13.19.0] - 2026-04-05
+### Added
+
+- Added idle auto-compaction settings and scheduling so sessions can compact after inactive turns without auto-continuing.
+- Added `onExternalEditor` callback to extension UI dialog options for handling external editor shortcut in select dialogs
+- Added external editor shortcut support in plan review selector, allowing users to open and edit the plan in their configured editor
+- Added `matchesAppExternalEditor` keybinding matcher to detect external editor shortcut (Ctrl+G or configured binding)
+- Added `trimTrailingNewline` option to `openInEditor` function to preserve trailing newlines when editing files
+- Added GitHub CLI utilities to git module (`utils/git.github`) with `available()`, `run()`, `json()`, and `text()` methods for GitHub CLI operations
+- Exported git utilities from main package entry point for use by extensions
+- Added comprehensive git utility module (`utils/git`) with organized namespaces for common git operations (branch, commit, diff, log, patch, ref, stage, status, head, repository)
+
+### Changed
+
+- Changed idle compaction settings (`compaction.idleThresholdTokens` and `compaction.idleTimeoutSeconds`) from enum to numeric type for flexible configuration
+- Modified secret obfuscation to deobfuscate restored session messages for local display while keeping outbound LLM messages obfuscated
+- Updated stash pop operation to preserve staged changes with `--index` flag when restoring after task branch merges
+- Changed secret placeholders to deterministic hash-style redaction tokens and deobfuscated assistant output for local display.
+- Updated hook editor and hook selector components to use `matchesAppExternalEditor` matcher for consistent external editor keybinding detection
+- Modified plan review flow to read the latest plan content from disk before approval, allowing changes made in external editor to be reflected
+- Enhanced plan review help text to dynamically display the configured external editor keybinding
+- Refactored git operations to use centralized utility module instead of `ControlledGit` class throughout codebase
+- Replaced `ControlledGit` dependency injection pattern with direct `cwd` parameter in commit agent tools
+- Migrated git HEAD resolution in footer and status-line components to use new synchronous and asynchronous utilities
+- Updated git status summary calculation in status-line component to use new git utility API
+- Simplified git branch operations in task execution and cleanup to use new utility functions
+- Refactored patch application logic in task worktree to use new git patch utilities
+
+### Removed
+
+- Removed `gh-cli.ts` module; GitHub CLI functionality now available via `utils/git.github`
+- Removed `ControlledGit` class and associated git wrapper infrastructure from `commit/git` module
+- Removed `mergeStdoutStderr` helper function from autoresearch git utilities
+- Removed `findGitHeadPathAsync` and `findGitHeadPathSync` from modes/shared module (replaced by git utilities)
+- Removed `./commit/git` export from package.json (internal diff parsing still available via `./commit/git/*`)
+
+### Fixed
+
+- Fixed idle compaction timer to properly cancel when event controller is disposed, preventing memory leaks
+- Fixed session resumption to preserve the last non-empty session when starting a fresh session
+- Fixed stash detection to use git ref resolution instead of output parsing for reliable stash state tracking
+- Fixed isolated task merge-back to preserve task outputs on merge failure and stash dirty worktrees before cherry-pick.
+- Fixed web search source rendering to truncate long title, metadata, and URL lines before they overflow the UI.
+- Fixed PR checkout tool to resolve symlinks in worktree paths, ensuring consistent path references in results and metadata
+- Fixed `read` output for file-backed internal URLs like `local://...` to include hashline prefixes in hashline edit mode, preserving usable line refs for follow-up edits
+- Fixed the plan review selector to support the external editor shortcut for opening and updating the current plan from the approval screen
+
 ## [13.18.0] - 2026-04-02
 ### Breaking Changes
 
@@ -354,6 +401,9 @@
 
 - Fixed resumed and session-switched GitHub Copilot/OpenAI Responses conversations replaying stale assistant native history from older saved sessions by sanitizing persisted assistant replay metadata on rehydration and resetting provider session state across live session boundaries ([#505](https://github.com/can1357/oh-my-pi/issues/505))
 
+### Added
+
+- Session observer overlay (`Ctrl+S`): view running subagent sessions with a picker and read-only transcript showing thinking, text, tool calls, and results
 ## [13.14.0] - 2026-03-20
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.18.0",
+	"version": "13.19.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -42,12 +42,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.18.0",
-		"@oh-my-pi/pi-agent-core": "13.18.0",
-		"@oh-my-pi/pi-ai": "13.18.0",
-		"@oh-my-pi/pi-natives": "13.18.0",
-		"@oh-my-pi/pi-tui": "13.18.0",
-		"@oh-my-pi/pi-utils": "13.18.0",
+		"@oh-my-pi/omp-stats": "13.19.0",
+		"@oh-my-pi/pi-agent-core": "13.19.0",
+		"@oh-my-pi/pi-ai": "13.19.0",
+		"@oh-my-pi/pi-natives": "13.19.0",
+		"@oh-my-pi/pi-tui": "13.19.0",
+		"@oh-my-pi/pi-utils": "13.19.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",
@@ -146,10 +146,6 @@
 			"types": "./src/commit/changelog/*.ts",
 			"import": "./src/commit/changelog/*.ts"
 		},
-		"./commit/git": {
-			"types": "./src/commit/git/index.ts",
-			"import": "./src/commit/git/index.ts"
-		},
 		"./commit/git/*": {
 			"types": "./src/commit/git/*.ts",
 			"import": "./src/commit/git/*.ts"

package/src/autoresearch/git.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "../extensibility/extensions";
+import * as git from "../utils/git";
 import { isAutoresearchLocalStatePath, normalizeAutoresearchPath } from "./helpers";
 
 const AUTORESEARCH_BRANCH_PREFIX = "autoresearch/";
@@ -17,9 +18,8 @@ export interface EnsureAutoresearchBranchSuccess {
 
 export type EnsureAutoresearchBranchResult = EnsureAutoresearchBranchFailure | EnsureAutoresearchBranchSuccess;
 
-export async function getCurrentAutoresearchBranch(api: ExtensionAPI, workDir: string): Promise<string | null> {
-	const currentBranchResult = await api.exec("git", ["branch", "--show-current"], { cwd: workDir, timeout: 5_000 });
-	const currentBranch = currentBranchResult.stdout.trim();
+export async function getCurrentAutoresearchBranch(_api: ExtensionAPI, workDir: string): Promise<string | null> {
+	const currentBranch = (await git.branch.current(workDir)) ?? "";
 	return currentBranch.startsWith(AUTORESEARCH_BRANCH_PREFIX) ? currentBranch : null;
 }
 
@@ -28,28 +28,30 @@ export async function ensureAutoresearchBranch(
 	workDir: string,
 	goal: string | null,
 ): Promise<EnsureAutoresearchBranchResult> {
-	const repoRootResult = await api.exec("git", ["rev-parse", "--show-toplevel"], { cwd: workDir, timeout: 5_000 });
-	if (repoRootResult.code !== 0) {
+	const repoRoot = await git.repo.root(workDir);
+	if (!repoRoot) {
 		return {
 			error: "Autoresearch requires a git repository so it can isolate experiments and revert failed runs safely.",
 			ok: false,
 		};
 	}
-	const repoRoot = repoRootResult.stdout.trim() || workDir;
 
-	const dirtyPathsResult = await api.exec("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], {
-		cwd: repoRoot,
-		timeout: 5_000,
-	});
-	if (dirtyPathsResult.code !== 0) {
+	let dirtyPathsOutput: string;
+	try {
+		dirtyPathsOutput = await git.status(repoRoot, {
+			porcelainV1: true,
+			untrackedFiles: "all",
+			z: true,
+		});
+	} catch (err) {
 		return {
-			error: `Unable to inspect git status before starting autoresearch: ${mergeStdoutStderr(dirtyPathsResult).trim() || `exit ${dirtyPathsResult.code}`}`,
+			error: `Unable to inspect git status before starting autoresearch: ${err instanceof Error ? err.message : String(err)}`,
 			ok: false,
 		};
 	}
 
 	const workDirPrefix = await readGitWorkDirPrefix(api, workDir);
-	const unsafeDirtyPaths = collectUnsafeDirtyPaths(dirtyPathsResult.stdout, workDirPrefix);
+	const unsafeDirtyPaths = collectUnsafeDirtyPaths(dirtyPathsOutput, workDirPrefix);
 	const currentBranch = await getCurrentAutoresearchBranch(api, workDir);
 	if (currentBranch) {
 		if (unsafeDirtyPaths.length > 0) {
@@ -66,12 +68,11 @@ export async function ensureAutoresearchBranch(
 	}
 
 	const branchName = await allocateBranchName(api, workDir, goal);
-	const checkoutResult = await api.exec("git", ["checkout", "-b", branchName], { cwd: workDir, timeout: 10_000 });
-	if (checkoutResult.code !== 0) {
+	try {
+		await git.branch.checkoutNew(workDir, branchName);
+	} catch (err) {
 		return {
-			error:
-				`Failed to create autoresearch branch ${branchName}: ` +
-				`${mergeStdoutStderr(checkoutResult).trim() || `exit ${checkoutResult.code}`}`,
+			error: `Failed to create autoresearch branch ${branchName}: ${err instanceof Error ? err.message : String(err)}`,
 			ok: false,
 		};
 	}
@@ -109,11 +110,12 @@ export function relativizeGitPathToWorkDir(repoRelativePath: string, workDirPref
 }
 
 async function readGitWorkDirPrefix(api: ExtensionAPI, workDir: string): Promise<string> {
-	const prefixResult = await api.exec("git", ["rev-parse", "--show-prefix"], { cwd: workDir, timeout: 5_000 });
-	if (prefixResult.code !== 0) {
+	void api;
+	try {
+		return await git.show.prefix(workDir);
+	} catch {
 		return "";
 	}
-	return prefixResult.stdout.trim();
 }
 
 export function parseDirtyPaths(statusOutput: string): string[] {
@@ -180,11 +182,8 @@ async function allocateBranchName(api: ExtensionAPI, workDir: string, goal: stri
 }
 
 async function branchExists(api: ExtensionAPI, workDir: string, branchName: string): Promise<boolean> {
-	const result = await api.exec("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], {
-		cwd: workDir,
-		timeout: 5_000,
-	});
-	return result.code === 0;
+	void api;
+	return git.ref.exists(workDir, `refs/heads/${branchName}`);
 }
 
 function slugifyGoal(goal: string | null): string {
@@ -204,10 +203,6 @@ function currentDateStamp(): string {
 	return `${year}${month}${day}`;
 }
 
-function mergeStdoutStderr(result: { stderr: string; stdout: string }): string {
-	return `${result.stdout}${result.stderr}`;
-}
-
 function addDirtyPath(paths: Set<string>, rawPath: string): void {
 	const normalizedPath = normalizeStatusPath(rawPath);
 	if (normalizedPath.length === 0) return;

package/src/autoresearch/tools/log-experiment.ts

@@ -7,6 +7,7 @@ import { Type } from "@sinclair/typebox";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
 import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
+import * as git from "../../utils/git";
 import { getAutoresearchFingerprintMismatchError, pathMatchesContractPath } from "../contract";
 import { getCurrentAutoresearchBranch, parseWorkDirDirtyPaths } from "../git";
 import {
@@ -493,7 +494,7 @@ function validateObservedStatus(
 }
 
 async function commitKeptExperiment(
-	options: AutoresearchToolFactoryOptions,
+	_options: AutoresearchToolFactoryOptions,
 	workDir: string,
 	state: ExperimentState,
 	experiment: ExperimentResult,
@@ -503,25 +504,15 @@ async function commitKeptExperiment(
 		return { note: "nothing to commit" };
 	}
 
-	const addResult = await options.pi.exec("git", ["add", "--all", "--", ...scopeValidation.committablePaths], {
-		cwd: workDir,
-		timeout: 10_000,
-	});
-	if (addResult.code !== 0) {
+	try {
+		await git.stage.files(workDir, scopeValidation.committablePaths);
+	} catch (err) {
 		return {
-			error: `git add failed: ${mergeStdoutStderr(addResult).trim() || `exit ${addResult.code}`}`,
+			error: `git add failed: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
 
-	const diffResult = await options.pi.exec(
-		"git",
-		["diff", "--cached", "--quiet", "--", ...scopeValidation.committablePaths],
-		{
-			cwd: workDir,
-			timeout: 10_000,
-		},
-	);
-	if (diffResult.code === 0) {
+	if (!(await git.diff.has(workDir, { cached: true, files: scopeValidation.committablePaths }))) {
 		return { note: "nothing to commit" };
 	}
 
@@ -533,32 +524,23 @@ async function commitKeptExperiment(
 		payload[name] = value;
 	}
 	const commitMessage = `${experiment.description}\n\nResult: ${JSON.stringify(payload)}`;
-	const commitResult = await options.pi.exec(
-		"git",
-		["commit", "-m", commitMessage, "--", ...scopeValidation.committablePaths],
-		{
-			cwd: workDir,
-			timeout: 10_000,
-		},
-	);
-	if (commitResult.code !== 0) {
+	let commitResultText = "";
+	try {
+		const commitResult = await git.commit(workDir, commitMessage, {
+			files: scopeValidation.committablePaths,
+		});
+		commitResultText = mergeStdoutStderr(commitResult);
+	} catch (err) {
 		return {
-			error: `git commit failed: ${mergeStdoutStderr(commitResult).trim() || `exit ${commitResult.code}`}`,
+			error: `git commit failed: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
 
-	const revParseResult = await options.pi.exec("git", ["rev-parse", "--short=7", "HEAD"], {
-		cwd: workDir,
-		timeout: 5_000,
-	});
-	const newCommit = revParseResult.stdout.trim();
+	const newCommit = (await git.head.short(workDir, 7)) ?? "";
 	if (newCommit.length >= 7) {
 		experiment.commit = newCommit;
 	}
-	const summaryLine =
-		mergeStdoutStderr(commitResult)
-			.split("\n")
-			.find(line => line.trim().length > 0) ?? "committed";
+	const summaryLine = commitResultText.split("\n").find(line => line.trim().length > 0) ?? "committed";
 	return { note: summaryLine.trim() };
 }
 
@@ -567,44 +549,46 @@ async function revertFailedExperiment(
 	workDir: string,
 ): Promise<KeepCommitResult> {
 	const preservedFiles = preserveAutoresearchFiles(workDir);
-	const restoreResult = await options.pi.exec(
-		"git",
-		["restore", "--source=HEAD", "--staged", "--worktree", "--", "."],
-		{ cwd: workDir, timeout: 10_000 },
-	);
-	const cleanResult = await options.pi.exec("git", ["clean", "-fd", "--", "."], { cwd: workDir, timeout: 10_000 });
-	const cleanIgnoredResult = await options.pi.exec("git", ["clean", "-fdX", "--", "."], {
-		cwd: workDir,
-		timeout: 10_000,
-	});
-	restoreAutoresearchFiles(preservedFiles);
-	if (restoreResult.code !== 0) {
+	try {
+		await git.restore(workDir, { files: ["."], source: "HEAD", staged: true, worktree: true });
+	} catch (err) {
+		restoreAutoresearchFiles(preservedFiles);
 		return {
-			error: `git restore failed: ${mergeStdoutStderr(restoreResult).trim() || `exit ${restoreResult.code}`}`,
+			error: `git restore failed: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
-	if (cleanResult.code !== 0) {
+	try {
+		await git.clean(workDir, { paths: ["."] });
+	} catch (err) {
+		restoreAutoresearchFiles(preservedFiles);
 		return {
-			error: `git clean failed: ${mergeStdoutStderr(cleanResult).trim() || `exit ${cleanResult.code}`}`,
+			error: `git clean failed: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
-	if (cleanIgnoredResult.code !== 0) {
+	try {
+		await git.clean(workDir, { ignoredOnly: true, paths: ["."] });
+	} catch (err) {
+		restoreAutoresearchFiles(preservedFiles);
 		return {
-			error: `git clean -X failed: ${mergeStdoutStderr(cleanIgnoredResult).trim() || `exit ${cleanIgnoredResult.code}`}`,
+			error: `git clean -X failed: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
-	const dirtyCheckResult = await options.pi.exec(
-		"git",
-		["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."],
-		{ cwd: workDir, timeout: 10_000 },
-	);
-	if (dirtyCheckResult.code !== 0) {
+	restoreAutoresearchFiles(preservedFiles);
+	let dirtyStatus = "";
+	try {
+		dirtyStatus = await git.status(workDir, {
+			pathspecs: ["."],
+			porcelainV1: true,
+			untrackedFiles: "all",
+			z: true,
+		});
+	} catch (err) {
 		return {
-			error: `git status failed after cleanup: ${mergeStdoutStderr(dirtyCheckResult).trim() || `exit ${dirtyCheckResult.code}`}`,
+			error: `git status failed after cleanup: ${err instanceof Error ? err.message : String(err)}`,
 		};
 	}
 	const workDirPrefix = await readGitWorkDirPrefix(options, workDir);
-	const remainingDirtyPaths = parseWorkDirDirtyPaths(dirtyCheckResult.stdout, workDirPrefix).filter(
+	const remainingDirtyPaths = parseWorkDirDirtyPaths(dirtyStatus, workDirPrefix).filter(
 		relativePath => !isAutoresearchLocalStatePath(relativePath),
 	);
 	if (remainingDirtyPaths.length > 0) {
@@ -654,21 +638,21 @@ async function validateKeepPaths(
 		return "Files in Scope is empty for the current segment. Re-run init_experiment after fixing autoresearch.md.";
 	}
 
-	const statusResult = await options.pi.exec(
-		"git",
-		["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."],
-		{
-			cwd: workDir,
-			timeout: 10_000,
-		},
-	);
-	if (statusResult.code !== 0) {
-		return `git status failed: ${mergeStdoutStderr(statusResult).trim() || `exit ${statusResult.code}`}`;
+	let statusText: string;
+	try {
+		statusText = await git.status(workDir, {
+			pathspecs: ["."],
+			porcelainV1: true,
+			untrackedFiles: "all",
+			z: true,
+		});
+	} catch (err) {
+		return `git status failed: ${err instanceof Error ? err.message : String(err)}`;
 	}
 
 	const workDirPrefix = await readGitWorkDirPrefix(options, workDir);
 	const committablePaths: string[] = [];
-	for (const normalizedPath of parseWorkDirDirtyPaths(statusResult.stdout, workDirPrefix)) {
+	for (const normalizedPath of parseWorkDirDirtyPaths(statusText, workDirPrefix)) {
 		if (isAutoresearchLocalStatePath(normalizedPath)) {
 			continue;
 		}
@@ -808,9 +792,12 @@ function buildLogText(
 }
 
 async function readGitWorkDirPrefix(options: AutoresearchToolFactoryOptions, workDir: string): Promise<string> {
-	const prefixResult = await options.pi.exec("git", ["rev-parse", "--show-prefix"], { cwd: workDir, timeout: 5_000 });
-	if (prefixResult.code !== 0) return "";
-	return prefixResult.stdout.trim();
+	void options;
+	try {
+		return await git.show.prefix(workDir);
+	} catch {
+		return "";
+	}
 }
 
 function truncateAsiValue(value: ASIData[string]): string {

package/src/commit/agentic/agent.ts

@@ -2,7 +2,6 @@ import { INTENT_FIELD, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { Markdown } from "@oh-my-pi/pi-tui";
 import chalk from "chalk";
-import type { ControlledGit } from "../../commit/git";
 import typesDescriptionPrompt from "../../commit/prompts/types-description.md" with { type: "text" };
 import type { ModelRegistry } from "../../config/model-registry";
 import { renderPromptTemplate } from "../../config/prompt-templates";
@@ -18,7 +17,6 @@ import { createCommitTools } from "./tools";
 
 export interface CommitAgentInput {
 	cwd: string;
-	git: ControlledGit;
 	model: Model<Api>;
 	thinkingLevel?: ThinkingLevel;
 	settings: Settings;
@@ -46,7 +44,6 @@ export async function runCommitAgentSession(input: CommitAgentInput): Promise<Co
 	const spawns = "quick_task";
 	const tools = createCommitTools({
 		cwd: input.cwd,
-		git: input.git,
 		authStorage: input.authStorage,
 		modelRegistry: input.modelRegistry,
 		settings: input.settings,

package/src/commit/agentic/index.ts

@@ -4,7 +4,6 @@ import { $env, getProjectDir, isEnoent } from "@oh-my-pi/pi-utils";
 import { applyChangelogProposals } from "../../commit/changelog";
 import { detectChangelogBoundaries } from "../../commit/changelog/detect";
 import { parseUnreleasedSection } from "../../commit/changelog/parse";
-import { ControlledGit } from "../../commit/git";
 import { formatCommitMessage } from "../../commit/message";
 import { resolvePrimaryModel, resolveSmolModel } from "../../commit/model-selection";
 import type { CommitCommandArgs, ConventionalAnalysis } from "../../commit/types";
@@ -12,6 +11,7 @@ import { ModelRegistry } from "../../config/model-registry";
 import { renderPromptTemplate } from "../../config/prompt-templates";
 import { Settings } from "../../config/settings";
 import { discoverAuthStorage, discoverContextFiles } from "../../sdk";
+import * as git from "../../utils/git";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
 import splitConfirmPrompt from "./prompts/split-confirm.md" with { type: "text" };
@@ -20,25 +20,24 @@ import { computeDependencyOrder } from "./topo-sort";
 import { detectTrivialChange } from "./trivial";
 
 interface CommitExecutionContext {
-	git: ControlledGit;
+	cwd: string;
 	dryRun: boolean;
 	push: boolean;
 }
 
 export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const cwd = getProjectDir();
-	const git = new ControlledGit(cwd);
 	const [settings, authStorage] = await Promise.all([Settings.init({ cwd }), discoverAuthStorage()]);
 
 	process.stdout.write("● Resolving model...\n");
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
 	const stagedFilesPromise = (async () => {
-		let stagedFiles = await git.getStagedFiles();
+		let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		if (stagedFiles.length === 0) {
 			process.stdout.write("No staged changes detected, staging all changes...\n");
-			await git.stageAll();
-			stagedFiles = await git.getStagedFiles();
+			await git.stage.files(cwd);
+			stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		}
 		return stagedFiles;
 	})();
@@ -66,8 +65,8 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const [changelogBoundaries, contextFiles, numstat, diff] = await Promise.all([
 		args.noChangelog ? [] : detectChangelogBoundaries(cwd, stagedFiles),
 		discoverContextFiles(cwd),
-		git.getNumstat(true),
-		git.getDiff(true),
+		git.diff.numstat(cwd, { cached: true }),
+		git.diff(cwd, { cached: true }),
 	]);
 	const changelogTargets = changelogBoundaries.map(boundary => boundary.changelogPath);
 	if (!args.noChangelog) {
@@ -93,7 +92,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	if (forceFallback) {
 		process.stdout.write("● Forcing fallback commit generation...\n");
 		const fallbackProposal = generateFallbackProposal(numstat);
-		await runSingleCommit(fallbackProposal, { git, dryRun: args.dryRun, push: args.push });
+		await runSingleCommit(fallbackProposal, { cwd, dryRun: args.dryRun, push: args.push });
 		return;
 	}
 
@@ -110,7 +109,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 			summary: trivialChange.summary,
 			warnings: [],
 		};
-		await runSingleCommit(trivialProposal, { git, dryRun: args.dryRun, push: args.push });
+		await runSingleCommit(trivialProposal, { cwd, dryRun: args.dryRun, push: args.push });
 		return;
 	}
 
@@ -129,7 +128,6 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	try {
 		commitState = await runCommitAgentSession({
 			cwd,
-			git,
 			model: agentModel,
 			thinkingLevel: agentThinkingLevel,
 			settings,
@@ -169,7 +167,6 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 		}
 		process.stdout.write("● Applying changelog entries...\n");
 		const updated = await applyChangelogProposals({
-			git,
 			cwd,
 			proposals: commitState.changelogProposal.entries,
 			dryRun: args.dryRun,
@@ -188,13 +185,13 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	}
 
 	if (commitState.proposal) {
-		await runSingleCommit(commitState.proposal, { git, dryRun: args.dryRun, push: args.push });
+		await runSingleCommit(commitState.proposal, { cwd, dryRun: args.dryRun, push: args.push });
 		return;
 	}
 
 	if (commitState.splitProposal) {
 		await runSplitCommit(commitState.splitProposal, {
-			git,
+			cwd,
 			dryRun: args.dryRun,
 			push: args.push,
 			additionalFiles: updatedChangelogFiles,
@@ -215,10 +212,10 @@ async function runSingleCommit(proposal: CommitProposal, ctx: CommitExecutionCon
 		process.stdout.write(`${commitMessage}\n`);
 		return;
 	}
-	await ctx.git.commit(commitMessage);
+	await git.commit(ctx.cwd, commitMessage);
 	process.stdout.write("Commit created.\n");
 	if (ctx.push) {
-		await ctx.git.push();
+		await git.push(ctx.cwd);
 		process.stdout.write("Pushed to remote.\n");
 	}
 }
@@ -233,7 +230,7 @@ async function runSplitCommit(
 	if (ctx.additionalFiles && ctx.additionalFiles.length > 0) {
 		appendFilesToLastCommit(plan, ctx.additionalFiles);
 	}
-	const stagedFiles = await ctx.git.getStagedFiles();
+	const stagedFiles = await git.diff.changedFiles(ctx.cwd, { cached: true });
 	const plannedFiles = new Set(plan.commits.flatMap(commit => commit.changes.map(change => change.path)));
 	const missingFiles = stagedFiles.filter(file => !plannedFiles.has(file));
 	if (missingFiles.length > 0) {
@@ -270,10 +267,10 @@ async function runSplitCommit(
 		throw new Error(order.error);
 	}
 
-	await ctx.git.resetStaging();
+	await git.stage.reset(ctx.cwd);
 	for (const commitIndex of order) {
 		const commit = plan.commits[commitIndex];
-		await ctx.git.stageHunks(commit.changes);
+		await git.stage.hunks(ctx.cwd, commit.changes);
 		const analysis: ConventionalAnalysis = {
 			type: commit.type,
 			scope: commit.scope,
@@ -281,12 +278,12 @@ async function runSplitCommit(
 			issueRefs: commit.issueRefs,
 		};
 		const message = formatCommitMessage(analysis, commit.summary);
-		await ctx.git.commit(message);
-		await ctx.git.resetStaging();
+		await git.commit(ctx.cwd, message);
+		await git.stage.reset(ctx.cwd);
 	}
 	process.stdout.write("Split commits created.\n");
 	if (ctx.push) {
-		await ctx.git.push();
+		await git.push(ctx.cwd);
 		process.stdout.write("Pushed to remote.\n");
 	}
 }

package/src/commit/agentic/tools/git-file-diff.ts

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import type { CommitAgentState } from "../../../commit/agentic/state";
-import type { ControlledGit } from "../../../commit/git";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 
 const TARGET_TOKENS = 30000;
 const CHARS_PER_TOKEN = 4;
@@ -136,10 +136,7 @@ const gitFileDiffSchema = Type.Object({
 	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
 });
 
-export function createGitFileDiffTool(
-	git: ControlledGit,
-	state: CommitAgentState,
-): CustomTool<typeof gitFileDiffSchema> {
+export function createGitFileDiffTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitFileDiffSchema> {
 	return {
 		name: "git_file_diff",
 		label: "Git File Diff",
@@ -167,7 +164,7 @@ export function createGitFileDiffTool(
 
 			if (uncachedFiles.length > 0) {
 				for (const file of uncachedFiles) {
-					const diff = await git.getDiffForFiles([file], staged);
+					const diff = await git.diff(cwd, { cached: staged, files: [file] });
 					if (diff) {
 						diffs.set(file, diff);
 						state.diffCache.set(cacheKey(file), diff);