gnhf 0.1.32 → 0.1.34

package/README.md

@@ -47,6 +47,7 @@ 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
 - **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
 
 ## Quick Start
@@ -142,6 +143,7 @@ npm link
 - **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
 - **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
 - **Shared memory** — the agent reads `notes.md` (built up from prior iterations) to communicate across iterations
 - **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`.
@@ -175,22 +177,22 @@ If you run `gnhf` on an existing `gnhf/` branch with a different prompt, gnhf as
 
 ### Flags
 
-| Flag                     | Description                                                                                 | Default                |
-| ------------------------ | ------------------------------------------------------------------------------------------- | ---------------------- |
-| `--agent <agent>`        | Agent to use (`claude`, `codex`, `rovodev`, `opencode`, `copilot`, `pi`, or `acp:<target>`) | 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              |
-| `--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`                |
-| `--version`              | Show version                                                                                |                        |
+| Flag                     | Description                                                                                            | Default                |
+| ------------------------ | ------------------------------------------------------------------------------------------------------ | ---------------------- |
+| `--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              |
+| `--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`                |
+| `--version`              | Show version                                                                                           |                        |
 
 ## Configuration
 
 Config lives at `~/.gnhf/config.yml`:
 
 ```yaml
-# Agent to use by default (claude, codex, rovodev, opencode, copilot, pi, or acp:<target>)
+# Agent to use by default (claude, codex, rovodev, opencode, copilot, pi, or acp:<target-or-command>)
 agent: claude
 
 # Custom paths to native agent binaries (optional)
@@ -225,7 +227,7 @@ agent: claude
 #   staging: "node /opt/staging/agent.mjs"
 
 # Commit message convention (optional)
-# Defaults to: gnhf #<iteration>: <summary>
+# Defaults to: gnhf <iteration>: <summary>
 # Use the conventional preset for semantic-release compatible headers:
 # commitMessage:
 #   preset: conventional
@@ -245,6 +247,7 @@ The iteration and token caps are runtime-only flags and are not persisted in `co
 `agentArgsOverride.<name>` lets you pass through extra CLI flags for native agents (`claude`, `codex`, `rovodev`, `opencode`, `copilot`, or `pi`).
 ACP targets do not support path or arg overrides in this version.
 Use `acpRegistryOverrides` to map `acp:<target>` names to custom spawn commands for local, forked, or beta ACP agents.
+You can also pass a raw custom ACP server command directly as a quoted `acp:` spec, for example `gnhf --agent 'acp:./bin/dev-acp --profile ci' "fix the tests"`.
 
 - Use it for agent-specific options like models, profiles, or reasoning settings without adding a dedicated `gnhf` config field for each one.
 - For `codex`, `claude`, and `copilot`, `gnhf` adds its usual non-interactive permission default only when you do not provide your own permission or execution-mode flag. If you set one explicitly, `gnhf` treats that as user-managed and does not add its default on top.
@@ -252,7 +255,7 @@ Use `acpRegistryOverrides` to map `acp:<target>` names to custom spawn commands
 
 `commitMessage` controls the subject line that gnhf uses for each successful iteration commit.
 
-- Omit it to keep the default `gnhf #<iteration>: <summary>` format.
+- Omit it to keep the default `gnhf <iteration>: <summary>` format.
 - Set `preset: conventional` to ask the agent for `type` and optional `scope`, then commit as `type(scope): summary` for semantic-release style workflows. Valid types are `build`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `test`, and `chore`; invalid or missing types fall back to `chore`, and empty scopes are omitted.
 - The resolved commit-message convention is saved per run, so resuming a `gnhf/` branch keeps the original subject format even if `config.yml` changes later.
 
@@ -273,7 +276,8 @@ When sleep prevention is enabled, `gnhf` uses the native mechanism for your OS:
 
 ## Debug Logs
 
-Every run writes a JSONL debug log to `.gnhf/runs/<runId>/gnhf.log` alongside `notes.md`. Lifecycle events for the orchestrator, agent, and HTTP requests are captured with elapsed timings and (for failures) the full `error.cause` chain — which is what you need to tell a bare `TypeError: fetch failed` apart from an undici `UND_ERR_HEADERS_TIMEOUT`. The agent's own streaming output still goes to the per-iteration `iteration-<n>.jsonl` file next to it.
+Every run writes a JSONL debug log to `.gnhf/runs/<runId>/gnhf.log` alongside `notes.md`. Lifecycle events for the orchestrator, agent, and HTTP requests are captured with elapsed timings and (for failures) the full `error.cause` chain, which is what you need to tell a bare `TypeError: fetch failed` apart from an undici `UND_ERR_HEADERS_TIMEOUT`. The agent's own streaming output still goes to the per-iteration `iteration-<n>.jsonl` file next to it.
+Raw ACP command specs are redacted as `acp:custom`/`custom` in debug logs and related errors, so local paths or secrets in custom commands are not written to `gnhf.log`.
 
 Including a snippet of `gnhf.log` is the single most useful thing you can attach when filing an issue.
 
@@ -285,17 +289,17 @@ Set `GNHF_TELEMETRY=0` to turn it off.
 
 ## Agents
 
-`gnhf` supports six native agents plus ACP targets. ACP support is powered by [`acpx`](https://github.com/openclaw/acpx), which is bundled with `gnhf` and provides the runtime and agent registry for `acp:<target>` specs.
-
-| Agent              | Flag                   | Requirements                                                                                                                            | Notes                                                                                                                                                                                                                                                                                      |
-| ------------------ | ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Claude Code        | `--agent claude`       | Install Anthropic's `claude` CLI and sign in first.                                                                                     | `gnhf` invokes `claude` directly in non-interactive mode. After Claude emits a successful structured result, `gnhf` treats that result as final and shuts down any lingering Claude process tree after a short grace period.                                                               |
-| Codex              | `--agent codex`        | Install OpenAI's `codex` CLI and sign in first.                                                                                         | `gnhf` invokes `codex exec` directly in non-interactive mode.                                                                                                                                                                                                                              |
-| GitHub Copilot CLI | `--agent copilot`      | Install GitHub Copilot CLI and sign in first.                                                                                           | `gnhf` invokes `copilot` directly in non-interactive JSONL mode. Copilot currently exposes assistant output tokens, but not full input/cache token totals; see https://github.com/github/copilot-cli/issues/1152.                                                                          |
-| Pi                 | `--agent pi`           | Install the `pi` CLI and configure a usable provider/model first.                                                                       | `gnhf` invokes `pi` directly in JSON mode, appends the final output schema to the prompt, and disables Pi session persistence with `--no-session`.                                                                                                                                         |
-| Rovo Dev           | `--agent rovodev`      | Install Atlassian's `acli` and authenticate it with Rovo Dev first.                                                                     | `gnhf` starts a local `acli rovodev serve --disable-session-token <port>` process automatically in the repo workspace.                                                                                                                                                                     |
-| OpenCode           | `--agent opencode`     | Install `opencode` and configure at least one usable model provider first.                                                              | `gnhf` starts a local `opencode serve --hostname 127.0.0.1 --port <port> --print-logs` process automatically, creates a per-run session, and applies a blanket allow rule so tool calls do not block on prompts.                                                                           |
-| ACP target         | `--agent acp:<target>` | Install and authenticate the target supported by the bundled [`acpx`](https://github.com/openclaw/acpx) registry, such as `acp:gemini`. | `gnhf` runs the target through ACP with a persistent per-run session under `.gnhf/runs/<runId>/acp-sessions`; token usage and `--max-tokens` use ACP `used` deltas when available, with prompt-length plus tool-call estimates as a fallback, and `agentPathOverride` and `agentArgsOverride` do not apply. |
+`gnhf` supports six native agents plus ACP targets. ACP support is powered by [`acpx`](https://github.com/openclaw/acpx), which is bundled with `gnhf` and provides the runtime and agent registry for `acp:<target-or-command>` specs.
+
+| Agent              | Flag                              | Requirements                                                                                                                                                                        | Notes                                                                                                                                                                                                                                                                                                       |
+| ------------------ | --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Claude Code        | `--agent claude`                  | Install Anthropic's `claude` CLI and sign in first.                                                                                                                                 | `gnhf` invokes `claude` directly in non-interactive mode. After Claude emits a successful structured result, `gnhf` treats that result as final and shuts down any lingering Claude process tree after a short grace period.                                                                                |
+| Codex              | `--agent codex`                   | Install OpenAI's `codex` CLI and sign in first.                                                                                                                                     | `gnhf` invokes `codex exec` directly in non-interactive mode.                                                                                                                                                                                                                                               |
+| GitHub Copilot CLI | `--agent copilot`                 | Install GitHub Copilot CLI and sign in first.                                                                                                                                       | `gnhf` invokes `copilot` directly in non-interactive JSONL mode. Copilot currently exposes assistant output tokens, but not full input/cache token totals; see https://github.com/github/copilot-cli/issues/1152.                                                                                           |
+| Pi                 | `--agent pi`                      | Install the `pi` CLI and configure a usable provider/model first.                                                                                                                   | `gnhf` invokes `pi` directly in JSON mode, appends the final output schema to the prompt, and disables Pi session persistence with `--no-session`.                                                                                                                                                          |
+| Rovo Dev           | `--agent rovodev`                 | Install Atlassian's `acli` and authenticate it with Rovo Dev first.                                                                                                                 | `gnhf` starts a local `acli rovodev serve --disable-session-token <port>` process automatically in the repo workspace.                                                                                                                                                                                      |
+| OpenCode           | `--agent opencode`                | Install `opencode` and configure at least one usable model provider first.                                                                                                          | `gnhf` starts a local `opencode serve --hostname 127.0.0.1 --port <port> --print-logs` process automatically, creates a per-run session, and applies a blanket allow rule so tool calls do not block on prompts.                                                                                            |
+| ACP target         | `--agent acp:<target-or-command>` | Install and authenticate the target supported by the bundled [`acpx`](https://github.com/openclaw/acpx) registry, such as `acp:gemini`, or pass a quoted custom ACP server command. | `gnhf` runs the target through ACP with a persistent per-run session under `.gnhf/runs/<runId>/acp-sessions`; token usage and `--max-tokens` use ACP `used` deltas when available, with prompt-length plus tool-call estimates as a fallback, and `agentPathOverride` and `agentArgsOverride` do not apply. |
 
 ## Development
 

package/dist/cli.mjs

@@ -37,12 +37,21 @@ const AGENT_NAMES = [
 	"copilot",
 	"pi"
 ];
-const ACP_SPEC_PATTERN = /^acp:[A-Za-z0-9][A-Za-z0-9._:-]*$/;
 function isAgentName$1(name) {
-	return AGENT_NAMES.includes(name);
+	return typeof name === "string" && AGENT_NAMES.includes(name);
+}
+function hasDisallowedAcpTargetChar(target) {
+	for (let i = 0; i < target.length; i += 1) {
+		const code = target.charCodeAt(i);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
 }
 function isAcpSpec(spec) {
-	return ACP_SPEC_PATTERN.test(spec);
+	if (typeof spec !== "string") return false;
+	if (!spec.startsWith("acp:")) return false;
+	const target = spec.slice(4);
+	return target.length > 0 && target.trim() === target && !hasDisallowedAcpTargetChar(target);
 }
 function isAgentSpec(spec) {
 	return isAgentName$1(spec) || isAcpSpec(spec);
@@ -50,6 +59,16 @@ function isAgentSpec(spec) {
 function getAcpTarget(spec) {
 	return spec.slice(4);
 }
+function isNamedAcpTarget(target) {
+	return ACP_TARGET_NAME_PATTERN.test(target);
+}
+function redactAcpTargetForLogs(target) {
+	return isNamedAcpTarget(target) ? target : "custom";
+}
+function redactAgentSpecForLogs(spec) {
+	if (!spec.startsWith("acp:")) return spec;
+	return `acp:${redactAcpTargetForLogs(spec.slice(4))}`;
+}
 const DEFAULT_CONFIG = {
 	agent: "claude",
 	agentPathOverride: {},
@@ -199,12 +218,19 @@ function serializeAgentArgsOverride(agentArgsOverride) {
 		sortKeys: false
 	}).trimEnd();
 }
+function serializeAgent(agent) {
+	return yaml.dump({ agent }, {
+		lineWidth: -1,
+		noRefs: true,
+		sortKeys: false
+	}).trimEnd();
+}
 function serializeConfig(config) {
 	const agentPathOverrideSection = serializeAgentPathOverride(config.agentPathOverride);
 	const agentArgsOverrideSection = serializeAgentArgsOverride(config.agentArgsOverride);
 	const lines = [
-		"# Agent to use by default: native agent name or acp:<target>",
-		`agent: ${config.agent}`,
+		"# Agent to use by default: native agent name or acp:<target-or-command>",
+		serializeAgent(config.agent),
 		"",
 		"# Custom paths to native agent binaries (optional)",
 		"# Paths may be absolute, bare executable names on PATH,",
@@ -237,14 +263,14 @@ function serializeConfig(config) {
 		"#     - high",
 		"",
 		"# Custom ACP target commands (optional)",
-		"# Maps acp:<target> names to spawn commands. Useful for pinning a",
+		"# Maps acp:<target> names to spawn commands. Useful for naming a",
 		"# local or beta build of an ACP agent.",
 		"# acpRegistryOverrides:",
 		"#   my-fork: \"/usr/local/bin/my-claude-code-fork --acp\"",
 		"#   staging: \"node /opt/staging/agent.mjs\"",
 		"",
 		"# Commit message convention (optional)",
-		"# Defaults to: gnhf #<iteration>: <summary>",
+		"# Defaults to: gnhf <iteration>: <summary>",
 		"# Use Conventional Commits semantic-release headers:",
 		"# commitMessage:",
 		"#   preset: conventional"
@@ -479,6 +505,62 @@ function getBranchCommitCount(baseCommit, cwd) {
 		`${baseCommit}..HEAD`
 	], cwd), 10);
 }
+function emptyBranchDiffStats$1() {
+	return {
+		commits: 0,
+		filesChanged: 0,
+		filesAdded: 0,
+		filesUpdated: 0,
+		filesDeleted: 0,
+		filesRenamed: 0,
+		binaryFiles: 0,
+		linesAdded: 0,
+		linesDeleted: 0
+	};
+}
+function getBranchDiffStats(baseCommit, cwd) {
+	if (!baseCommit) return emptyBranchDiffStats$1();
+	const range = `${baseCommit}..HEAD`;
+	const stats = emptyBranchDiffStats$1();
+	stats.commits = Number.parseInt(git([
+		"rev-list",
+		"--count",
+		"--first-parent",
+		range
+	], cwd), 10);
+	const nameStatus = git([
+		"diff",
+		"--name-status",
+		range
+	], cwd);
+	for (const line of nameStatus.split("\n")) {
+		if (!line) continue;
+		const [status] = line.split("	");
+		stats.filesChanged++;
+		if (status === "A") stats.filesAdded++;
+		else if (status === "D") stats.filesDeleted++;
+		else if (status?.startsWith("R")) {
+			stats.filesUpdated++;
+			stats.filesRenamed++;
+		} else stats.filesUpdated++;
+	}
+	const numstat = git([
+		"diff",
+		"--numstat",
+		range
+	], cwd);
+	for (const line of numstat.split("\n")) {
+		if (!line) continue;
+		const [added, deleted] = line.split("	");
+		if (added === "-" || deleted === "-") {
+			stats.binaryFiles++;
+			continue;
+		}
+		stats.linesAdded += Number.parseInt(added ?? "0", 10) || 0;
+		stats.linesDeleted += Number.parseInt(deleted ?? "0", 10) || 0;
+	}
+	return stats;
+}
 function commitAll(message, cwd) {
 	git(["add", "-A"], cwd);
 	try {
@@ -660,7 +742,7 @@ function resolveConventionalScope(value) {
 	return scope === "" ? "" : `(${scope})`;
 }
 function buildCommitMessage(config, output, context) {
-	if (config === void 0) return collapseHeader(`gnhf #${context.iteration}: ${output.summary}`);
+	if (config === void 0) return collapseHeader(`gnhf ${context.iteration}: ${output.summary}`);
 	const commitOutput = output;
 	return collapseHeader(`${resolveConventionalType(commitOutput.type)}${resolveConventionalScope(commitOutput.scope)}: ${output.summary}`);
 }
@@ -13461,6 +13543,40 @@ function isAbortError$2(error) {
 function createAbortError$2() {
 	return /* @__PURE__ */ new Error("Agent was aborted");
 }
+function redactRawAcpTargetInString(text, target) {
+	const redacted = redactAcpTargetForLogs(target);
+	if (redacted === target) return text;
+	return text.split(target).join(redacted);
+}
+function redactRawAcpTargetInValue(value, target) {
+	if (typeof value === "string") return redactRawAcpTargetInString(value, target);
+	if (Array.isArray(value)) return value.map((item) => redactRawAcpTargetInValue(item, target));
+	if (value !== null && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, redactRawAcpTargetInValue(entry, target)]));
+	return value;
+}
+function serializeAcpErrorForLog(error, target) {
+	return redactRawAcpTargetInValue(serializeError(error), target);
+}
+function redactAcpErrorForThrow(error, target) {
+	if (redactAcpTargetForLogs(target) === target) return error;
+	if (error instanceof PermanentAgentError) return new PermanentAgentError(redactRawAcpTargetInString(error.message, target), redactRawAcpTargetInString(error.detail, target));
+	if (error instanceof Error) {
+		let cause;
+		try {
+			cause = "cause" in error ? error.cause : void 0;
+		} catch {
+			cause = void 0;
+		}
+		const redactedCause = cause === void 0 ? void 0 : redactAcpErrorForThrow(cause, target);
+		const redactedError = new Error(redactRawAcpTargetInString(error.message, target), redactedCause === void 0 ? void 0 : { cause: redactedCause });
+		redactedError.name = error.name;
+		if (typeof error.stack === "string") redactedError.stack = redactRawAcpTargetInString(error.stack, target);
+		const code = error.code;
+		if (code !== void 0) redactedError.code = code;
+		return redactedError;
+	}
+	return redactRawAcpTargetInValue(error, target);
+}
 function estimateTokens(charCount) {
 	if (charCount <= 0) return 0;
 	return Math.ceil(charCount / 4);
@@ -13493,30 +13609,47 @@ var AcpAgent = class {
 		const { signal, onMessage, onUsage, logPath } = options ?? {};
 		if (signal?.aborted) throw createAbortError$2();
 		const runtime = this.ensureRuntime(cwd);
-		const handle = await runtime.ensureSession({
-			sessionKey: this.runId,
-			agent: this.target,
-			mode: "persistent",
-			cwd
-		});
+		let handle;
+		try {
+			handle = await runtime.ensureSession({
+				sessionKey: this.runId,
+				agent: this.target,
+				mode: "persistent",
+				cwd
+			});
+		} catch (error) {
+			throw redactAcpErrorForThrow(error, this.target);
+		}
 		this.handle = handle;
 		const requestId = randomUUID();
 		appendDebugLog("acp:turn:start", {
-			target: this.target,
+			target: redactAcpTargetForLogs(this.target),
 			sessionKey: this.runId,
 			requestId,
 			cwd
 		});
 		const acpPrompt = buildAcpPrompt(prompt, this.schema);
 		const promptTokenEstimate = estimateTokens(acpPrompt.length);
-		const turn = runtime.startTurn({
-			handle,
-			text: acpPrompt,
-			mode: "prompt",
-			requestId,
-			signal
-		});
 		const startedAt = Date.now();
+		const turn = (() => {
+			try {
+				return runtime.startTurn({
+					handle,
+					text: acpPrompt,
+					mode: "prompt",
+					requestId,
+					signal
+				});
+			} catch (error) {
+				appendDebugLog("acp:turn:start-error", {
+					target: redactAcpTargetForLogs(this.target),
+					requestId,
+					elapsedMs: Date.now() - startedAt,
+					error: serializeAcpErrorForLog(error, this.target)
+				});
+				throw redactAcpErrorForThrow(error, this.target);
+			}
+		})();
 		const iterationStartUsed = this.lastReportedUsed;
 		let latestUsed = iterationStartUsed;
 		let usageUpdateReceived = iterationStartUsed > 0;
@@ -13587,23 +13720,23 @@ var AcpAgent = class {
 				if (signal?.aborted || isAbortError$2(error)) {
 					await turn.cancel({ reason: "gnhf-aborted" }).catch(() => void 0);
 					appendDebugLog("acp:turn:aborted", {
-						target: this.target,
+						target: redactAcpTargetForLogs(this.target),
 						requestId,
 						elapsedMs: Date.now() - startedAt
 					});
 					throw createAbortError$2();
 				}
 				appendDebugLog("acp:turn:stream-error", {
-					target: this.target,
+					target: redactAcpTargetForLogs(this.target),
 					requestId,
 					elapsedMs: Date.now() - startedAt,
-					error: serializeError(error)
+					error: serializeAcpErrorForLog(error, this.target)
 				});
-				throw error;
+				throw redactAcpErrorForThrow(error, this.target);
 			}
 			const result = await turn.result;
 			appendDebugLog("acp:turn:result", {
-				target: this.target,
+				target: redactAcpTargetForLogs(this.target),
 				requestId,
 				status: result.status,
 				stopReason: result.status === "completed" || result.status === "cancelled" ? result.stopReason : void 0,
@@ -13614,7 +13747,7 @@ var AcpAgent = class {
 			});
 			if (result.status === "cancelled") throw createAbortError$2();
 			if (result.status === "failed") {
-				const message = result.error.message || "ACP turn failed";
+				const message = redactRawAcpTargetInString(result.error.message || "ACP turn failed", this.target);
 				if (result.error.retryable === false) throw new PermanentAgentError(message, result.error.code ?? "ACP_TURN_FAILED");
 				throw new Error(message);
 			}
@@ -13658,11 +13791,11 @@ var AcpAgent = class {
 				handle,
 				reason: "gnhf-shutdown"
 			});
-			appendDebugLog("acp:close", { target: this.target });
+			appendDebugLog("acp:close", { target: redactAcpTargetForLogs(this.target) });
 		} catch (error) {
 			appendDebugLog("acp:close-error", {
-				target: this.target,
-				error: serializeError(error)
+				target: redactAcpTargetForLogs(this.target),
+				error: serializeAcpErrorForLog(error, this.target)
 			});
 		}
 	}
@@ -13677,7 +13810,7 @@ var AcpAgent = class {
 		});
 		this.runtime = runtime;
 		appendDebugLog("acp:runtime:created", {
-			target: this.target,
+			target: redactAcpTargetForLogs(this.target),
 			sessionStateDir: this.sessionStateDir,
 			cwd
 		});
@@ -16343,7 +16476,7 @@ var Orchestrator = class extends EventEmitter {
 		this.state.status = "running";
 		this.emit("state", this.getState());
 		appendDebugLog("orchestrator:start", {
-			agent: this.agent.name,
+			agent: redactAgentSpecForLogs(this.agent.name),
 			runId: this.runInfo.runId,
 			startIteration: this.state.currentIteration,
 			maxIterations: this.limits.maxIterations,
@@ -16502,7 +16635,7 @@ var Orchestrator = class extends EventEmitter {
 		const agentStartedAt = Date.now();
 		appendDebugLog("agent:run:start", {
 			iteration: this.state.currentIteration,
-			agent: this.agent.name,
+			agent: redactAgentSpecForLogs(this.agent.name),
 			logPath
 		});
 		try {
@@ -16707,6 +16840,158 @@ var Orchestrator = class extends EventEmitter {
 	}
 };
 //#endregion
+//#region src/utils/tokens.ts
+function formatTokens(count) {
+	if (count >= 0xe8d4a51000) return `${(count / 0xe8d4a51000).toFixed(1)}T`;
+	if (count >= 1e9) return `${(count / 1e9).toFixed(1)}B`;
+	if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
+	if (count >= 1e3) return `${Math.round(count / 1e3)}K`;
+	return String(count);
+}
+//#endregion
+//#region src/core/exit-summary.ts
+const MIN_CARD_WIDTH = 62;
+const LABEL_WIDTH = 16;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const ANSI_TOKEN_RE = /\x1b\[[0-9;]*m/g;
+const NO_MISTAKES_URL = "https://github.com/kunchenguid/no-mistakes";
+function stripExitSummaryAnsi(text) {
+	return text.replace(ANSI_RE, "");
+}
+function makeStyles(color) {
+	const wrap = (open, text) => color ? `${open}${text}\x1b[0m` : text;
+	return {
+		dim: (text) => wrap("\x1B[2m", text),
+		bold: (text) => wrap("\x1B[1m", text),
+		cyan: (text) => wrap("\x1B[36m", text),
+		yellow: (text) => wrap("\x1B[33m", text),
+		green: (text) => wrap("\x1B[32m", text),
+		red: (text) => wrap("\x1B[31m", text),
+		magenta: (text) => wrap("\x1B[35m", text),
+		blueUnderline: (text) => wrap("\x1B[34;4m", text)
+	};
+}
+function visibleLength(text) {
+	return stripExitSummaryAnsi(text).length;
+}
+function padVisible(text, width) {
+	return text + " ".repeat(Math.max(0, width - visibleLength(text)));
+}
+function truncateVisible(text, width) {
+	if (visibleLength(text) <= width) return text;
+	if (width <= 0) return "";
+	const targetWidth = Math.max(0, width - 1);
+	let output = "";
+	let visible = 0;
+	let index = 0;
+	let hasActiveStyle = false;
+	const finish = () => `${output}…${hasActiveStyle ? "\x1B[0m" : ""}`;
+	for (const match of text.matchAll(ANSI_TOKEN_RE)) {
+		const chunk = text.slice(index, match.index);
+		for (const char of chunk) {
+			if (visible >= targetWidth) return finish();
+			output += char;
+			visible += 1;
+		}
+		output += match[0];
+		hasActiveStyle = match[0] !== "\x1B[0m";
+		index = match.index + match[0].length;
+	}
+	for (const char of text.slice(index)) {
+		if (visible >= targetWidth) return finish();
+		output += char;
+		visible += 1;
+	}
+	return finish();
+}
+function formatDuration(ms) {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor(totalSeconds % 3600 / 60);
+	const seconds = totalSeconds % 60;
+	if (hours > 0) return `${hours}h ${minutes}m`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+function formatNumber(value) {
+	return new Intl.NumberFormat("en-US").format(value);
+}
+function formatTokenCount$1(value, suffix, estimated) {
+	return `${estimated ? "~" : ""}${formatTokens(value)} ${suffix}`;
+}
+function plural(value, singular, pluralText = `${singular}s`) {
+	return `${formatNumber(value)} ${value === 1 ? singular : pluralText}`;
+}
+function metricLine(label, columns) {
+	return `  ${padVisible(`${padVisible(label, LABEL_WIDTH)}${columns[0] ?? ""}`, 30)}${padVisible(columns[1] ?? "", 13)}${columns[2] ?? ""}`;
+}
+function commandLine(label, command) {
+	return `  ${padVisible(label, LABEL_WIDTH)}${command}`;
+}
+function continuationLine(text) {
+	return `  ${"".padEnd(LABEL_WIDTH)}${text}`;
+}
+function resolveCardWidth(contents, terminalColumns) {
+	const contentWidth = Math.max(...contents.map(visibleLength));
+	const desiredWidth = Math.max(MIN_CARD_WIDTH, contentWidth + 4);
+	const columns = terminalColumns && terminalColumns > 0 ? terminalColumns : void 0;
+	return Math.max(4, columns ? Math.min(desiredWidth, columns) : desiredWidth);
+}
+function cardBorder(left, right, width, dim) {
+	return dim(`${left}${"─".repeat(Math.max(0, width - 2))}${right}`);
+}
+function cardLine(content, width, dim) {
+	const contentWidth = Math.max(0, width - 4);
+	return `${dim("│ ")}${padVisible(truncateVisible(content, contentWidth), contentWidth)}${dim(" │")}`;
+}
+function renderExitSummary(options) {
+	const s = makeStyles(options.color);
+	const elapsed = formatDuration(options.elapsedMs);
+	const stopped = options.status === "aborted";
+	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 inputTokens = formatTokenCount$1(options.totalInputTokens, "in", options.tokensEstimated);
+	const outputTokens = formatTokenCount$1(options.totalOutputTokens, "out", options.tokensEstimated);
+	const commits = plural(options.commitCount, "commit");
+	const linesAdded = `+${formatNumber(options.diffStats.linesAdded)}`;
+	const linesDeleted = `-${formatNumber(options.diffStats.linesDeleted)}`;
+	return `\n${[
+		cardBorder("╭", "╮", cardWidth, s.dim),
+		cardLine(title, cardWidth, s.dim),
+		cardLine(`  ${subtitle}`, cardWidth, s.dim),
+		cardBorder("╰", "╯", cardWidth, s.dim),
+		"",
+		metricLine(s.dim("iterations"), [
+			`${s.bold(String(options.iterations))} total`,
+			s.green(`${options.successCount} good`),
+			stopped ? s.red(rolledBack) : s.yellow(rolledBack)
+		]),
+		metricLine(s.dim("tokens"), [s.bold(inputTokens), s.bold(outputTokens)]),
+		metricLine(s.dim("branch diff"), [
+			s.bold(commits),
+			s.green(linesAdded),
+			s.red(linesDeleted)
+		]),
+		metricLine(s.dim("files"), [
+			`${options.diffStats.filesAdded} added`,
+			`${options.diffStats.filesUpdated} updated`,
+			`${options.diffStats.filesDeleted} deleted`
+		]),
+		"",
+		commandLine(s.dim("notes"), options.notesPath),
+		commandLine(s.dim("debug log"), options.logPath),
+		"",
+		commandLine(s.dim("next steps"), s.cyan(`git log --oneline ${options.baseRef}..HEAD`)),
+		continuationLine(s.cyan(`git diff --stat ${options.baseRef}..HEAD`)),
+		continuationLine(s.cyan("gh pr create")),
+		"",
+		commandLine(s.dim("too much"), `${s.cyan("git push no-mistakes")}:`),
+		commandLine(s.dim("to review?"), s.blueUnderline(NO_MISTAKES_URL))
+	].join("\n")}\n`;
+}
+//#endregion
 //#region src/mock-orchestrator.ts
 function mockIter(n, success, summary, agoMs) {
 	return {
@@ -16920,15 +17205,6 @@ function formatElapsed(ms) {
 	return `${String(Math.floor(s / 3600)).padStart(2, "0")}:${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
 }
 //#endregion
-//#region src/utils/tokens.ts
-function formatTokens(count) {
-	if (count >= 0xe8d4a51000) return `${(count / 0xe8d4a51000).toFixed(1)}T`;
-	if (count >= 1e9) return `${(count / 1e9).toFixed(1)}B`;
-	if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
-	if (count >= 1e3) return `${Math.round(count / 1e3)}K`;
-	return String(count);
-}
-//#endregion
 //#region src/utils/terminal-width.ts
 const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 const MARK_REGEX = /\p{Mark}/u;
@@ -17548,7 +17824,7 @@ const GNHF_REEXEC_STDIN_PROMPT_FILE = "GNHF_REEXEC_STDIN_PROMPT_FILE";
 const GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX = "gnhf-stdin-";
 const GNHF_REEXEC_STDIN_PROMPT_FILENAME = "prompt.txt";
 const AGENT_NAME_SET = new Set(AGENT_NAMES);
-const AGENT_SPEC_LIST = `${`"${AGENT_NAMES.slice(0, -1).join("\", \"")}", or "${AGENT_NAMES[AGENT_NAMES.length - 1]}"`}, or "acp:<target>" (e.g. acp:gemini)`;
+const AGENT_SPEC_LIST = `${`"${AGENT_NAMES.slice(0, -1).join("\", \"")}", or "${AGENT_NAMES[AGENT_NAMES.length - 1]}"`}, or "acp:<target-or-command>" (e.g. acp:gemini)`;
 var PromptSignalError = class extends Error {
 	constructor(signal) {
 		super(signal);
@@ -17576,6 +17852,42 @@ function isAgentName(name) {
 function getNativeAgentName(spec) {
 	return isAgentName(spec) ? spec : void 0;
 }
+function getTelemetryAgent(spec) {
+	return redactAgentSpecForLogs(spec);
+}
+function shouldUseColor() {
+	return process$1.stdout.isTTY === true && process$1.env.NO_COLOR === void 0 && process$1.env.TERM !== "dumb";
+}
+function emptyBranchDiffStats(commitCount) {
+	return {
+		commits: commitCount,
+		filesChanged: 0,
+		filesAdded: 0,
+		filesUpdated: 0,
+		filesDeleted: 0,
+		filesRenamed: 0,
+		binaryFiles: 0,
+		linesAdded: 0,
+		linesDeleted: 0
+	};
+}
+function redactDebugArgs(args) {
+	const redacted = [...args];
+	for (let i = 0; i < redacted.length; i += 1) {
+		const arg = redacted[i];
+		if (arg === "--") break;
+		if (arg === "--agent") {
+			const next = redacted[i + 1];
+			if (next !== void 0) {
+				redacted[i + 1] = redactAgentSpecForLogs(next);
+				i += 1;
+			}
+			continue;
+		}
+		if (arg?.startsWith("--agent=")) redacted[i] = `--agent=${redactAgentSpecForLogs(arg.slice(8))}`;
+	}
+	return redacted;
+}
 function buildSchemaOptions(stopWhen, commitMessage) {
 	const commitFields = getCommitMessageSchemaFields(commitMessage);
 	return {
@@ -17797,7 +18109,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>)`).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; 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) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
@@ -17939,16 +18251,17 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		}
 	}
 	const runMode = options.worktree ? "worktree" : startIteration > 0 ? "resume" : "new";
+	const telemetryAgent = getTelemetryAgent(config.agent);
 	telemetry.pageview("/run", {
-		agent: config.agent,
+		agent: telemetryAgent,
 		mode: runMode
 	});
 	initDebugLog(runInfo.logPath);
 	appendDebugLog("run:start", {
-		args: process$1.argv.slice(2),
+		args: redactDebugArgs(process$1.argv.slice(2)),
 		runId: runInfo.runId,
 		runDir: runInfo.runDir,
-		agent: config.agent,
+		agent: redactAgentSpecForLogs(config.agent),
 		promptLength: prompt.length,
 		promptFromStdin,
 		startIteration,
@@ -18037,6 +18350,38 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 	}
 	{
 		const finalState = orchestrator.getState();
+		let finalBranchName = "HEAD";
+		try {
+			finalBranchName = getCurrentBranch(effectiveCwd);
+		} catch (error) {
+			appendDebugLog("summary:branch-error", { error: serializeError(error) });
+		}
+		let diffStats = emptyBranchDiffStats(finalState.commitCount);
+		try {
+			diffStats = getBranchDiffStats(runInfo.baseCommit, effectiveCwd);
+		} catch (error) {
+			appendDebugLog("summary:diff-stats-error", { error: serializeError(error) });
+		}
+		const exitSummary = renderExitSummary({
+			agentName: redactAgentSpecForLogs(config.agent),
+			branchName: finalBranchName,
+			elapsedMs: Date.now() - finalState.startTime.getTime(),
+			status: finalState.status,
+			abortReason: finalState.lastAgentError ?? finalState.lastMessage,
+			iterations: finalState.currentIteration,
+			successCount: finalState.successCount,
+			failCount: finalState.failCount,
+			totalInputTokens: finalState.totalInputTokens,
+			totalOutputTokens: finalState.totalOutputTokens,
+			tokensEstimated: finalState.tokensEstimated,
+			commitCount: finalState.commitCount,
+			notesPath: runInfo.notesPath,
+			logPath: runInfo.logPath,
+			baseRef: runInfo.baseCommit.slice(0, 12) || runInfo.baseCommit,
+			diffStats,
+			color: shouldUseColor(),
+			terminalColumns: process$1.stdout.columns
+		});
 		appendDebugLog("run:complete", {
 			signal: shutdownSignal,
 			status: finalState.status,
@@ -18049,7 +18394,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			worktreePath
 		});
 		telemetry.track("run", {
-			agent: config.agent,
+			agent: telemetryAgent,
 			mode: runMode,
 			status: finalState.status,
 			signal: shutdownSignal ?? void 0,
@@ -18074,6 +18419,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			worktreeCleanup = null;
 			appendDebugLog("worktree:cleaned-up", { worktreePath });
 		}
+		process$1.stdout.write(exitSummary);
 	}
 	if (shutdownSignal) process$1.exit(getSignalExitCode(shutdownSignal));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnhf",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Before I go to bed, I tell my agents: good night, have fun",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^4.1.2",
+    "acp-mock": "^1.1.0",
     "acpx": "^0.6.1",
     "eslint": "^9.0.0",
     "eslint-config-prettier": "^10.0.0",