gnhf 0.1.31 → 0.1.33

package/README.md

@@ -175,22 +175,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 +225,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 +245,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 +253,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 +274,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 +287,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"
@@ -660,7 +686,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 +13487,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 +13553,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 +13664,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 +13691,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 +13735,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 +13754,7 @@ var AcpAgent = class {
 		});
 		this.runtime = runtime;
 		appendDebugLog("acp:runtime:created", {
-			target: this.target,
+			target: redactAcpTargetForLogs(this.target),
 			sessionStateDir: this.sessionStateDir,
 			cwd
 		});
@@ -16039,7 +16116,7 @@ function getBuildTimeUmamiHost() {
 	return "https://a.kunchenguid.com";
 }
 function getBuildTimeUmamiWebsiteID() {
-	return "";
+	return "7f4707fa-4e80-4977-8320-4ade27692d85";
 }
 function normalizeEndpoint(host) {
 	let url;
@@ -16343,7 +16420,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 +16579,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 {
@@ -17548,7 +17625,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 +17653,26 @@ function isAgentName(name) {
 function getNativeAgentName(spec) {
 	return isAgentName(spec) ? spec : void 0;
 }
+function getTelemetryAgent(spec) {
+	return redactAgentSpecForLogs(spec);
+}
+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 +17894,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 +18036,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,
@@ -18049,7 +18147,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnhf",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "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",