@oh-my-pi/pi-coding-agent 17.2.10 → 17.2.11

package/dist/types/modes/utils/transcript-render-helpers.d.ts

@@ -68,8 +68,9 @@ export type AssistantErrorPresentation = {
 };
 /**
  * Resolve the turn-ending assistant error presentation, if any.
- * Silent and user-interrupt aborts yield no label. Recovered auto-retry errors
- * collapse to a single non-error note; terminal errors keep the full red presentation.
+ * Silent and user-interrupt aborts yield no label. Recovered retry attempts
+ * render a compact note; attempts superseded by an exhausted budget are hidden
+ * while the final terminal error keeps its full presentation.
  */
 export declare function resolveAssistantErrorPresentation(message: AssistantAgentMessage, retryAttempt?: number): AssistantErrorPresentation;
 /**

package/dist/types/secrets/index.d.ts

@@ -1,4 +1,4 @@
-import { type SecretEntry } from "./obfuscator.js";
+import { type SecretEntry, SecretObfuscator } from "./obfuscator.js";
 /**
  * Per-install secret key for the placeholder digest. Persisted under XDG state
  * and never sent to a provider, so model-visible placeholders cannot be reversed
@@ -40,3 +40,25 @@ export declare function collectEnvSecrets(): SecretEntry[];
  * transparent because the round trip is lossless.
  */
 export declare function builtinCredentialSecretEntries(): SecretEntry[];
+/**
+ * Build the session secret obfuscator from every configured source: secrets.yml
+ * (project + global), secret-shaped environment variables, and the built-in
+ * credential patterns. Callers gate on `secrets.enabled`.
+ *
+ * Only CONFIGURED entries force startup key creation: a configured
+ * obfuscate-mode secret — or a default (no custom `replacement`) replace-mode
+ * regex whose key-derived idempotent fallback marker needs a stable key across
+ * restarts (see `secretEntryNeedsPlaceholderKey`) — mints placeholders as soon
+ * as the obfuscator is built. The built-in credential-pattern entry matches
+ * dynamically, so it resolves the persisted key lazily on first match instead
+ * of creating the key file for every secrets-enabled session.
+ *
+ * When no configured entry produced an active secret but a persisted key
+ * exists, returns a redaction-only obfuscator so a tool read of the key file
+ * does not ship the reusable HMAC key to the provider. Returns undefined when
+ * there is nothing to protect.
+ *
+ * `keyDir` is the explicit agent dir override for the placeholder-key file
+ * (default XDG/agent location when omitted).
+ */
+export declare function buildSecretObfuscator(cwd: string, agentDir: string, keyDir?: string): Promise<SecretObfuscator | undefined>;

package/dist/types/session/agent-session-events.d.ts

@@ -2,7 +2,7 @@ import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { CompactionResult } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Effort } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule.js";
-import type { RecoveredRetryError } from "../extensibility/shared-events.js";
+import type { RetryErrorUpdate } from "../extensibility/shared-events.js";
 import type { Goal, GoalModeState } from "../goals/state.js";
 import type { ConfiguredThinkingLevel } from "../thinking.js";
 import type { TodoItem } from "../tools/todo.js";
@@ -40,7 +40,7 @@ export type AgentSessionEvent = Exclude<AgentEvent, {
     success: boolean;
     attempt: number;
     finalError?: string;
-    recoveredErrors?: RecoveredRetryError[];
+    retryErrors?: RetryErrorUpdate[];
 } | {
     type: "retry_fallback_applied";
     from: string;

package/dist/types/session/agent-session.d.ts

@@ -83,7 +83,7 @@ export declare class AgentSession {
     /**
      * Arm prewalk outside the normal startup path so an explicit slash command starts immediately.
      */
-    armPrewalk(target: Model, thinkingLevel?: ConfiguredThinkingLevel): void;
+    armPrewalk(target: Model, thinkingLevel?: ConfiguredThinkingLevel): boolean;
     /** Validate the active plan artifact and shape an `xd://propose` result for review-mode hosts. */
     preparePlanForReview(title: string): Promise<AgentToolResult<PlanApprovalDetails>>;
     constructor(config: AgentSessionConfig);

package/dist/types/session/messages.d.ts

@@ -12,6 +12,7 @@ import type { OutputMeta } from "../tools/output-meta.js";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export declare const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
+export declare const PREWALK_PLAN_MESSAGE_TYPE = "prewalk-plan";
 /**
  * Logs provider-error turns so their actual cause is available outside the
  * session transcript. No-op for non-error stop reasons.

package/dist/types/session/prewalk.d.ts

@@ -6,6 +6,8 @@ import { type ConfiguredThinkingLevel } from "../thinking.js";
 import type { PlanProposalHandler } from "../tools/resolve.js";
 import type { PlanYolo, Prewalk } from "./agent-session-types.js";
 import type { SessionManager } from "./session-manager.js";
+/** Hidden plan steering is consumed within the live run and must not reappear after a context rebuild. */
+export declare function isPrewalkPlanNudge(message: AgentMessage): boolean;
 /** Capabilities the prewalk coordinator borrows from its owning session. */
 export interface PrewalkCoordinatorHost {
     agent: Agent;
@@ -41,7 +43,7 @@ export declare class PrewalkCoordinator {
     /** Advances the one-way prewalk switch at a completed assistant-turn boundary. */
     advanceAtTurnEnd(liveMessages: AgentMessage[], context: AgentTurnEndContext | undefined): Promise<void>;
     /** Arms a prewalk immediately for an explicit slash-command request. */
-    arm(target: Model, thinkingLevel?: ConfiguredThinkingLevel): void;
+    arm(target: Model, thinkingLevel?: ConfiguredThinkingLevel): boolean;
     /** Lazily enables plan-yolo's plan phase before the first prompt is built. */
     armPlanYoloIfNeeded(): Promise<void>;
 }

package/dist/types/session/session-tools.d.ts

@@ -108,6 +108,14 @@ export declare class SessionTools {
     get baseSystemPrompt(): string[];
     /** Replaces the controller-owned base prompt without applying it to the agent. */
     setBaseSystemPrompt(prompt: string[]): void;
+    /**
+     * Registers the per-turn `before_agent_start` system-prompt override and
+     * applies it to the agent. Base rebuilds during the turn preserve it until
+     * {@link clearTurnSystemPromptOverride}.
+     */
+    setTurnSystemPromptOverride(prompt: string[]): void;
+    /** Drops the active per-turn override; later rebuilds fall back to the base prompt. */
+    clearTurnSystemPromptOverride(): void;
     /** Skills currently rendered into the system prompt. */
     get skills(): Skill[];
     /** Diagnostics produced while loading the current skills. */

package/dist/types/session/turn-recovery.d.ts

@@ -100,8 +100,13 @@ export declare class TurnRecovery {
         autoContinue: boolean;
         triggerContextTokens?: number;
     }): Promise<RecoveryCompactionResult>;
-    /** Restores the configured primary after fallback cooldown expiry. */
-    maybeRestoreRetryFallbackPrimary(): Promise<void>;
+    /**
+     * Restores the configured primary after fallback cooldown expiry.
+     * @returns true when the active model was actually switched back to the
+     * primary, so callers can re-run the pre-send context-fit check against the
+     * reverted (possibly smaller) window before issuing the next request.
+     */
+    maybeRestoreRetryFallbackPrimary(): Promise<boolean>;
     /** Applies model fallback policy from live usage health before a turn starts. */
     maybeApplyUsageAwareFallback(signal: AbortSignal, confirmer?: UsageFallbackConfirmer): Promise<boolean>;
     /** Applies automatic retry, credential rotation, and model fallback policy. */

package/dist/types/task/index.d.ts

@@ -49,6 +49,8 @@ export declare function composeSpawnAdvisory(args: {
     willRunAsync: boolean;
     scoutAvailable?: boolean;
 }): string | undefined;
+/** Rescan one cwd and publish its definitions to existing and future task tools. */
+export declare function refreshAgentDiscovery(cwd: string): Promise<void>;
 /**
  * Task tool - Delegate tasks to specialized agents.
  *

package/dist/types/tools/shell-tokenize.d.ts

@@ -41,3 +41,19 @@ export interface FlatShellCommandSegment {
  * complete input in that case.
  */
 export declare function extractFlatShellCommandSegments(command: string): FlatShellCommandSegment[];
+/**
+ * Parses a leading `cd <path> && ...` prefix so the bash tool can route the
+ * target through its structured `cwd` parameter when the model omits it.
+ *
+ * Returns the single path token (quotes and backslash escapes resolved to their
+ * literal value) and the command remainder after the top-level `&&`, or `null`
+ * when the command does not begin with exactly `cd`, one path token, and a
+ * top-level `&&`. The scanner deliberately bails on anything else in the prefix
+ * — redirects (`cd /tmp 2>/dev/null && ...`), extra arguments, or paths needing
+ * shell expansion (`$`, backticks, `(`) — leaving the whole command for the
+ * shell instead of absorbing shell syntax into `cwd`.
+ */
+export declare function extractLeadingCdTarget(command: string): {
+    path: string;
+    rest: string;
+} | null;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.2.10",
+	"version": "17.2.11",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -50,18 +50,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.2.10",
-		"@oh-my-pi/omp-stats": "17.2.10",
-		"@oh-my-pi/omptype": "17.2.10",
-		"@oh-my-pi/pi-agent-core": "17.2.10",
-		"@oh-my-pi/pi-ai": "17.2.10",
-		"@oh-my-pi/pi-catalog": "17.2.10",
-		"@oh-my-pi/pi-mnemopi": "17.2.10",
-		"@oh-my-pi/pi-natives": "17.2.10",
-		"@oh-my-pi/pi-tui": "17.2.10",
-		"@oh-my-pi/pi-utils": "17.2.10",
-		"@oh-my-pi/pi-wire": "17.2.10",
-		"@oh-my-pi/snapcompact": "17.2.10",
+		"@oh-my-pi/hashline": "17.2.11",
+		"@oh-my-pi/omp-stats": "17.2.11",
+		"@oh-my-pi/omptype": "17.2.11",
+		"@oh-my-pi/pi-agent-core": "17.2.11",
+		"@oh-my-pi/pi-ai": "17.2.11",
+		"@oh-my-pi/pi-catalog": "17.2.11",
+		"@oh-my-pi/pi-mnemopi": "17.2.11",
+		"@oh-my-pi/pi-natives": "17.2.11",
+		"@oh-my-pi/pi-tui": "17.2.11",
+		"@oh-my-pi/pi-utils": "17.2.11",
+		"@oh-my-pi/pi-wire": "17.2.11",
+		"@oh-my-pi/snapcompact": "17.2.11",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/scripts/legacy-pi-virtual-module.ts

@@ -151,7 +151,10 @@ export async function collectBundledPiEntries(): Promise<BundledPiEntry[]> {
 				const glob = new Bun.Glob(`**/*${pattern.sourceSuffix}`);
 				const matches: string[] = [];
 				for await (const match of glob.scan({ cwd: sourceDir, onlyFiles: true })) {
-					matches.push(match);
+					// Bun.Glob yields host separators; the export keys and generated
+					// identifiers below are `/`-shaped. Same normalization as
+					// `generate-docs-index.ts`.
+					matches.push(match.split(path.sep).join("/"));
 				}
 				matches.sort();
 				for (const match of matches) {

package/src/capability/mcp.ts

@@ -27,12 +27,23 @@ export interface MCPServer {
 	args?: string[];
 	/** Environment variables */
 	env?: Record<string, string>;
+	/**
+	 * `literal`: env values are opaque plugin package data (Agent Plugins
+	 * §§4.1/9.2) — exempt from env-name lookup and `!command` resolution.
+	 */
+	envPolicy?: "literal";
 	/** Working directory for stdio transport */
 	cwd?: string;
 	/** URL (for HTTP/SSE transport) */
 	url?: string;
 	/** HTTP headers (for HTTP transport) */
 	headers?: Record<string, string>;
+	/**
+	 * `origin-locked`: configured headers are literal package data pinned to the
+	 * configured URL's origin (Agent Plugins §7.2.1) — never expanded, never
+	 * forwarded cross-origin, and client-generated headers win case-insensitively.
+	 */
+	headerPolicy?: "origin-locked";
 	/** Authentication configuration */
 	auth?: {
 		type: "oauth" | "apikey";

package/src/capability/skill.ts

@@ -43,6 +43,12 @@ export interface Skill {
 	content: string;
 	/** Parsed frontmatter */
 	frontmatter?: SkillFrontmatter;
+	/**
+	 * Filesystem-resolved plugin root this skill was packaged in (Agent Plugins
+	 * §4.1). When set, every `skill://` resource access must realpath-resolve
+	 * within this directory; symlinks may target other files inside it.
+	 */
+	containRoot?: string;
 	/** Source level */
 	level: "user" | "project";
 	/** Source metadata */

package/src/cli/command-help.ts

@@ -72,6 +72,10 @@ export const sayHelp = {
 
 export const searchHelp = { description: "Test web search providers" } satisfies CommandMetadata;
 
+export const shareHelp = {
+	description: "Share a saved session via an encrypted link (same as /share)",
+} satisfies CommandMetadata;
+
 export const setupHelp = {
 	description: "Run onboarding setup or install dependencies for optional features",
 } satisfies CommandMetadata;

package/src/cli/gallery-cli.ts

@@ -153,7 +153,7 @@ export async function renderGalleryState(
 	const component = new ToolExecutionComponent(
 		componentName,
 		streamingArgs,
-		{ showImages: false },
+		{ showImages: false, useBuiltInRenderer: !fixture.customRendered },
 		tool,
 		ui,
 		getProjectDir(),

package/src/cli-commands.ts

@@ -120,6 +120,11 @@ export const commands: CommandEntry[] = [
 		load: () => import("./commands/say").then(m => m.default),
 		help: commandHelp.sayHelp,
 	},
+	{
+		name: "share",
+		load: () => import("./commands/share").then(m => m.default),
+		help: commandHelp.shareHelp,
+	},
 	{
 		name: "setup",
 		load: () => import("./commands/setup").then(m => m.default),

package/src/commands/commit.ts

@@ -5,7 +5,7 @@
 import { postmortem } from "@oh-my-pi/pi-utils";
 import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { commitHelp as commandHelp } from "../cli/command-help";
-import { runCommitCommand } from "../commit";
+import { CommitAbortedError, runCommitCommand } from "../commit";
 import type { CommitCommandArgs } from "../commit/types";
 import { initTheme } from "../modes/theme/theme";
 
@@ -41,7 +41,20 @@ export default class Commit extends Command {
 		// is already written. Mirror the `runPrintMode` exit pattern from
 		// `main.ts` so the CLI returns to the shell instead of stranding the user
 		// on Ctrl+C (issue #1041).
-		await runCommitCommand(cmd);
-		await postmortem.quit(0);
+		let exitCode = 0;
+		try {
+			const { usedFallback } = await runCommitCommand(cmd);
+			// A commit written by the mechanical fallback is a degraded outcome:
+			// the agent did not do the work it was asked to do, so the command
+			// reports non-zero so callers can distinguish it from a real
+			// single-commit decision (issue #7835).
+			if (usedFallback) exitCode = 1;
+		} catch (error) {
+			if (!(error instanceof CommitAbortedError)) throw error;
+			// Failure already reported with a readable message; exit non-zero
+			// without letting the runtime dump a stack/minified-source blob.
+			exitCode = 1;
+		}
+		await postmortem.quit(exitCode);
 	}
 }

package/src/commands/share.ts

@@ -0,0 +1,71 @@
+/**
+ * Share a saved session as an encrypted link without launching the agent.
+ *
+ * `omp share <session>` accepts a session id (prefix) or a path to a session
+ * `.jsonl` and uploads the sealed snapshot exactly like the `/share` slash
+ * command, honoring `share.serverUrl`, `share.store`, and
+ * `share.redactSecrets`.
+ */
+
+import { getAgentDir } from "@oh-my-pi/pi-utils";
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { shareHelp as commandHelp } from "../cli/command-help";
+import { Settings } from "../config/settings";
+import { shareSession } from "../export/share";
+import { buildSecretObfuscator } from "../secrets";
+import { resolveResumableSession } from "../session/session-listing";
+import { SessionManager } from "../session/session-manager";
+
+export default class Share extends Command {
+	static description = commandHelp.description;
+	static args = {
+		session: Args.string({
+			description: "Session id (prefix) or path to a session .jsonl",
+			required: true,
+		}),
+	};
+	static flags = {
+		gist: Flags.boolean({
+			description: "Upload to a secret GitHub gist instead of the share server",
+			default: false,
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Share);
+
+		const sessionArg = args.session ?? "";
+		let sessionPath = sessionArg;
+		if (!sessionArg.includes("/") && !sessionArg.includes("\\") && !sessionArg.endsWith(".jsonl")) {
+			const match = await resolveResumableSession(sessionArg, process.cwd());
+			if (!match) {
+				process.stderr.write(`Session "${sessionArg}" not found.\n`);
+				process.exitCode = 1;
+				return;
+			}
+			sessionPath = match.session.path;
+		}
+
+		const sm = await SessionManager.open(sessionPath);
+		// Settings resolve against the session's own project so its
+		// share.redactSecrets/secrets.enabled policy governs, not the invoking cwd's.
+		const settings = await Settings.loadReadOnly({ cwd: sm.getCwd() });
+		// Same leak boundary as /share: a share blob leaves the machine, so honor
+		// share.redactSecrets with the full obfuscator built against the session's
+		// own project directory (its secrets.yml, not the invoking cwd's).
+		const obfuscator =
+			settings.get("share.redactSecrets") && settings.get("secrets.enabled")
+				? await buildSecretObfuscator(sm.getCwd(), getAgentDir())
+				: undefined;
+
+		const result = await shareSession(sm, {
+			serverUrl: settings.get("share.serverUrl"),
+			store: flags.gist ? "gist" : settings.get("share.store"),
+			obfuscator,
+		});
+		const lines = [`Share URL: ${result.url}`];
+		if (result.gistUrl) lines.push(`Gist: ${result.gistUrl}`);
+		if (result.truncated) lines.push("Note: large content was trimmed to fit the share size limit.");
+		console.log(lines.join("\n"));
+	}
+}

package/src/commit/agentic/index.ts

@@ -11,6 +11,7 @@ import { ModelRegistry } from "../../config/model-registry";
 import { Settings } from "../../config/settings";
 import { discoverAuthStorage, discoverContextFiles, loadCliExtensionProviders } from "../../sdk";
 import * as git from "../../utils/git";
+import { abortOnGitFailure, pushOrAbort } from "../execute";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
 import { assignLockFilesToPlan } from "./lock-files";
@@ -25,7 +26,7 @@ interface CommitExecutionContext {
 	push: boolean;
 }
 
-export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
+export async function runAgenticCommit(args: CommitCommandArgs): Promise<{ usedFallback: boolean }> {
 	const cwd = getProjectDir();
 	const [settings, authStorage] = await Promise.all([Settings.init({ cwd }), discoverAuthStorage()]);
 
@@ -56,8 +57,13 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	);
 
 	if (stagedFiles.length === 0) {
+		if (args.push) {
+			process.stdout.write("No changes to commit; pushing existing commits...\n");
+			await pushOrAbort(cwd);
+			return { usedFallback: false };
+		}
 		process.stderr.write("No changes to commit.\n");
-		return;
+		return { usedFallback: false };
 	}
 
 	if (!args.noChangelog) {
@@ -94,7 +100,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 		process.stdout.write("● Forcing fallback commit generation...\n");
 		const fallbackProposal = generateFallbackProposal(numstat);
 		await runSingleCommit(fallbackProposal, { cwd, dryRun: args.dryRun, push: args.push });
-		return;
+		return { usedFallback: true };
 	}
 
 	const trivialChange = detectTrivialChange(diff);
@@ -111,7 +117,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 			warnings: [],
 		};
 		await runSingleCommit(trivialProposal, { cwd, dryRun: args.dryRun, push: args.push });
-		return;
+		return { usedFallback: false };
 	}
 
 	let existingChangelogEntries: ExistingChangelogEntries[] | undefined;
@@ -124,6 +130,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 
 	process.stdout.write("● Starting commit agent...\n");
 	let agentSessionCompleted = false;
+	let usedFallback = false;
 
 	try {
 		await runCommitAgentSession({
@@ -141,7 +148,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 			existingChangelogEntries,
 			onComplete: async commitState => {
 				agentSessionCompleted = true;
-				await completeAgentCommitState(commitState, {
+				usedFallback = await completeAgentCommitState(commitState, {
 					cwd,
 					dryRun: args.dryRun,
 					push: args.push,
@@ -151,7 +158,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 				});
 			},
 		});
-		return;
+		return { usedFallback };
 	} catch (error) {
 		if (agentSessionCompleted) {
 			throw error;
@@ -164,7 +171,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 		process.stdout.write("● Using fallback commit generation...\n");
 		const fallbackProposal = generateFallbackProposal(numstat);
 		await runSingleCommit(fallbackProposal, { cwd, dryRun: args.dryRun, push: args.push });
-		return;
+		return { usedFallback: true };
 	}
 }
 
@@ -175,7 +182,7 @@ async function completeAgentCommitState(
 		changelogTargets: string[];
 		numstat: NumstatEntry[];
 	},
-): Promise<void> {
+): Promise<boolean> {
 	let usedFallback = false;
 	if (!commitState.proposal && !commitState.splitProposal) {
 		if ($env.PI_COMMIT_NO_FALLBACK?.toLowerCase() !== "true") {
@@ -211,7 +218,7 @@ async function completeAgentCommitState(
 
 	if (commitState.proposal) {
 		await runSingleCommit(commitState.proposal, ctx);
-		return;
+		return usedFallback;
 	}
 
 	if (commitState.splitProposal) {
@@ -221,7 +228,7 @@ async function completeAgentCommitState(
 			push: ctx.push,
 			additionalFiles: updatedChangelogFiles,
 		});
-		return;
+		return usedFallback;
 	}
 
 	throw new Error("Commit agent did not provide a proposal.");
@@ -238,12 +245,14 @@ async function runSingleCommit(proposal: CommitProposal, ctx: CommitExecutionCon
 		return;
 	}
 	process.stdout.write("● Creating commit...\n");
-	await git.commit(ctx.cwd, commitMessage);
-	process.stdout.write("Commit created.\n");
-	if (ctx.push) {
-		await git.push(ctx.cwd);
-		process.stdout.write("Pushed to remote.\n");
+	try {
+		await git.commit(ctx.cwd, commitMessage);
+	} catch (error) {
+		if (error instanceof git.GitCommandError) abortOnGitFailure("Commit failed", error);
+		throw error;
 	}
+	process.stdout.write("Commit created.\n");
+	if (ctx.push) await pushOrAbort(ctx.cwd);
 }
 
 async function runSplitCommit(
@@ -296,7 +305,7 @@ async function runSplitCommit(
 	process.stdout.write("● Creating split commits...\n");
 	const stagedDiff = await git.diff(ctx.cwd, { cached: true, binary: true });
 	await git.stage.reset(ctx.cwd);
-	for (const commitIndex of order) {
+	for (const [position, commitIndex] of order.entries()) {
 		const commit = plan.commits[commitIndex];
 		await git.stage.hunks(ctx.cwd, commit.changes, { rawDiff: stagedDiff, diffCached: true });
 		const analysis: ConventionalAnalysis = {
@@ -306,14 +315,23 @@ async function runSplitCommit(
 			issueRefs: commit.issueRefs,
 		};
 		const message = formatCommitMessage(analysis, commit.summary);
-		await git.commit(ctx.cwd, message);
+		try {
+			await git.commit(ctx.cwd, message);
+		} catch (error) {
+			if (error instanceof git.GitCommandError) {
+				const stagedNow = await git.diff.changedFiles(ctx.cwd, { cached: true });
+				abortOnGitFailure(
+					`Commit ${position + 1} of ${order.length} failed`,
+					error,
+					`${position} of ${order.length} commits created; ${stagedNow.length} file(s) remain staged. No changes were lost.`,
+				);
+			}
+			throw error;
+		}
 		await git.stage.reset(ctx.cwd);
 	}
 	process.stdout.write("Split commits created.\n");
-	if (ctx.push) {
-		await git.push(ctx.cwd);
-		process.stdout.write("Pushed to remote.\n");
-	}
+	if (ctx.push) await pushOrAbort(ctx.cwd);
 }
 
 function appendFilesToLastCommit(plan: SplitCommitPlan, files: string[]): void {

package/src/commit/execute.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared commit-execution helpers for the agentic and legacy `omp commit`
+ * pipelines: readable failure reporting for refusing git hooks and a push
+ * wrapper that keeps a requested `--push` honest.
+ */
+
+import * as git from "../utils/git";
+
+/**
+ * A commit or push failure that has already been reported to the user with a
+ * readable message. It is thrown so the CLI exits non-zero without the runtime
+ * dumping a stack trace — in a bundled build that trace is several kilobytes of
+ * minified source, which buries the one line the user needs (issue #7834).
+ *
+ * `runCommitCommand`'s caller (`commands/commit.ts`) maps this to exit code 1.
+ */
+export class CommitAbortedError extends Error {
+	constructor() {
+		super("commit aborted");
+		this.name = "CommitAbortedError";
+	}
+}
+
+/**
+ * Print a git-command failure — most often a `pre-commit`/`commit-msg` hook
+ * that exited non-zero — as an indented message under `context`, then abort.
+ *
+ * @param context Label for the failed step, e.g. `"Commit 1 of 2 failed"`.
+ * @param error The failure to surface; its captured stderr/stdout is shown.
+ * @param note Optional trailing status line (split-plan progress, recovery).
+ */
+export function abortOnGitFailure(context: string, error: git.GitCommandError, note?: string): never {
+	const detail = error.result.stderr.trim() || error.result.stdout.trim() || error.message;
+	const body = detail
+		.split("\n")
+		.map(line => `    ${line}`)
+		.join("\n");
+	process.stderr.write(`✗ ${context}:\n${body}\n`);
+	if (note) process.stderr.write(`  ${note}\n`);
+	throw new CommitAbortedError();
+}
+
+/**
+ * Push the current branch, reporting a refused push (missing upstream, rejected
+ * ref) through {@link abortOnGitFailure} instead of letting the raw
+ * `GitCommandError` escape. Prints the success line on completion.
+ */
+export async function pushOrAbort(cwd: string): Promise<void> {
+	try {
+		await git.push(cwd);
+	} catch (error) {
+		if (error instanceof git.GitCommandError) abortOnGitFailure("Push failed", error);
+		throw error;
+	}
+	process.stdout.write("Pushed to remote.\n");
+}

package/src/commit/index.ts

@@ -2,4 +2,5 @@
  * Entry points for the omp commit command.
  */
 
-export { runCommitCommand } from "./pipeline";
+export * from "./execute";
+export * from "./pipeline";