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

package/src/commit/agentic/tools/git-hunk.ts

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
-import type { ControlledGit } from "../../../commit/git";
 import type { DiffHunk, FileHunks } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 
 const gitHunkSchema = Type.Object({
 	file: Type.String({ description: "File path" }),
@@ -15,7 +15,7 @@ function selectHunks(fileHunks: FileHunks, requested?: number[]): DiffHunk[] {
 	return fileHunks.hunks.filter(hunk => wanted.has(hunk.index + 1));
 }
 
-export function createGitHunkTool(git: ControlledGit): CustomTool<typeof gitHunkSchema> {
+export function createGitHunkTool(cwd: string): CustomTool<typeof gitHunkSchema> {
 	return {
 		name: "git_hunk",
 		label: "Git Hunk",
@@ -23,7 +23,7 @@ export function createGitHunkTool(git: ControlledGit): CustomTool<typeof gitHunk
 		parameters: gitHunkSchema,
 		async execute(_toolCallId, params) {
 			const staged = params.staged ?? true;
-			const hunks = await git.getHunks([params.file], staged);
+			const hunks = await git.diff.hunks(cwd, [params.file], { cached: staged });
 			const fileHunks = hunks.find(entry => entry.filename === params.file) ?? {
 				filename: params.file,
 				isBinary: false,

package/src/commit/agentic/tools/git-overview.ts

@@ -1,8 +1,8 @@
 import { Type } from "@sinclair/typebox";
 import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agentic/state";
 import { extractScopeCandidates } from "../../../commit/analysis/scope";
-import type { ControlledGit } from "../../../commit/git";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 
 const EXCLUDED_LOCK_FILES = new Set([
 	"Cargo.lock",
@@ -47,10 +47,7 @@ const gitOverviewSchema = Type.Object({
 	include_untracked: Type.Optional(Type.Boolean({ description: "Include untracked files when staged=false" })),
 });
 
-export function createGitOverviewTool(
-	git: ControlledGit,
-	state: CommitAgentState,
-): CustomTool<typeof gitOverviewSchema> {
+export function createGitOverviewTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitOverviewSchema> {
 	return {
 		name: "git_overview",
 		label: "Git Overview",
@@ -58,13 +55,13 @@ export function createGitOverviewTool(
 		parameters: gitOverviewSchema,
 		async execute(_toolCallId, params) {
 			const staged = params.staged ?? true;
-			const allFiles = staged ? await git.getStagedFiles() : await git.getChangedFiles(false);
+			const allFiles = await git.diff.changedFiles(cwd, { cached: staged });
 			const { filtered: files, excluded } = filterExcludedFiles(allFiles);
-			const stat = await git.getStat(staged);
-			const allNumstat = await git.getNumstat(staged);
+			const stat = await git.diff(cwd, { stat: true, cached: staged });
+			const allNumstat = await git.diff.numstat(cwd, { cached: staged });
 			const numstat = allNumstat.filter(entry => !isExcludedFile(entry.path));
 			const scopeResult = extractScopeCandidates(numstat);
-			const untrackedFiles = !staged && params.include_untracked ? await git.getUntrackedFiles() : undefined;
+			const untrackedFiles = !staged && params.include_untracked ? await git.ls.untracked(cwd) : undefined;
 			const snapshot: GitOverviewSnapshot = {
 				files,
 				stat,

package/src/commit/agentic/tools/index.ts

@@ -1,5 +1,4 @@
 import type { CommitAgentState } from "../../../commit/agentic/state";
-import type { ControlledGit } from "../../../commit/git";
 import type { ModelRegistry } from "../../../config/model-registry";
 import type { Settings } from "../../../config/settings";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
@@ -15,7 +14,6 @@ import { createSplitCommitTool } from "./split-commit";
 
 export interface CommitToolOptions {
 	cwd: string;
-	git: ControlledGit;
 	authStorage: AuthStorage;
 	modelRegistry: ModelRegistry;
 	settings: Settings;
@@ -27,10 +25,10 @@ export interface CommitToolOptions {
 
 export function createCommitTools(options: CommitToolOptions): Array<CustomTool<any, any>> {
 	const tools: Array<CustomTool<any, any>> = [
-		createGitOverviewTool(options.git, options.state),
-		createGitFileDiffTool(options.git, options.state),
-		createGitHunkTool(options.git),
-		createRecentCommitsTool(options.git),
+		createGitOverviewTool(options.cwd, options.state),
+		createGitFileDiffTool(options.cwd, options.state),
+		createGitHunkTool(options.cwd),
+		createRecentCommitsTool(options.cwd),
 	];
 
 	if (options.enableAnalyzeFiles ?? true) {
@@ -48,8 +46,8 @@ export function createCommitTools(options: CommitToolOptions): Array<CustomTool<
 
 	tools.push(
 		createProposeChangelogTool(options.state, options.changelogTargets),
-		createProposeCommitTool(options.git, options.state),
-		createSplitCommitTool(options.git, options.state, options.changelogTargets),
+		createProposeCommitTool(options.cwd, options.state),
+		createSplitCommitTool(options.cwd, options.state, options.changelogTargets),
 	);
 
 	return tools;

package/src/commit/agentic/tools/propose-commit.ts

@@ -9,9 +9,9 @@ import {
 	validateTypeConsistency,
 } from "../../../commit/agentic/validation";
 import { validateAnalysis } from "../../../commit/analysis/validation";
-import type { ControlledGit } from "../../../commit/git";
 import type { CommitType, ConventionalAnalysis, ConventionalDetail } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 import { commitTypeSchema, detailSchema } from "./schemas.js";
 
 const proposeCommitSchema = Type.Object({
@@ -49,10 +49,7 @@ function normalizeDetails(
 	}));
 }
 
-export function createProposeCommitTool(
-	git: ControlledGit,
-	state: CommitAgentState,
-): CustomTool<typeof proposeCommitSchema> {
+export function createProposeCommitTool(cwd: string, state: CommitAgentState): CustomTool<typeof proposeCommitSchema> {
 	return {
 		name: "propose_commit",
 		label: "Propose Commit",
@@ -72,8 +69,8 @@ export function createProposeCommitTool(
 
 			const summaryValidation = validateSummaryRules(summary);
 			const analysisValidation = validateAnalysis(analysis);
-			const stagedFiles = state.overview?.files ?? (await git.getStagedFiles());
-			const diffText = state.diffText ?? (await git.getDiff(true));
+			const stagedFiles = state.overview?.files ?? (await git.diff.changedFiles(cwd, { cached: true }));
+			const diffText = state.diffText ?? (await git.diff(cwd, { cached: true }));
 			const typeValidation = validateTypeConsistency(params.type, stagedFiles, {
 				diffText,
 				summary,

package/src/commit/agentic/tools/recent-commits.ts

@@ -1,6 +1,6 @@
 import { Type } from "@sinclair/typebox";
-import type { ControlledGit } from "../../../commit/git";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 
 const recentCommitsSchema = Type.Object({
 	count: Type.Optional(Type.Number({ description: "Number of commits to fetch", minimum: 1, maximum: 50 })),
@@ -25,7 +25,7 @@ function extractScope(subject: string): string | null {
 	return match?.[1]?.trim() ?? null;
 }
 
-export function createRecentCommitsTool(git: ControlledGit): CustomTool<typeof recentCommitsSchema> {
+export function createRecentCommitsTool(cwd: string): CustomTool<typeof recentCommitsSchema> {
 	return {
 		name: "recent_commits",
 		label: "Recent Commits",
@@ -33,7 +33,7 @@ export function createRecentCommitsTool(git: ControlledGit): CustomTool<typeof r
 		parameters: recentCommitsSchema,
 		async execute(_toolCallId, params) {
 			const count = params.count ?? 8;
-			const commits = await git.getRecentCommits(count);
+			const commits = await git.log.subjects(cwd, count);
 			const verbs: Record<string, number> = {};
 			const scopes: Record<string, number> = {};
 			const lengths: number[] = [];

package/src/commit/agentic/tools/split-commit.ts

@@ -10,9 +10,9 @@ import {
 	validateTypeConsistency,
 } from "../../../commit/agentic/validation";
 import { validateScope } from "../../../commit/analysis/validation";
-import type { ControlledGit } from "../../../commit/git";
 import type { ConventionalDetail } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 import { commitTypeSchema, detailSchema } from "./schemas.js";
 
 const hunkSelectorSchema = Type.Union([
@@ -64,7 +64,7 @@ function normalizeDetails(
 }
 
 export function createSplitCommitTool(
-	git: ControlledGit,
+	cwd: string,
 	state: CommitAgentState,
 	changelogTargets: string[],
 ): CustomTool<typeof splitCommitSchema> {
@@ -74,13 +74,13 @@ export function createSplitCommitTool(
 		description: "Propose multiple atomic commits for unrelated changes.",
 		parameters: splitCommitSchema,
 		async execute(_toolCallId, params) {
-			const stagedFiles = state.overview?.files ?? (await git.getStagedFiles());
+			const stagedFiles = state.overview?.files ?? (await git.diff.changedFiles(cwd, { cached: true }));
 			const stagedSet = new Set(stagedFiles);
 			const changelogSet = new Set(changelogTargets);
 			const usedFiles = new Set<string>();
 			const errors: string[] = [];
 			const warnings: string[] = [];
-			const diffText = await git.getDiff(true);
+			const diffText = await git.diff(cwd, { cached: true });
 
 			const commits: SplitCommitGroup[] = params.commits.map((commit, index) => {
 				const scope = commit.scope?.trim() || null;

package/src/commit/changelog/index.ts

@@ -2,8 +2,8 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
-import type { ControlledGit } from "../../commit/git";
 import { CHANGELOG_CATEGORIES } from "../../commit/types";
+import * as git from "../../utils/git";
 import { detectChangelogBoundaries } from "./detect";
 import { generateChangelogEntries } from "./generate";
 import { parseUnreleasedSection } from "./parse";
@@ -13,7 +13,6 @@ const CHANGELOG_SECTIONS = CHANGELOG_CATEGORIES;
 const DEFAULT_MAX_DIFF_CHARS = 120_000;
 
 export interface ChangelogFlowInput {
-	git: ControlledGit;
 	cwd: string;
 	model: Model<Api>;
 	apiKey: string;
@@ -25,7 +24,6 @@ export interface ChangelogFlowInput {
 }
 
 export interface ChangelogProposalInput {
-	git: ControlledGit;
 	cwd: string;
 	proposals: Array<{
 		path: string;
@@ -40,7 +38,6 @@ export interface ChangelogProposalInput {
  * Update CHANGELOG.md entries for staged changes.
  */
 export async function runChangelogFlow({
-	git,
 	cwd,
 	model,
 	apiKey,
@@ -58,9 +55,9 @@ export async function runChangelogFlow({
 	const updated: string[] = [];
 	for (const boundary of boundaries) {
 		onProgress?.(`Generating entries for ${boundary.changelogPath}…`);
-		const diff = await git.getDiffForFiles(boundary.files, true);
+		const diff = await git.diff(cwd, { cached: true, files: boundary.files });
 		if (!diff.trim()) continue;
-		const stat = await git.getStatForFiles(boundary.files, true);
+		const stat = await git.diff(cwd, { stat: true, cached: true, files: boundary.files });
 		const diffForPrompt = truncateDiff(diff, maxDiffChars ?? DEFAULT_MAX_DIFF_CHARS);
 		const changelogContent = await Bun.file(boundary.changelogPath).text();
 		let unreleased: { startLine: number; endLine: number; entries: Record<string, string[]> };
@@ -87,7 +84,7 @@ export async function runChangelogFlow({
 		const updatedContent = applyChangelogEntries(changelogContent, unreleased, generated.entries);
 		if (!dryRun) {
 			await Bun.write(boundary.changelogPath, updatedContent);
-			await git.stageFiles([path.relative(cwd, boundary.changelogPath)]);
+			await git.stage.files(cwd, [path.relative(cwd, boundary.changelogPath)]);
 		}
 		updated.push(boundary.changelogPath);
 	}
@@ -99,7 +96,6 @@ export async function runChangelogFlow({
  * Apply changelog entries provided by the commit agent.
  */
 export async function applyChangelogProposals({
-	git,
 	cwd,
 	proposals,
 	dryRun,
@@ -132,7 +128,7 @@ export async function applyChangelogProposals({
 		const updatedContent = applyChangelogEntries(changelogContent, unreleased, normalized, normalizedDeletions);
 		if (!dryRun) {
 			await Bun.write(proposal.path, updatedContent);
-			await git.stageFiles([path.relative(cwd, proposal.path)]);
+			await git.stage.files(cwd, [path.relative(cwd, proposal.path)]);
 		}
 		updated.push(proposal.path);
 	}

package/src/commit/pipeline.ts

@@ -7,6 +7,7 @@ import { renderPromptTemplate } from "../config/prompt-templates";
 import { Settings } from "../config/settings";
 import { discoverAuthStorage } from "../sdk";
 import { loadProjectContextFiles } from "../system-prompt";
+import * as git from "../utils/git";
 import { runAgenticCommit } from "./agentic";
 import {
 	extractScopeCandidates,
@@ -16,7 +17,6 @@ import {
 	validateSummary,
 } from "./analysis";
 import { runChangelogFlow } from "./changelog";
-import { ControlledGit } from "./git";
 import { runMapReduceAnalysis, shouldUseMapReduce } from "./map-reduce";
 import { formatCommitMessage } from "./message";
 import { resolvePrimaryModel, resolveSmolModel } from "./model-selection";
@@ -57,12 +57,11 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		thinkingLevel: smolThinkingLevel,
 	} = await resolveSmolModel(settings, modelRegistry, primaryModel, primaryApiKey);
 
-	const git = new ControlledGit(cwd);
-	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 });
 	}
 	if (stagedFiles.length === 0) {
 		process.stderr.write("No changes to commit.\n");
@@ -71,7 +70,6 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 
 	if (!args.noChangelog) {
 		await runChangelogFlow({
-			git,
 			cwd,
 			model: primaryModel,
 			apiKey: primaryApiKey,
@@ -82,11 +80,11 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		});
 	}
 
-	const diff = await git.getDiff(true);
-	const stat = await git.getStat(true);
-	const numstat = await git.getNumstat(true);
+	const diff = await git.diff(cwd, { cached: true });
+	const stat = await git.diff(cwd, { stat: true, cached: true });
+	const numstat = await git.diff.numstat(cwd, { cached: true });
 	const scopeCandidates = extractScopeCandidates(numstat).scopeCandidates;
-	const recentCommits = await git.getRecentCommits(RECENT_COMMITS_COUNT);
+	const recentCommits = await git.log.subjects(cwd, RECENT_COMMITS_COUNT);
 	const contextFiles = await loadProjectContextFiles({ cwd });
 	const formattedContextFiles = contextFiles.map(file => ({
 		path: path.relative(cwd, file.path),
@@ -131,10 +129,10 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 		return;
 	}
 
-	await git.commit(commitMessage);
+	await git.commit(cwd, commitMessage);
 	process.stdout.write("Commit created.\n");
 	if (args.push) {
-		await git.push();
+		await git.push(cwd);
 		process.stdout.write("Pushed to remote.\n");
 	}
 }

package/src/config/keybindings.ts

@@ -37,6 +37,7 @@ interface AppKeybindings {
 	"app.session.tree": true;
 	"app.session.fork": true;
 	"app.session.resume": true;
+	"app.session.observe": true;
 	"app.session.togglePath": true;
 	"app.session.toggleSort": true;
 	"app.session.rename": true;
@@ -144,6 +145,10 @@ export const KEYBINDINGS = {
 		defaultKeys: [],
 		description: "Resume session",
 	},
+	"app.session.observe": {
+		defaultKeys: "ctrl+s",
+		description: "Observe subagent sessions",
+	},
 	"app.session.togglePath": {
 		defaultKeys: "ctrl+p",
 		description: "Toggle session path display",
@@ -214,6 +219,7 @@ const KEYBINDING_NAME_MIGRATIONS = {
 	tree: "app.session.tree",
 	fork: "app.session.fork",
 	resume: "app.session.resume",
+	observeSessions: "app.session.observe",
 	toggleSTT: "app.stt.toggle",
 	// TUI editor (old names for backward compatibility)
 	cursorUp: "tui.editor.cursorUp",
@@ -260,9 +266,6 @@ function isLegacyKeybindingName(key: string): key is keyof typeof KEYBINDING_NAM
 	return key in KEYBINDING_NAME_MIGRATIONS;
 }
 
-/**
- * Normalize input to KeybindingsConfig, validating types.
- */
 function toKeybindingsConfig(value: unknown): KeybindingsConfig {
 	if (typeof value !== "object" || value === null) {
 		return {};
@@ -270,15 +273,13 @@ function toKeybindingsConfig(value: unknown): KeybindingsConfig {
 
 	const config: KeybindingsConfig = {};
 	for (const [key, val] of Object.entries(value)) {
-		// Allow undefined, string (KeyId), or array of strings
 		if (val === undefined) {
 			config[key] = undefined;
 		} else if (typeof val === "string") {
 			config[key] = val as KeyId;
 		} else if (Array.isArray(val) && val.every(v => typeof v === "string")) {
-			config[key] = val as string[] as KeyId[];
+			config[key] = val as KeyId[];
 		}
-		// Silently skip invalid entries
 	}
 	return config;
 }

package/src/config/settings-schema.ts

@@ -194,6 +194,15 @@ export const SETTINGS_SCHEMA = {
 	// ────────────────────────────────────────────────────────────────────────
 	lastChangelogVersion: { type: "string", default: undefined },
 
+	autoResume: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "interaction",
+			label: "Auto Resume",
+			description: "Automatically resume the most recent session in the current directory",
+		},
+	},
 	shellPath: { type: "string", default: undefined },
 
 	extensions: { type: "array", default: EMPTY_STRING_ARRAY },
@@ -797,6 +806,38 @@ export const SETTINGS_SCHEMA = {
 
 	"compaction.remoteEndpoint": { type: "string", default: undefined },
 
+	// Idle compaction
+	"compaction.idleEnabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "context",
+			label: "Idle Compaction",
+			description: "Compact context while idle when token count exceeds threshold",
+		},
+	},
+
+	"compaction.idleThresholdTokens": {
+		type: "number",
+		default: 200000,
+		ui: {
+			tab: "context",
+			label: "Idle Compaction Threshold",
+			description: "Token count above which idle compaction triggers",
+			submenu: true,
+		},
+	},
+
+	"compaction.idleTimeoutSeconds": {
+		type: "number",
+		default: 300,
+		ui: {
+			tab: "context",
+			label: "Idle Compaction Delay",
+			description: "Seconds to wait while idle before compacting",
+			submenu: true,
+		},
+	},
 	// Branch summaries
 	"branchSummary.enabled": {
 		type: "boolean",
@@ -1701,6 +1742,9 @@ export interface CompactionSettings {
 	autoContinue: boolean;
 	remoteEnabled: boolean;
 	remoteEndpoint: string | undefined;
+	idleEnabled: boolean;
+	idleThresholdTokens: number;
+	idleTimeoutSeconds: number;
 }
 
 export interface ContextPromotionSettings {

package/src/extensibility/custom-commands/bundled/ci-green/index.ts

@@ -2,26 +2,14 @@ import { renderPromptTemplate } from "../../../../config/prompt-templates";
 import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
 import type { HookCommandContext } from "../../../../extensibility/hooks/types";
 import ciGreenRequestTemplate from "../../../../prompts/ci-green-request.md" with { type: "text" };
+import * as git from "../../../../utils/git";
 
 async function getHeadTag(api: CustomCommandAPI): Promise<string | undefined> {
-	const result = await api.exec("git", [
-		"for-each-ref",
-		"--points-at",
-		"HEAD",
-		"--sort=-version:refname",
-		"--format=%(refname:strip=2)",
-		"refs/tags",
-	]);
-
-	if (result.code !== 0 || result.killed) {
+	try {
+		return (await git.ref.tags(api.cwd))[0];
+	} catch {
 		return undefined;
 	}
-
-	const tag = result.stdout
-		.split("\n")
-		.map(line => line.trim())
-		.find(Boolean);
-	return tag || undefined;
 }
 
 export class GreenCommand implements CustomCommand {

package/src/extensibility/custom-commands/bundled/review/index.ts

@@ -15,6 +15,7 @@ import { renderPromptTemplate } from "../../../../config/prompt-templates";
 import type { CustomCommand, CustomCommandAPI } from "../../../../extensibility/custom-commands/types";
 import type { HookCommandContext } from "../../../../extensibility/hooks/types";
 import reviewRequestTemplate from "../../../../prompts/review-request.md" with { type: "text" };
+import * as git from "../../../../utils/git";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
@@ -258,20 +259,20 @@ export class ReviewCommand implements CustomCommand {
 				if (!baseBranch) return undefined;
 
 				const currentBranch = await getCurrentBranch(this.api);
-				const diffResult = await this.api.exec("git", ["diff", `${baseBranch}...${currentBranch}`], {
-					timeout: 30000,
-				});
-				if (diffResult.code !== 0) {
-					ctx.ui.notify(`Failed to get diff: ${diffResult.stderr}`, "error");
+				let diffText: string;
+				try {
+					diffText = await git.diff(this.api.cwd, { base: `${baseBranch}...${currentBranch}` });
+				} catch (err) {
+					ctx.ui.notify(`Failed to get diff: ${err instanceof Error ? err.message : String(err)}`, "error");
 					return undefined;
 				}
 
-				if (!diffResult.stdout.trim()) {
+				if (!diffText.trim()) {
 					ctx.ui.notify(`No changes between ${baseBranch} and ${currentBranch}`, "warning");
 					return undefined;
 				}
 
-				const stats = parseDiff(diffResult.stdout);
+				const stats = parseDiff(diffText);
 				if (stats.files.length === 0) {
 					ctx.ui.notify("No reviewable files (all changes filtered out)", "warning");
 					return undefined;
@@ -280,7 +281,7 @@ export class ReviewCommand implements CustomCommand {
 				return buildReviewPrompt(
 					`Reviewing changes between \`${baseBranch}\` and \`${currentBranch}\` (PR-style)`,
 					stats,
-					diffResult.stdout,
+					diffText,
 				);
 			}
 
@@ -292,12 +293,19 @@ export class ReviewCommand implements CustomCommand {
 					return undefined;
 				}
 
-				const [unstagedResult, stagedResult] = await Promise.all([
-					this.api.exec("git", ["diff"], { timeout: 30000 }),
-					this.api.exec("git", ["diff", "--cached"], { timeout: 30000 }),
-				]);
+				let unstagedDiff: string;
+				let stagedDiff: string;
+				try {
+					[unstagedDiff, stagedDiff] = await Promise.all([
+						git.diff(this.api.cwd),
+						git.diff(this.api.cwd, { cached: true }),
+					]);
+				} catch (err) {
+					ctx.ui.notify(`Failed to get diff: ${err instanceof Error ? err.message : String(err)}`, "error");
+					return undefined;
+				}
 
-				const combinedDiff = [unstagedResult.stdout, stagedResult.stdout].filter(Boolean).join("\n");
+				const combinedDiff = [unstagedDiff, stagedDiff].filter(Boolean).join("\n");
 
 				if (!combinedDiff.trim()) {
 					ctx.ui.notify("No diff content found", "warning");
@@ -327,25 +335,26 @@ export class ReviewCommand implements CustomCommand {
 				// Extract commit hash from selection (format: "abc1234 message")
 				const hash = selected.split(" ")[0];
 
-				// Get the commit diff (with timeout)
-				const showResult = await this.api.exec("git", ["show", "--format=", hash], { timeout: 30000 });
-				if (showResult.code !== 0) {
-					ctx.ui.notify(`Failed to get commit: ${showResult.stderr}`, "error");
+				let diffText: string;
+				try {
+					diffText = await git.show(this.api.cwd, hash, { format: "" });
+				} catch (err) {
+					ctx.ui.notify(`Failed to get commit: ${err instanceof Error ? err.message : String(err)}`, "error");
 					return undefined;
 				}
 
-				if (!showResult.stdout.trim()) {
+				if (!diffText.trim()) {
 					ctx.ui.notify("Commit has no diff content", "warning");
 					return undefined;
 				}
 
-				const stats = parseDiff(showResult.stdout);
+				const stats = parseDiff(diffText);
 				if (stats.files.length === 0) {
 					ctx.ui.notify("No reviewable files in commit (all changes filtered out)", "warning");
 					return undefined;
 				}
 
-				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, showResult.stdout);
+				return buildReviewPrompt(`Reviewing commit \`${hash}\``, stats, diffText);
 			}
 
 			case 4: {
@@ -354,16 +363,21 @@ export class ReviewCommand implements CustomCommand {
 				if (!instructions?.trim()) return undefined;
 
 				// For custom, we still try to get current diff for context
-				const diffResult = await this.api.exec("git", ["diff", "HEAD"], { timeout: 30000 });
-				const hasDiff = diffResult.code === 0 && diffResult.stdout.trim();
+				let diffText: string | undefined;
+				try {
+					diffText = await git.diff(this.api.cwd, { base: "HEAD" });
+				} catch {
+					diffText = undefined;
+				}
+				const reviewDiff = diffText?.trim();
 
-				if (hasDiff) {
-					const stats = parseDiff(diffResult.stdout);
+				if (reviewDiff) {
+					const stats = parseDiff(reviewDiff);
 					// Even if all files filtered, include the custom instructions
 					return `${buildReviewPrompt(
 						`Custom review: ${instructions.split("\n")[0].slice(0, 60)}…`,
 						stats,
-						diffResult.stdout,
+						reviewDiff,
 					)}\n\n### Additional Instructions\n\n${instructions}`;
 				}
 
@@ -388,12 +402,7 @@ Use the Task tool with \`agent: "reviewer"\` to execute this review.`;
 
 async function getGitBranches(api: CustomCommandAPI): Promise<string[]> {
 	try {
-		const result = await api.exec("git", ["branch", "-a", "--format=%(refname:short)"]);
-		if (result.code !== 0) return [];
-		return result.stdout
-			.split("\n")
-			.map(b => b.trim())
-			.filter(Boolean);
+		return await git.branch.list(api.cwd, { all: true });
 	} catch {
 		return [];
 	}
@@ -401,8 +410,7 @@ async function getGitBranches(api: CustomCommandAPI): Promise<string[]> {
 
 async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
 	try {
-		const result = await api.exec("git", ["branch", "--show-current"]);
-		return result.stdout.trim() || "HEAD";
+		return (await git.branch.current(api.cwd)) ?? "HEAD";
 	} catch {
 		return "HEAD";
 	}
@@ -410,8 +418,7 @@ async function getCurrentBranch(api: CustomCommandAPI): Promise<string> {
 
 async function getGitStatus(api: CustomCommandAPI): Promise<string> {
 	try {
-		const result = await api.exec("git", ["status", "--porcelain"]);
-		return result.stdout;
+		return await git.status(api.cwd);
 	} catch {
 		return "";
 	}
@@ -419,12 +426,7 @@ async function getGitStatus(api: CustomCommandAPI): Promise<string> {
 
 async function getRecentCommits(api: CustomCommandAPI, count: number): Promise<string[]> {
 	try {
-		const result = await api.exec("git", ["log", `-${count}`, "--oneline", "--no-decorate"]);
-		if (result.code !== 0) return [];
-		return result.stdout
-			.split("\n")
-			.map(c => c.trim())
-			.filter(Boolean);
+		return await git.log.onelines(api.cwd, count);
 	} catch {
 		return [];
 	}