gnhf 0.1.34 → 0.1.36

package/README.md

@@ -45,7 +45,7 @@ gnhf is a [ralph](https://ghuntley.com/ralph/), [autoresearch](https://github.co
 You wake up to a branch full of clean work and a log of everything that happened.
 
 - **Dead simple** — one command starts an autonomous loop that runs until you request stop or a configured runtime cap is reached
-- **Long running** — each iteration is committed on success, rolled back on failure, with sensible retries; retryable hard agent errors back off exponentially while agent-reported failures continue immediately
+- **Long running** — each iteration is committed on success, rolled back on failure except commit failures preserved for repair, with sensible retries; retryable hard agent errors back off exponentially while agent-reported failures continue immediately
 - **Live terminal title** — interactive runs keep your terminal title updated with live status, token totals, and commit count, then clear or restore it on exit depending on terminal support; token totals prefixed with `~` are estimates
 - **Exit summary**: every run ends with a permanent summary covering elapsed time, branch, iterations, tokens, branch diff stats, local notes/log paths, and review commands
 - **Agent-agnostic**: works with Claude Code, Codex, Rovo Dev, OpenCode, GitHub Copilot CLI, Pi, or ACP targets out of the box
@@ -71,6 +71,11 @@ $ gnhf --worktree "add tests for module Y" &
 $ gnhf --worktree "refactor the API layer" &
 ```
 
+```sh
+# Commit directly on the current branch and push after each successful iteration
+$ gnhf --current-branch --push "keep improving this app"
+```
+
 Run `gnhf` from inside a Git repository with a clean working tree. If you are starting from a plain directory, run `git init` first.
 `gnhf` supports macOS, Linux, and Windows.
 
@@ -101,7 +106,7 @@ npm link
                            ▼
                 ┌──────────────────────┐
                 │  validate clean git  │
-                │  create gnhf/ branch │
+                │  create or use branch │
                 │  write prompt.md     │
                 └──────────┬───────────┘
                            ▼
@@ -121,8 +126,8 @@ npm link
                   yes  │      │  no                        │
                        ▼      ▼                            │
               ┌──────────┐  ┌───────────┐                  │
-              │  commit  │  │ git reset │                  │
-              │  append  │  │  --hard   │                  │
+              │  commit  │  │ reset or  │                  │
+              │  append  │  │  repair   │                  │
               │ notes.md │  │ maybe wait│                  │
               └────┬─────┘  └─────┬─────┘                  │
                    │              │                        │
@@ -138,9 +143,9 @@ npm link
                     └──────────────────────────────────────┘
 ```
 
-- **Incremental commits** - each successful iteration is a separate unsigned git commit, so you can cherry-pick or revert individual changes without GPG or SSH signing prompts blocking the run
-- **Failure handling** - all failed iterations are rolled back with `git reset --hard`; agent-reported failures proceed to the next iteration immediately, retryable hard agent errors use exponential backoff, and permanent agent errors such as Claude low credit balance abort immediately and print the run log path. Complete no-op iterations are reported as failures and count toward the consecutive-failure abort limit.
-- **Runtime caps** - `--max-iterations` stops before the next iteration begins, `--max-tokens` can abort mid-iteration once reported usage reaches the cap, and `--stop-when` ends the loop after an iteration whose agent output reports the natural-language condition is met; resumed runs reuse the saved stop condition unless you pass a new value, or `--stop-when ""` to clear it; uncommitted work is rolled back in either case, and in the interactive TUI the final state remains visible until you press Ctrl+C to exit
+- **Incremental commits** - each successful iteration is a separate unsigned git commit, so you can cherry-pick or revert individual changes without GPG or SSH signing prompts blocking the run; if `git commit` fails, gnhf preserves the uncommitted work and asks the next agent iteration to repair it
+- **Failure handling** - failed iterations are rolled back with `git reset --hard` except commit failures, which preserve uncommitted work for repair; agent-reported failures proceed to the next iteration immediately, retryable hard agent errors use exponential backoff, and permanent agent errors such as Claude low credit balance abort immediately and print the run log path. Complete no-op iterations are reported as failures and count toward the consecutive-failure abort limit. If the run exits with a pending commit failure, the exit summary warns that uncommitted changes were left for repair.
+- **Runtime caps** - `--max-iterations` stops before the next iteration begins, `--max-tokens` can abort mid-iteration once reported usage reaches the cap, and `--stop-when` ends the loop after an iteration whose agent output reports the natural-language condition is met unless a commit failure needs repair first; resumed runs reuse the saved stop condition unless you pass a new value, or `--stop-when ""` to clear it; pending commit-failure repair work is preserved and other uncommitted work is rolled back, and in the interactive TUI the final state remains visible until you press Ctrl+C to exit
 - **Iteration finalization** - agents are expected to finish validation, stop any background processes they started, and only then emit the final JSON result for the iteration
 - **Graceful interrupts** - in the interactive TUI, the first Ctrl+C requests a graceful stop and lets the current iteration finish (or ends backoff early), the second Ctrl+C force-stops immediately, and `SIGTERM` also force-stops immediately
 - **Exit summary** - after shutdown cleanup, gnhf prints a permanent stdout summary with the final branch, elapsed time, iteration and token totals, branch diff stats, notes/debug-log paths, and review commands
@@ -148,6 +153,17 @@ npm link
 - **Local run metadata** — gnhf stores prompt, notes, stop conditions, and commit-message convention metadata under `.gnhf/runs/` and ignores it locally, so your branch only contains intentional work
 - **Resume support** — run `gnhf` while on an existing `gnhf/` branch to pick up where a previous run left off; if you provide a different prompt, gnhf asks whether to update the saved prompt and continue with the existing history, start a new branch, or quit. New runs whose generated branch already exists use a numeric suffix such as `gnhf/<slug>-1`.
 
+### Live Branch Mode
+
+Pass `--current-branch` to run on the branch you are already on instead of creating a `gnhf/` branch.
+Pass `--push` to push the current branch after each successful iteration.
+Together, `--current-branch --push` is useful for loose projects where you want a deployed or locally watched branch to update throughout the run.
+
+- Push failures abort the run after preserving the successful local commit.
+- gnhf never force-pushes or auto-pulls for this mode.
+- `--push` also works with the default `gnhf/` branch mode and sets `origin` as the upstream when needed.
+- Do not combine `--current-branch` with `--worktree`; gnhf exits with an error because those modes choose different working directories.
+
 ### Worktree Mode
 
 Pass `--worktree` to run each agent in an isolated [git worktree](https://git-scm.com/docs/git-worktree). This lets you launch multiple agents on the same repo simultaneously — each gets its own working directory and branch without interfering with the others or your main checkout.
@@ -161,7 +177,7 @@ Pass `--worktree` to run each agent in an isolated [git worktree](https://git-sc
 
 - Worktrees with commits are **preserved** after the run so you can review, merge, or cherry-pick the work. gnhf prints the path and cleanup command.
 - Re-running the same prompt with `--worktree` resumes a preserved matching worktree when possible; otherwise gnhf creates a suffixed worktree such as `<run-slug>-1` if the original name is unavailable.
-- Worktrees with **no commits** are automatically removed on exit.
+- Worktrees with **no commits** are automatically removed on exit unless a pending commit failure left uncommitted work to inspect or repair.
 - `--worktree` must be run from a non-gnhf branch (typically `main`).
 
 ## CLI Reference
@@ -182,9 +198,11 @@ If you run `gnhf` on an existing `gnhf/` branch with a different prompt, gnhf as
 | `--agent <agent>`        | Agent to use (`claude`, `codex`, `rovodev`, `opencode`, `copilot`, `pi`, or `acp:<target-or-command>`) | config file (`claude`) |
 | `--max-iterations <n>`   | Abort after `n` total iterations                                                                       | unlimited              |
 | `--max-tokens <n>`       | Abort after `n` total input+output tokens                                                              | unlimited              |
-| `--stop-when <cond>`     | End the loop when the agent reports this condition; persists across resume                             | unlimited              |
+| `--stop-when <cond>`     | End when the agent reports this condition, after any commit-failure repair; persists across resume     | unlimited              |
 | `--prevent-sleep <mode>` | Prevent system sleep during the run (`on`/`off` or `true`/`false`)                                     | config file (`on`)     |
 | `--worktree`             | Run in a separate git worktree (enables multiple agents concurrently)                                  | `false`                |
+| `--current-branch`       | Run on the current branch instead of creating a `gnhf/` branch                                         | `false`                |
+| `--push`                 | Push the current branch after each successful iteration                                                | `false`                |
 | `--version`              | Show version                                                                                           |                        |
 
 ## Configuration

package/dist/cli.mjs

@@ -416,6 +416,33 @@ const NOT_GIT_REPOSITORY_MESSAGE = "This command must be run inside a Git reposi
 function translateGitError(error) {
 	return error instanceof Error ? error : new Error(String(error));
 }
+function outputText(value) {
+	if (typeof value === "string") return value;
+	if (Buffer.isBuffer(value)) return value.toString("utf-8");
+	if (value instanceof Uint8Array) return Buffer.from(value).toString("utf-8");
+	return "";
+}
+function formatGitError(error) {
+	const parts = [
+		error instanceof Error ? error.message : String(error),
+		outputText(error.stdout),
+		outputText(error.stderr)
+	].map((part) => part.trim()).filter(Boolean);
+	return [...new Set(parts)].join("\n");
+}
+function firstLine(text) {
+	return text.split("\n").find((line) => line.trim())?.trim() ?? text;
+}
+var CommitFailedError = class extends Error {
+	detail;
+	constructor(error) {
+		const detail = formatGitError(error);
+		super(`git commit failed: ${firstLine(detail)}`);
+		this.name = "CommitFailedError";
+		this.detail = detail;
+		this.cause = error;
+	}
+};
 function git(args, cwd, options = {}) {
 	const env = {
 		...options.env ?? process.env,
@@ -562,18 +589,62 @@ function getBranchDiffStats(baseCommit, cwd) {
 	return stats;
 }
 function commitAll(message, cwd) {
+	const commitArgs = [
+		"-c",
+		"commit.gpgsign=false",
+		"-c",
+		"tag.gpgsign=false",
+		"commit",
+		"-m",
+		message
+	];
 	git(["add", "-A"], cwd);
 	try {
 		git([
-			"-c",
-			"commit.gpgsign=false",
-			"-c",
-			"tag.gpgsign=false",
-			"commit",
-			"-m",
-			message
+			"diff",
+			"--cached",
+			"--quiet"
 		], cwd);
+		return;
 	} catch {}
+	try {
+		git(commitArgs, cwd);
+	} catch (error) {
+		const commitError = new CommitFailedError(error);
+		appendDebugLog("git:commit:failed", {
+			error: serializeError(error),
+			detail: commitError.detail
+		});
+		throw commitError;
+	}
+}
+function pushCurrentBranch(cwd) {
+	let hasUpstream = true;
+	try {
+		git([
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		], cwd);
+	} catch {
+		hasUpstream = false;
+	}
+	if (hasUpstream) {
+		git(["push"], cwd);
+		return;
+	}
+	git([
+		"remote",
+		"get-url",
+		"origin"
+	], cwd);
+	git([
+		"push",
+		"-u",
+		"origin",
+		"HEAD"
+	], cwd);
 }
 function resetHard(cwd) {
 	git([
@@ -16377,6 +16448,7 @@ var Orchestrator = class extends EventEmitter {
 	activeIterationPromise = null;
 	activeAbortController = null;
 	pendingAbortReason = null;
+	pendingCommitFailure = null;
 	activeIterationTokensEstimated = false;
 	loopDone = false;
 	stoppedEventEmitted = false;
@@ -16413,7 +16485,8 @@ var Orchestrator = class extends EventEmitter {
 		return {
 			...this.state,
 			tokensEstimated: this.state.tokensEstimated || this.activeIterationTokensEstimated,
-			interruptHint: getInterruptHint(this.state)
+			interruptHint: getInterruptHint(this.state),
+			hasPendingCommitFailure: this.pendingCommitFailure !== null
 		};
 	}
 	requestGracefulStop() {
@@ -16466,6 +16539,7 @@ var Orchestrator = class extends EventEmitter {
 				await iterationPromise;
 			} else await this.closeAgent();
 			resetHard(this.cwd);
+			this.pendingCommitFailure = null;
 			this.state.status = "stopped";
 			this.emit("state", this.getState());
 			this.emitStopped();
@@ -16481,6 +16555,7 @@ var Orchestrator = class extends EventEmitter {
 			startIteration: this.state.currentIteration,
 			maxIterations: this.limits.maxIterations,
 			maxTokens: this.limits.maxTokens,
+			push: this.limits.push === true,
 			maxConsecutiveFailures: this.config.maxConsecutiveFailures,
 			baseCommit: this.runInfo.baseCommit,
 			initialCommitCount: this.state.commitCount
@@ -16497,13 +16572,14 @@ var Orchestrator = class extends EventEmitter {
 				this.state.status = "running";
 				this.emit("iteration:start", this.state.currentIteration);
 				this.emit("state", this.getState());
-				const iterationPrompt = buildIterationPrompt({
+				const baseIterationPrompt = buildIterationPrompt({
 					n: this.state.currentIteration,
 					runId: this.runInfo.runId,
 					prompt: this.prompt,
 					stopWhen: this.limits.stopWhen,
 					commitMessage: this.config.commitMessage
 				});
+				const iterationPrompt = this.pendingCommitFailure ? this.buildCommitRepairPrompt(baseIterationPrompt) : baseIterationPrompt;
 				appendDebugLog("iteration:start", {
 					iteration: this.state.currentIteration,
 					promptLength: iterationPrompt.length,
@@ -16550,6 +16626,10 @@ var Orchestrator = class extends EventEmitter {
 					tokensEstimated: this.state.tokensEstimated,
 					commitCount: this.state.commitCount
 				});
+				if (result.abortReason) {
+					this.abort(result.abortReason);
+					break;
+				}
 				if (this.stopForGracefulShutdown()) break;
 				if (this.limits.stopWhen !== void 0 && result.shouldFullyStop) {
 					this.abort("stop condition met");
@@ -16659,11 +16739,16 @@ var Orchestrator = class extends EventEmitter {
 			});
 			if (this.stopRequested) return { type: "stopped" };
 			const shouldFullyStop = result.output.should_fully_stop === true;
-			if (result.output.success) return {
-				type: "completed",
-				record: this.recordSuccess(result.output),
-				shouldFullyStop
-			};
+			if (result.output.success) {
+				const record = this.recordSuccess(result.output);
+				const abortReason = record.success && this.limits.push === true ? this.pushAfterSuccess() : void 0;
+				return {
+					type: "completed",
+					record,
+					shouldFullyStop: record.success ? shouldFullyStop : false,
+					...abortReason === void 0 ? {} : { abortReason }
+				};
+			}
 			return {
 				type: "completed",
 				record: this.recordFailure(`[FAIL] ${result.output.summary}`, result.output.summary, toStringArray(result.output.key_learnings), "reported"),
@@ -16681,7 +16766,7 @@ var Orchestrator = class extends EventEmitter {
 					elapsedMs,
 					reason: this.pendingAbortReason
 				});
-				resetHard(this.cwd);
+				if (this.pendingCommitFailure === null) resetHard(this.cwd);
 				return {
 					type: "aborted",
 					reason: this.pendingAbortReason
@@ -16700,7 +16785,7 @@ var Orchestrator = class extends EventEmitter {
 				error: serializeError(err)
 			});
 			if (err instanceof PermanentAgentError) {
-				resetHard(this.cwd);
+				if (this.pendingCommitFailure === null) resetHard(this.cwd);
 				this.state.lastAgentError = err.detail;
 				return {
 					type: "aborted",
@@ -16719,8 +16804,16 @@ var Orchestrator = class extends EventEmitter {
 		}
 	}
 	recordSuccess(output) {
-		appendNotes(this.runInfo.notesPath, this.state.currentIteration, output.summary, toStringArray(output.key_changes_made), toStringArray(output.key_learnings));
-		commitAll(buildCommitMessage(this.config.commitMessage, output, { iteration: this.state.currentIteration }), this.cwd);
+		const keyChanges = toStringArray(output.key_changes_made);
+		const keyLearnings = toStringArray(output.key_learnings);
+		try {
+			commitAll(buildCommitMessage(this.config.commitMessage, output, { iteration: this.state.currentIteration }), this.cwd);
+		} catch (error) {
+			if (error instanceof CommitFailedError) return this.recordCommitFailure(error);
+			throw error;
+		}
+		this.pendingCommitFailure = null;
+		appendNotes(this.runInfo.notesPath, this.state.currentIteration, output.summary, keyChanges, keyLearnings);
 		this.state.commitCount = getBranchCommitCount(this.runInfo.baseCommit, this.cwd);
 		this.state.successCount++;
 		this.state.consecutiveFailures = 0;
@@ -16730,14 +16823,60 @@ var Orchestrator = class extends EventEmitter {
 			number: this.state.currentIteration,
 			success: true,
 			summary: output.summary,
-			keyChanges: toStringArray(output.key_changes_made),
-			keyLearnings: toStringArray(output.key_learnings),
+			keyChanges,
+			keyLearnings,
 			timestamp: /* @__PURE__ */ new Date()
 		};
 	}
+	buildCommitRepairPrompt(basePrompt) {
+		return `${basePrompt}
+
+## Previous Commit Failure
+
+The previous iteration made workspace changes, but gnhf could not commit them because git commit failed.
+Do not start unrelated work.
+Inspect and fix the existing uncommitted changes so the commit can pass, then report success.
+
+Git commit output:
+
+\`\`\`
+${this.pendingCommitFailure}
+\`\`\``;
+	}
+	recordCommitFailure(error) {
+		this.pendingCommitFailure = error.detail;
+		const summary = "git commit failed; asking agent to repair the workspace";
+		appendNotes(this.runInfo.notesPath, this.state.currentIteration, `[ERROR] ${summary}`, [], [error.detail]);
+		this.state.failCount++;
+		this.state.consecutiveFailures++;
+		this.state.consecutiveErrors = 0;
+		this.state.lastAgentError = error.detail;
+		return {
+			number: this.state.currentIteration,
+			success: false,
+			summary,
+			keyChanges: [],
+			keyLearnings: [error.detail],
+			timestamp: /* @__PURE__ */ new Date()
+		};
+	}
+	pushAfterSuccess() {
+		try {
+			pushCurrentBranch(this.cwd);
+			appendDebugLog("git:push:success", { iteration: this.state.currentIteration });
+			return;
+		} catch (err) {
+			appendDebugLog("git:push:error", {
+				iteration: this.state.currentIteration,
+				error: serializeError(err)
+			});
+			return `push failed: ${err instanceof Error ? err.message : String(err)}`;
+		}
+	}
 	recordFailure(notesSummary, recordSummary, learnings, kind) {
+		const hadPendingCommitFailure = this.pendingCommitFailure !== null;
 		appendNotes(this.runInfo.notesPath, this.state.currentIteration, notesSummary, [], toStringArray(learnings));
-		resetHard(this.cwd);
+		if (!hadPendingCommitFailure) resetHard(this.cwd);
 		this.state.failCount++;
 		this.state.consecutiveFailures++;
 		if (kind === "error") {
@@ -16951,7 +17090,7 @@ function renderExitSummary(options) {
 	const title = stopped ? `${s.red("×")} ${s.bold("gnhf stopped")}` : `${s.cyan("✦")} ${s.bold("gnhf wrapped")}`;
 	const subtitle = stopped ? `${s.cyan(options.agentName)} ran for ${s.yellow(elapsed)} before: ${options.abortReason ?? options.status}` : `${s.cyan(options.agentName)} worked for ${s.yellow(elapsed)} on ${s.magenta(options.branchName)}`;
 	const cardWidth = resolveCardWidth([title, `  ${subtitle}`], options.terminalColumns);
-	const rolledBack = `${options.failCount} rolled back`;
+	const failed = `${options.failCount} failed`;
 	const inputTokens = formatTokenCount$1(options.totalInputTokens, "in", options.tokensEstimated);
 	const outputTokens = formatTokenCount$1(options.totalOutputTokens, "out", options.tokensEstimated);
 	const commits = plural(options.commitCount, "commit");
@@ -16966,7 +17105,7 @@ function renderExitSummary(options) {
 		metricLine(s.dim("iterations"), [
 			`${s.bold(String(options.iterations))} total`,
 			s.green(`${options.successCount} good`),
-			stopped ? s.red(rolledBack) : s.yellow(rolledBack)
+			stopped ? s.red(failed) : s.yellow(failed)
 		]),
 		metricLine(s.dim("tokens"), [s.bold(inputTokens), s.bold(outputTokens)]),
 		metricLine(s.dim("branch diff"), [
@@ -16982,6 +17121,7 @@ function renderExitSummary(options) {
 		"",
 		commandLine(s.dim("notes"), options.notesPath),
 		commandLine(s.dim("debug log"), options.logPath),
+		...options.hasPendingCommitFailure ? [commandLine(s.yellow("uncommitted"), "commit failed; changes were left for repair")] : [],
 		"",
 		commandLine(s.dim("next steps"), s.cyan(`git log --oneline ${options.baseRef}..HEAD`)),
 		continuationLine(s.cyan(`git diff --stat ${options.baseRef}..HEAD`)),
@@ -17913,6 +18053,11 @@ function initializeNewBranch(prompt, cwd, schemaOptions) {
 	const runId = createBranchWithSuffix(slugifyPrompt(prompt), cwd).split("/")[1];
 	return setupRun(runId, prompt, baseCommit, cwd, schemaOptions);
 }
+function initializeCurrentBranchRun(prompt, cwd, schemaOptions) {
+	ensureCleanWorkingTree(cwd);
+	const baseCommit = getHeadCommit(cwd);
+	return setupRun(createRunIdWithSuffix(slugifyPrompt(prompt).split("/")[1], cwd), prompt, baseCommit, cwd, schemaOptions);
+}
 function branchNameWithSuffix(branchName, suffix) {
 	return suffix === 0 ? branchName : `${branchName}-${suffix}`;
 }
@@ -17932,6 +18077,16 @@ function createBranchWithSuffix(branchName, cwd) {
 	}
 	throw new Error(`Unable to create a unique branch name for ${branchName}`);
 }
+function runIdWithSuffix(runId, suffix) {
+	return suffix === 0 ? runId : `${runId}-${suffix}`;
+}
+function createRunIdWithSuffix(runId, cwd) {
+	for (let suffix = 0; suffix < 100; suffix += 1) {
+		const candidate = runIdWithSuffix(runId, suffix);
+		if (!existsSync(join(cwd, ".gnhf", "runs", candidate))) return candidate;
+	}
+	throw new Error(`Unable to create a unique run id for ${runId}`);
+}
 function initializeWorktreeRun(prompt, cwd, schemaOptions, resumeSchemaOptions) {
 	const repoRoot = getRepoRootDir(cwd);
 	const baseCommit = getHeadCommit(cwd);
@@ -18109,7 +18264,7 @@ function readReexecStdinPrompt(env) {
 	}
 }
 const program = new Command();
-program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", `Agent to use (${AGENT_NAMES.join(", ")}, or acp:<target-or-command>)`).option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--stop-when <condition>", "End when the agent reports this condition; resumes reuse it, pass a new value to overwrite or \"\" to clear").option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--worktree", "Run in a separate git worktree (enables multiple agents on the same repo)", false).option("--mock", "", false).action(async (promptArg, options) => {
+program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", `Agent to use (${AGENT_NAMES.join(", ")}, or acp:<target-or-command>)`).option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--stop-when <condition>", "End when the agent reports this condition, after any commit-failure repair; resumes reuse it, pass a new value to overwrite or \"\" to clear").option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--worktree", "Run in a separate git worktree (enables multiple agents on the same repo)", false).option("--current-branch", "Run on the current branch instead of creating a gnhf branch", false).option("--push", "Push the current branch after each successful iteration", false).option("--mock", "", false).action(async (promptArg, options) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
@@ -18158,6 +18313,10 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 	let worktreeCleanup = null;
 	const currentBranch = getCurrentBranch(cwd);
 	const onGnhfBranch = currentBranch.startsWith("gnhf/");
+	if (options.currentBranch && options.worktree) {
+		console.error("Cannot combine --current-branch and --worktree.");
+		process$1.exit(1);
+	}
 	const cliStopWhen = options.stopWhen === "" ? void 0 : options.stopWhen;
 	let effectiveStopWhen = cliStopWhen;
 	let effectiveCommitMessage = config.commitMessage;
@@ -18194,6 +18353,12 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 				if (worktreeCleanup === exitCleanup) exitCleanup();
 			});
 		}
+	} else if (options.currentBranch) {
+		if (!prompt) {
+			program.help();
+			return;
+		}
+		runInfo = initializeCurrentBranchRun(prompt, cwd, schemaOptions);
 	} else if (onGnhfBranch) {
 		const existingRunId = currentBranch.slice(5);
 		const existingMetadata = peekRunMetadata(existingRunId, cwd);
@@ -18250,7 +18415,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			if (!reexeced) persistedPrompt?.cleanup();
 		}
 	}
-	const runMode = options.worktree ? "worktree" : startIteration > 0 ? "resume" : "new";
+	const runMode = options.worktree ? "worktree" : options.currentBranch ? "current-branch" : startIteration > 0 ? "resume" : "new";
 	const telemetryAgent = getTelemetryAgent(config.agent);
 	telemetry.pageview("/run", {
 		agent: telemetryAgent,
@@ -18273,6 +18438,8 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		agentArgsOverride: getNativeAgentName(config.agent) ? config.agentArgsOverride?.[getNativeAgentName(config.agent)] : void 0,
 		worktree: options.worktree,
 		worktreePath,
+		currentBranch: options.currentBranch,
+		push: options.push,
 		platform: process$1.platform,
 		nodeVersion: process$1.version,
 		gnhfVersion: packageVersion
@@ -18288,7 +18455,8 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 	}, agent, runInfo, prompt, effectiveCwd, startIteration, {
 		maxIterations: options.maxIterations,
 		maxTokens: options.maxTokens,
-		stopWhen: effectiveStopWhen
+		stopWhen: effectiveStopWhen,
+		...options.push ? { push: true } : {}
 	});
 	let shutdownSignal = null;
 	let forceShutdownRequested = false;
@@ -18380,7 +18548,8 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			baseRef: runInfo.baseCommit.slice(0, 12) || runInfo.baseCommit,
 			diffStats,
 			color: shouldUseColor(),
-			terminalColumns: process$1.stdout.columns
+			terminalColumns: process$1.stdout.columns,
+			hasPendingCommitFailure: finalState.hasPendingCommitFailure
 		});
 		appendDebugLog("run:complete", {
 			signal: shutdownSignal,
@@ -18406,12 +18575,13 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			total_output_tokens: finalState.totalOutputTokens,
 			duration_ms: Date.now() - runStartedAt,
 			prevent_sleep: config.preventSleep === true,
+			push_each_iteration: options.push === true,
 			commit_message_preset: effectiveCommitMessage?.preset ?? "default",
 			stop_when_set: effectiveStopWhen !== void 0
 		});
 		await telemetry.close(1e3);
 		if (finalState.status === "aborted") console.error(`\n  gnhf: Run log: ${runInfo.logPath}\n`);
-		if (worktreePath) if (finalState.commitCount > 0) {
+		if (worktreePath) if (finalState.commitCount > 0 || finalState.hasPendingCommitFailure) {
 			worktreeCleanup = null;
 			console.error(`\n  gnhf: worktree preserved at ${worktreePath}\n  gnhf: merge the branch and remove with: git worktree remove "${worktreePath}"\n`);
 		} else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnhf",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "description": "Before I go to bed, I tell my agents: good night, have fun",
   "type": "module",
   "bin": {