gnhf 0.1.29 → 0.1.30

package/README.md

@@ -144,7 +144,7 @@ npm link
 - **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
 - **Shared memory** — the agent reads `notes.md` (built up from prior iterations) to communicate across iterations
 - **Local run metadata** — gnhf stores prompt, notes, and resume 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
+- **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`.
 
 ### Worktree Mode
 
@@ -158,6 +158,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.
 - `--worktree` must be run from a non-gnhf branch (typically `main`).
 

package/dist/cli.mjs

@@ -445,7 +445,7 @@ function removeWorktree(baseCwd, worktreePath) {
 		worktreePath
 	], baseCwd);
 }
-function worktreeExists(baseCwd, worktreePath) {
+function listWorktreePaths(baseCwd) {
 	let output;
 	try {
 		output = git([
@@ -454,11 +454,11 @@ function worktreeExists(baseCwd, worktreePath) {
 			"--porcelain"
 		], baseCwd);
 	} catch {
-		return false;
+		return /* @__PURE__ */ new Set();
 	}
-	const target = resolve(worktreePath);
-	for (const line of output.split("\n")) if (line.startsWith("worktree ") && resolve(line.slice(9)) === target) return true;
-	return false;
+	const paths = /* @__PURE__ */ new Set();
+	for (const line of output.split("\n")) if (line.startsWith("worktree ")) paths.add(resolve(line.slice(9)));
+	return paths;
 }
 //#endregion
 //#region src/core/agents/types.ts
@@ -4754,37 +4754,79 @@ function buildResumeSchemaOptions(stopWhen) {
 function initializeNewBranch(prompt, cwd, schemaOptions) {
 	ensureCleanWorkingTree(cwd);
 	const baseCommit = getHeadCommit(cwd);
-	const branchName = slugifyPrompt(prompt);
-	createBranch(branchName, cwd);
-	const runId = branchName.split("/")[1];
+	const runId = createBranchWithSuffix(slugifyPrompt(prompt), cwd).split("/")[1];
 	return setupRun(runId, prompt, baseCommit, cwd, schemaOptions);
 }
+function branchNameWithSuffix(branchName, suffix) {
+	return suffix === 0 ? branchName : `${branchName}-${suffix}`;
+}
+function isCollisionError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return /already exists|exists already|would be overwritten/i.test(message);
+}
+function createBranchWithSuffix(branchName, cwd) {
+	for (let suffix = 0; suffix < 100; suffix += 1) {
+		const candidate = branchNameWithSuffix(branchName, suffix);
+		try {
+			createBranch(candidate, cwd);
+			return candidate;
+		} catch (error) {
+			if (!isCollisionError(error)) throw error;
+		}
+	}
+	throw new Error(`Unable to create a unique branch name for ${branchName}`);
+}
 function initializeWorktreeRun(prompt, cwd, schemaOptions) {
 	const repoRoot = getRepoRootDir(cwd);
 	const baseCommit = getHeadCommit(cwd);
 	const branchName = slugifyPrompt(prompt);
+	const makeWorktreePath = (runId) => join(dirname(repoRoot), `${basename(repoRoot)}-gnhf-worktrees`, runId);
 	const runId = branchName.split("/")[1];
-	const worktreePath = join(dirname(repoRoot), `${basename(repoRoot)}-gnhf-worktrees`, runId);
-	if (worktreeExists(repoRoot, worktreePath) && existsSync(join(worktreePath, ".gnhf", "runs", runId))) {
+	const worktreePath = makeWorktreePath(runId);
+	const registeredWorktreePaths = listWorktreePaths(repoRoot);
+	const resumePreservedWorktree = (candidateBranchName, candidateRunId, candidateWorktreePath) => {
+		if (!registeredWorktreePaths.has(resolve(candidateWorktreePath)) || !existsSync(join(candidateWorktreePath, ".gnhf", "runs", candidateRunId))) return null;
 		let worktreeBranch;
 		try {
-			worktreeBranch = getCurrentBranch(worktreePath);
+			worktreeBranch = getCurrentBranch(candidateWorktreePath);
 		} catch (error) {
-			throw new Error(`Preserved worktree at ${worktreePath} is in an unexpected state (${error instanceof Error ? error.message : String(error)}). Fix the worktree manually or remove it with "git worktree remove ${worktreePath}" before re-running.`);
+			throw new Error(`Preserved worktree at ${candidateWorktreePath} is in an unexpected state (${error instanceof Error ? error.message : String(error)}). Fix the worktree manually or remove it with "git worktree remove ${candidateWorktreePath}" before re-running.`);
 		}
-		if (worktreeBranch !== branchName) throw new Error(`Preserved worktree at ${worktreePath} is on branch "${worktreeBranch}" rather than "${branchName}". Restore it to "${branchName}" with "git -C ${worktreePath} checkout ${branchName}", or remove the worktree with "git worktree remove ${worktreePath}" to start fresh.`);
+		if (worktreeBranch !== candidateBranchName) throw new Error(`Preserved worktree at ${candidateWorktreePath} is on branch "${worktreeBranch}" rather than "${candidateBranchName}". Restore it to "${candidateBranchName}" with "git -C ${candidateWorktreePath} checkout ${candidateBranchName}", or remove the worktree with "git worktree remove ${candidateWorktreePath}" to start fresh.`);
 		return {
-			runInfo: resumeRun(runId, worktreePath, schemaOptions),
-			worktreePath,
-			effectiveCwd: worktreePath,
+			runInfo: resumeRun(candidateRunId, candidateWorktreePath, schemaOptions),
+			worktreePath: candidateWorktreePath,
+			effectiveCwd: candidateWorktreePath,
 			resumed: true
 		};
+	};
+	let createdBranchName = branchName;
+	let createdRunId = runId;
+	let createdWorktreePath = worktreePath;
+	for (let suffix = 0; suffix < 100; suffix += 1) {
+		const candidateBranchName = branchNameWithSuffix(branchName, suffix);
+		const candidateRunId = candidateBranchName.split("/")[1];
+		const resumed = resumePreservedWorktree(candidateBranchName, candidateRunId, makeWorktreePath(candidateRunId));
+		if (resumed) return resumed;
+	}
+	for (let suffix = 0; suffix < 100; suffix += 1) {
+		createdBranchName = branchNameWithSuffix(branchName, suffix);
+		createdRunId = createdBranchName.split("/")[1];
+		createdWorktreePath = makeWorktreePath(createdRunId);
+		const resumed = resumePreservedWorktree(createdBranchName, createdRunId, createdWorktreePath);
+		if (resumed) return resumed;
+		try {
+			createWorktree(repoRoot, createdWorktreePath, createdBranchName);
+			break;
+		} catch (error) {
+			if (!isCollisionError(error)) throw error;
+			if (suffix === 99) throw new Error(`Unable to create a unique worktree for ${branchName}`);
+		}
 	}
-	createWorktree(repoRoot, worktreePath, branchName);
 	return {
-		runInfo: setupRun(runId, prompt, baseCommit, worktreePath, schemaOptions),
-		worktreePath,
-		effectiveCwd: worktreePath,
+		runInfo: setupRun(createdRunId, prompt, baseCommit, createdWorktreePath, schemaOptions),
+		worktreePath: createdWorktreePath,
+		effectiveCwd: createdWorktreePath,
 		resumed: false
 	};
 }

package/package.json

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