get-tbd 0.1.22 → 0.1.24

package/README.md

@@ -138,20 +138,20 @@ status or context or knowledge and know what to do next:
 
 | What you say | What happens | What runs |
 | --- | --- | --- |
-| "Let's plan a new feature that …" | Agent creates a spec from a template | [`tbd shortcut new-plan-spec`](packages/tbd/docs/shortcuts/standard/new-plan-spec.md) |
-| "Break this spec into beads" | Agent creates implementation beads from the spec | [`tbd shortcut plan-implementation-with-beads`](packages/tbd/docs/shortcuts/standard/plan-implementation-with-beads.md) |
-| "Implement these beads" | Agent works through beads systematically | [`tbd shortcut implement-beads`](packages/tbd/docs/shortcuts/standard/implement-beads.md) |
-| "Create a bead for the bug where …" | Agent creates and tracks a bead | `tbd create "..." --type=bug` |
-| "Let's work on current beads" | Agent finds ready beads and starts working | `tbd ready` |
-| "Review this code" | Agent performs comprehensive code review with all guidelines | [`tbd shortcut review-code`](packages/tbd/docs/shortcuts/standard/review-code.md) |
-| "Review this PR" | Agent reviews a GitHub pull request and can comment/fix | [`tbd shortcut review-github-pr`](packages/tbd/docs/shortcuts/standard/review-github-pr.md) |
-| "Use the shortcut to commit" | Agent runs full pre-commit checks, code review, and commits | [`tbd shortcut code-review-and-commit`](packages/tbd/docs/shortcuts/standard/code-review-and-commit.md) |
-| "Create a PR" | Agent creates or updates the pull request | [`tbd shortcut create-or-update-pr-simple`](packages/tbd/docs/shortcuts/standard/create-or-update-pr-simple.md) |
-| "Let's create a research brief on …" | Agent creates a research document using a template | [`tbd shortcut new-research-brief`](packages/tbd/docs/shortcuts/standard/new-research-brief.md) |
-| "How could we test this better?" | Agent loads TDD and testing guidelines | [`tbd guidelines general-tdd-guidelines`](packages/tbd/docs/guidelines/general-tdd-guidelines.md) |
-| "How can we make this a well-designed TypeScript CLI?" | Agent loads TypeScript CLI guidelines | [`tbd guidelines typescript-cli-tool-rules`](packages/tbd/docs/guidelines/typescript-cli-tool-rules.md) |
-| "Can you review if this TypeScript package setup follows best practices" | Agent loads monorepo patterns | [`tbd guidelines pnpm-monorepo-patterns`](packages/tbd/docs/guidelines/pnpm-monorepo-patterns.md) |
-| "How can we do a better job of testing?" | Agent loads golden testing guidelines | [`tbd guidelines golden-testing-guidelines`](packages/tbd/docs/guidelines/golden-testing-guidelines.md) |
+| “Let’s plan a new feature that …” | Agent creates a spec from a template | [`tbd shortcut new-plan-spec`](packages/tbd/docs/shortcuts/standard/new-plan-spec.md) |
+| “Break this spec into beads” | Agent creates implementation beads from the spec | [`tbd shortcut plan-implementation-with-beads`](packages/tbd/docs/shortcuts/standard/plan-implementation-with-beads.md) |
+| “Implement these beads” | Agent works through beads systematically | [`tbd shortcut implement-beads`](packages/tbd/docs/shortcuts/standard/implement-beads.md) |
+| “Create a bead for the bug where …” | Agent creates and tracks a bead | `tbd create "..." --type=bug` |
+| “Let’s work on current beads” | Agent finds ready beads and starts working | `tbd ready` |
+| “Review this code” | Agent performs comprehensive code review with all guidelines | [`tbd shortcut review-code`](packages/tbd/docs/shortcuts/standard/review-code.md) |
+| “Review this PR” | Agent reviews a GitHub pull request and can comment/fix | [`tbd shortcut review-github-pr`](packages/tbd/docs/shortcuts/standard/review-github-pr.md) |
+| “Use the shortcut to commit” | Agent runs full pre-commit checks, code review, and commits | [`tbd shortcut code-review-and-commit`](packages/tbd/docs/shortcuts/standard/code-review-and-commit.md) |
+| “Create a PR” | Agent creates or updates the pull request | [`tbd shortcut create-or-update-pr-simple`](packages/tbd/docs/shortcuts/standard/create-or-update-pr-simple.md) |
+| “Let’s create a research brief on …” | Agent creates a research document using a template | [`tbd shortcut new-research-brief`](packages/tbd/docs/shortcuts/standard/new-research-brief.md) |
+| “How could we test this better?” | Agent loads TDD and testing guidelines | [`tbd guidelines general-tdd-guidelines`](packages/tbd/docs/guidelines/general-tdd-guidelines.md) |
+| “How can we make this a well-designed TypeScript CLI?” | Agent loads TypeScript CLI guidelines | [`tbd guidelines typescript-cli-tool-rules`](packages/tbd/docs/guidelines/typescript-cli-tool-rules.md) |
+| “Can you review if this TypeScript package setup follows best practices” | Agent loads monorepo patterns | [`tbd guidelines pnpm-monorepo-patterns`](packages/tbd/docs/guidelines/pnpm-monorepo-patterns.md) |
+| “How can we do a better job of testing?” | Agent loads golden testing guidelines | [`tbd guidelines golden-testing-guidelines`](packages/tbd/docs/guidelines/golden-testing-guidelines.md) |
 
 Under the hood, your agent runs these `tbd` commands automatically.
 You just talk naturally.
@@ -165,8 +165,8 @@ You just talk naturally.
 
 - **Git-native:** Beads live in your repo, synced to a separate, dedicated `tbd-sync`
   branch. Your code history stays clean—no bead churn polluting your logs.
-- **Agent friendly:** JSON output, non-interactive mode, simple commands that agents
-  understand. Installs itself as a skill in Claude Code.
+- **Agent friendly:** JSON output, simple commands that agents understand.
+  Installs itself as a skill in Claude Code.
 - **Markdown + YAML frontmatter:** One file per bead, human-readable and editable.
   This eliminates most merge conflicts.
 - **Beads alternative:** Largely compatible with `bd` at the CLI level, but with a
@@ -472,8 +472,6 @@ Every command supports these flags for automation:
 | Flag | Purpose |
 | --- | --- |
 | `--json` | Machine-parseable output |
-| `--non-interactive` | Fail if input required |
-| `--yes` | Auto-confirm prompts |
 | `--dry-run` | Preview changes |
 | `--quiet` | Minimal output |
 
@@ -533,7 +531,7 @@ It does *not* aim to solve real-time multi-agent coordination, which is a separa
 problem requiring sub-second messaging and atomic claims.
 Tools like [Agent Mail](https://github.com/Dicklesworthstone/mcp_agent_mail) and
 [Gas Town](https://github.com/steveyegge/gastown) address that space and are
-complementary to `tbd`—you could layer real-time coordination on top of `tbd`'s durable
+complementary to `tbd`—you could layer real-time coordination on top of `tbd`’s durable
 tracking. See the [design doc](packages/tbd/docs/tbd-design.md) for a detailed
 comparison.
 

package/dist/bin.mjs

@@ -8,7 +8,7 @@ import process$1 from "node:process";
 import matter from "gray-matter";
 import os, { homedir } from "node:os";
 import tty from "node:tty";
-import { access, chmod, cp, mkdir, readFile, readdir, rename, rm, stat, unlink } from "node:fs/promises";
+import { access, chmod, cp, mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { promisify } from "node:util";
 import crypto, { randomBytes } from "node:crypto";
@@ -14033,7 +14033,7 @@ function serializeIssue(issue) {
 * Package version, derived from git at build time.
 * Format: X.Y.Z for releases, X.Y.Z-dev.N.hash for dev builds.
 */
-const VERSION$1 = "0.1.22";
+const VERSION$1 = "0.1.24";
 
 //#endregion
 //#region src/cli/lib/version.ts
@@ -96563,15 +96563,12 @@ function sanitizeTab(tab, fallbackTab) {
 */
 function getCommandContext(command) {
 	const opts = command.optsWithGlobals();
-	const isCI = Boolean(process.env.CI);
 	return {
 		dryRun: opts.dryRun ?? false,
 		verbose: opts.verbose ?? false,
 		quiet: opts.quiet ?? false,
 		json: opts.json ?? false,
 		color: opts.color ?? "auto",
-		nonInteractive: opts.nonInteractive ?? (!process.stdin.isTTY || isCI),
-		yes: opts.yes ?? false,
 		sync: opts.sync !== false,
 		debug: opts.debug ?? false
 	};
@@ -99276,7 +99273,11 @@ async function migrateDataToWorktree(baseDir, removeSource = false) {
 		await mkdir(correctIssuesPath, { recursive: true });
 		await mkdir(correctMappingsPath, { recursive: true });
 		for (const file of issueFiles) await cp(join(wrongIssuesPath, file), join(correctIssuesPath, file));
-		for (const file of mappingFiles) await cp(join(wrongMappingsPath, file), join(correctMappingsPath, file));
+		for (const file of mappingFiles) if (file === "ids.yml") {
+			const { loadIdMapping, mergeIdMappings, saveIdMapping } = await Promise.resolve().then(() => id_mapping_exports);
+			const sourceMapping = await loadIdMapping(wrongPath);
+			await saveIdMapping(correctPath, mergeIdMappings(await loadIdMapping(correctPath), sourceMapping));
+		} else await cp(join(wrongMappingsPath, file), join(correctMappingsPath, file));
 		const totalFiles = issueFiles.length + mappingFiles.length;
 		await git("-C", worktreePath, "add", "-A");
 		if (await git("-C", worktreePath, "diff", "--cached", "--quiet").then(() => false).catch(() => true)) await git("-C", worktreePath, "commit", "--no-verify", "-m", `tbd: migrate ${totalFiles} file(s) from incorrect location`);
@@ -99777,6 +99778,110 @@ async function listIssues(baseDir) {
 	return issues;
 }
 
+//#endregion
+//#region src/utils/lockfile.ts
+/**
+* Directory-based mutual exclusion for concurrent file access.
+*
+* Note: Despite the name "lockfile", this is NOT a POSIX file lock (flock/fcntl).
+* It uses mkdir to create a lock *directory* as a coordination convention — no
+* OS-level file locking syscalls are involved. This makes it portable across all
+* filesystems, including NFS and other network mounts where flock/fcntl locks
+* are unreliable or unsupported.
+*
+* This is the same strategy used by:
+*
+* - **Git** for ref updates (e.g., `.git/refs/heads/main.lock`)
+*   See: https://git-scm.com/docs/gitrepository-layout ("lockfile protocol")
+* - **npm** for package-lock.json concurrent access
+*
+* ## Why mkdir?
+*
+* `mkdir(2)` is atomic on all common filesystems (local and network): it either
+* creates the directory or returns EEXIST. Unlike `open(O_CREAT|O_EXCL)`,
+* a directory lock is trivially distinguishable from normal files.
+*
+* Node.js `fs.mkdir` maps directly to the mkdir(2) syscall, preserving
+* the atomicity guarantee:
+*   https://nodejs.org/api/fs.html#fsmkdirpath-options-callback
+*
+* ## Lock lifecycle
+*
+* 1. **Acquire**: `mkdir(lockDir)` — fails with EEXIST if held by another process
+* 2. **Hold**: Execute the critical section
+* 3. **Release**: `rmdir(lockDir)` — in a finally block
+* 4. **Stale detection**: If lock mtime exceeds a threshold, assume the holder
+*    crashed and break the lock. This is a heuristic — safe when the critical
+*    section is short-lived (sub-second for file I/O).
+*
+* ## Degraded mode
+*
+* If the lock cannot be acquired within the timeout (e.g., due to a stuck
+* lockfile that isn't old enough to break), the critical section runs anyway.
+* Callers should design their critical sections to be safe without the lock
+* (e.g., using read-merge-write for append-only data).
+*/
+const DEFAULT_TIMEOUT_MS = 2e3;
+const DEFAULT_POLL_MS = 50;
+const DEFAULT_STALE_MS = 5e3;
+/**
+* Execute `fn` while holding a lockfile.
+*
+* The lock is a directory at `lockPath` (typically `<target-file>.lock`).
+* Concurrent callers will wait up to `timeoutMs` for the lock, polling
+* every `pollMs`. Stale locks older than `staleMs` are broken automatically.
+*
+* If the lock cannot be acquired, `fn` is still executed (degraded mode).
+* This ensures a stuck lockfile never permanently blocks the CLI.
+*
+* @param lockPath - Path to use as the lock directory (e.g., "/path/to/ids.yml.lock")
+* @param fn - Critical section to execute under the lock
+* @param options - Timing parameters for lock acquisition
+* @returns The return value of `fn`
+*
+* @example
+* ```ts
+* await withLockfile('/path/to/ids.yml.lock', async () => {
+*   const data = await readFile('/path/to/ids.yml', 'utf-8');
+*   const updated = mergeEntries(data, newEntries);
+*   await writeFile('/path/to/ids.yml', updated);
+* });
+* ```
+*/
+async function withLockfile(lockPath, fn, options) {
+	const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const pollMs = options?.pollMs ?? DEFAULT_POLL_MS;
+	const staleMs = options?.staleMs ?? DEFAULT_STALE_MS;
+	const deadline = Date.now() + timeoutMs;
+	let acquired = false;
+	while (Date.now() < deadline) try {
+		await mkdir(lockPath);
+		acquired = true;
+		break;
+	} catch (error) {
+		if (error.code !== "EEXIST") break;
+		try {
+			const lockStat = await stat(lockPath);
+			if (Date.now() - lockStat.mtimeMs > staleMs) {
+				try {
+					await rmdir(lockPath);
+				} catch {}
+				continue;
+			}
+		} catch {
+			continue;
+		}
+		await new Promise((resolve) => setTimeout(resolve, pollMs));
+	}
+	try {
+		return await fn();
+	} finally {
+		if (acquired) try {
+			await rmdir(lockPath);
+		} catch {}
+	}
+}
+
 //#endregion
 //#region src/lib/sort.ts
 /**
@@ -99921,15 +100026,54 @@ async function loadIdMapping(baseDir) {
 	};
 }
 /**
-* Save the ID mapping to disk.
+* Save the ID mapping to disk with mutual exclusion.
+*
+* Uses a lockfile to serialize concurrent writers, then performs read-merge-write
+* inside the lock. This prevents the lost-update problem when multiple `tbd create`
+* commands run in parallel.
+*
+* The merge is safe because ID mappings are append-only — entries are never
+* intentionally removed. Even if the lock acquisition fails (degraded mode),
+* the read-merge-write provides a fallback that preserves entries from other writers.
 */
 async function saveIdMapping(baseDir, mapping) {
 	const filePath = getMappingPath(baseDir);
 	await mkdir(dirname(filePath), { recursive: true });
-	const data = {};
-	const sortedKeys = naturalSort(Array.from(mapping.shortToUlid.keys()));
-	for (const key of sortedKeys) data[key] = mapping.shortToUlid.get(key);
-	await writeFile(filePath, stringifyYaml(data));
+	await withLockfile(filePath + ".lock", async () => {
+		let merged = mapping;
+		let onDiskSize = 0;
+		try {
+			const onDisk = await loadIdMappingRaw(filePath);
+			onDiskSize = onDisk.shortToUlid.size;
+			if (onDiskSize > 0) merged = mergeIdMappings(mapping, onDisk);
+		} catch {}
+		if (merged.shortToUlid.size < onDiskSize) throw new Error(`Refusing to save ID mapping: would lose ${onDiskSize - merged.shortToUlid.size} entries (on-disk: ${onDiskSize}, proposed: ${merged.shortToUlid.size}). ID mappings are append-only — this indicates a bug.`);
+		const data = {};
+		const sortedKeys = naturalSort(Array.from(merged.shortToUlid.keys()));
+		for (const key of sortedKeys) data[key] = merged.shortToUlid.get(key);
+		await writeFile(filePath, stringifyYaml(data));
+	});
+}
+/**
+* Load an ID mapping directly from a file path (internal helper for save merging).
+* Separated from loadIdMapping to avoid coupling the save path to baseDir resolution.
+*/
+async function loadIdMappingRaw(filePath) {
+	const { data: rawData } = parseYamlToleratingDuplicateKeys(await readFile(filePath, "utf-8"), filePath);
+	const data = rawData ?? {};
+	const parseResult = IdMappingYamlSchema.safeParse(data);
+	if (!parseResult.success) throw new Error(`Invalid ID mapping format in ${filePath}: ${parseResult.error.message}`);
+	const validData = parseResult.data;
+	const shortToUlid = /* @__PURE__ */ new Map();
+	const ulidToShort = /* @__PURE__ */ new Map();
+	for (const [shortId, ulid] of Object.entries(validData)) {
+		shortToUlid.set(shortId, ulid);
+		ulidToShort.set(ulid, shortId);
+	}
+	return {
+		shortToUlid,
+		ulidToShort
+	};
 }
 /**
 * Calculate the optimal short ID length based on existing ID count.
@@ -103001,8 +103145,8 @@ var SyncHandler = class extends BaseCommand {
 		else if (options.push) await this.pushChanges(syncBranch, remote);
 		else await this.fullSync(syncBranch, remote, {
 			force: options.force,
-			noAutoSave: options.noAutoSave,
-			noOutbox: options.noOutbox
+			autoSave: options.autoSave,
+			outbox: options.outbox
 		});
 	}
 	/**
@@ -103421,7 +103565,7 @@ var SyncHandler = class extends BaseCommand {
 				this.output.error(`Push failed: ${displayError}`);
 				console.log(`  ${aheadCommits} commit(s) not pushed to remote.`);
 			});
-			if (errorType === "permanent" && !options.noAutoSave) await this.handlePermanentFailure();
+			if (errorType === "permanent" && options.autoSave !== false) await this.handlePermanentFailure();
 			else if (!this.ctx.json) if (errorType === "transient") {
 				console.log("");
 				console.log("  This appears to be a temporary issue. Options:");
@@ -103436,7 +103580,7 @@ var SyncHandler = class extends BaseCommand {
 			}
 			return;
 		}
-		if (!options.noOutbox) await this.maybeImportOutbox(syncBranch, remote);
+		if (options.outbox !== false) await this.maybeImportOutbox(syncBranch, remote);
 		this.output.data({
 			summary,
 			conflicts: conflicts.length
@@ -104459,7 +104603,9 @@ var DoctorHandler = class extends BaseCommand {
 		healthChecks.push(await this.checkIdMappingDuplicates(options.fix));
 		healthChecks.push(await this.checkTempFiles(options.fix));
 		healthChecks.push(this.checkIssueValidity(this.issues));
-		healthChecks.push(await this.checkMissingMappings(options.fix));
+		const parsedMaxHistory = options.maxHistory ? parseInt(options.maxHistory, 10) : 50;
+		const maxHistory = Number.isNaN(parsedMaxHistory) || parsedMaxHistory < 0 ? 50 : parsedMaxHistory;
+		healthChecks.push(await this.checkMissingMappings(options.fix, maxHistory));
 		healthChecks.push(await this.checkWorktree(options.fix));
 		healthChecks.push(await this.checkDataLocation(options.fix));
 		healthChecks.push(await this.checkLocalSyncBranch());
@@ -104813,7 +104959,7 @@ var DoctorHandler = class extends BaseCommand {
 	*
 	* With --fix, creates missing mappings automatically.
 	*/
-	async checkMissingMappings(fix) {
+	async checkMissingMappings(fix, maxHistory = 50) {
 		if (this.issues.length === 0) return {
 			name: "ID mapping coverage",
 			status: "ok"
@@ -104830,25 +104976,41 @@ var DoctorHandler = class extends BaseCommand {
 			status: "ok"
 		};
 		if (fix && !this.checkDryRun("Create missing ID mappings")) {
-			const { parseIdMappingFromYaml } = await Promise.resolve().then(() => id_mapping_exports);
+			const { parseIdMappingFromYaml, mergeIdMappings } = await Promise.resolve().then(() => id_mapping_exports);
 			let historicalMapping;
 			try {
 				const syncBranch = (await Promise.resolve().then(() => config_exports).then((m) => m.readConfig(this.cwd))).sync.branch;
-				const priorContent = await git("log", "-1", "--format=%H", syncBranch, "--", `${DATA_SYNC_DIR}/mappings/ids.yml`);
-				if (priorContent.trim()) {
-					const idsContent = await git("show", `${priorContent.trim()}:${DATA_SYNC_DIR}/mappings/ids.yml`);
-					if (idsContent) historicalMapping = parseIdMappingFromYaml(idsContent);
-				}
+				const logArgs = ["log", "--format=%H"];
+				if (maxHistory > 0) logArgs.push(`-${maxHistory}`);
+				logArgs.push(syncBranch, "--", `${DATA_SYNC_DIR}/mappings/ids.yml`);
+				const commitHashes = (await git(...logArgs)).trim().split("\n").filter(Boolean);
+				for (const commitHash of commitHashes) try {
+					const idsContent = await git("show", `${commitHash}:${DATA_SYNC_DIR}/mappings/ids.yml`);
+					if (idsContent) {
+						const versionMapping = parseIdMappingFromYaml(idsContent);
+						if (!historicalMapping) historicalMapping = versionMapping;
+						else historicalMapping = mergeIdMappings(historicalMapping, versionMapping);
+					}
+				} catch {}
 			} catch {}
+			const historicalCount = historicalMapping?.shortToUlid.size ?? 0;
 			const result = reconcileMappings(missingIds, mapping, historicalMapping);
 			await saveIdMapping(this.dataSyncDir, mapping);
 			const parts = [];
 			if (result.recovered.length > 0) parts.push(`recovered ${result.recovered.length} from git history`);
 			if (result.created.length > 0) parts.push(`created ${result.created.length} new`);
+			const details = [
+				`Scanned ${maxHistory > 0 ? `up to ${maxHistory}` : "all"} git commits for ids.yml history`,
+				`Found ${historicalCount} historical mapping(s) to use for recovery`,
+				`${missingIds.length} issue(s) were missing short ID mappings`
+			];
+			if (result.recovered.length > 0) details.push(`Recovered ${result.recovered.length} original short ID(s) from git history`);
+			if (result.created.length > 0) details.push(`Generated ${result.created.length} new short ID(s) (originals not found in history)`);
 			return {
 				name: "ID mapping coverage",
 				status: "ok",
-				message: parts.join(", ")
+				message: parts.join(", "),
+				details
 			};
 		}
 		return {
@@ -105007,13 +105169,19 @@ var DoctorHandler = class extends BaseCommand {
 				path: wrongIssuesPath,
 				details: ["Cannot migrate: worktree must be repaired first.", "The worktree repair should have run before this check."]
 			};
-			const result = await migrateDataToWorktree(this.cwd);
-			if (result.success) return {
-				name: "Data location",
-				status: "ok",
-				message: result.backupPath ? `migrated ${result.migratedCount} file(s), backed up to ${result.backupPath}` : `migrated ${result.migratedCount} file(s)`,
-				path: wrongIssuesPath
-			};
+			const result = await migrateDataToWorktree(this.cwd, true);
+			if (result.success) {
+				const details = [];
+				if (result.backupPath) details.push(`Backed up to ${result.backupPath}`);
+				details.push(`Migrated ${result.migratedCount} file(s) from .tbd/data-sync/ to worktree`, "Source files removed after successful migration");
+				return {
+					name: "Data location",
+					status: "ok",
+					message: result.backupPath ? `migrated ${result.migratedCount} file(s), backed up to ${result.backupPath}` : `migrated ${result.migratedCount} file(s)`,
+					path: wrongIssuesPath,
+					details
+				};
+			}
 			return {
 				name: "Data location",
 				status: "error",
@@ -105210,15 +105378,13 @@ var DoctorHandler = class extends BaseCommand {
 			};
 			if (consistency.localAhead > 0) return {
 				name: "Sync consistency",
-				status: "warn",
-				message: `${consistency.localAhead} commit(s) ahead of remote`,
-				suggestion: "Run: tbd sync to push changes"
+				status: "ok",
+				message: `${consistency.localAhead} local commit(s) not yet pushed — run \`tbd sync\` to push`
 			};
 			if (consistency.localBehind > 0) return {
 				name: "Sync consistency",
-				status: "warn",
-				message: `${consistency.localBehind} commit(s) behind remote`,
-				suggestion: "Run: tbd sync to pull changes"
+				status: "ok",
+				message: `${consistency.localBehind} remote commit(s) not yet pulled — run \`tbd sync\` to pull`
 			};
 			return {
 				name: "Sync consistency",
@@ -105239,7 +105405,7 @@ var DoctorHandler = class extends BaseCommand {
 		}
 	}
 };
-const doctorCommand = new Command("doctor").description("Diagnose and repair repository").option("--fix", "Attempt to fix issues").action(async (options, command) => {
+const doctorCommand = new Command("doctor").description("Diagnose and repair repository").option("--fix", "Attempt to fix issues").option("--max-history <n>", "Max git commits to scan for ID mapping recovery (0 = full history)", "50").action(async (options, command) => {
 	await new DoctorHandler(command).run(options);
 });
 
@@ -108634,11 +108800,7 @@ var SetupDefaultHandler = class extends BaseCommand {
 		]);
 		if (tbdGitignoreResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitignore`);
 		else if (tbdGitignoreResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitignore with new patterns`);
-		const gitattributesResult = await ensureGitignorePatterns(join(projectDir, TBD_DIR, ".gitattributes"), [
-			"# Protect ID mappings from merge deletion (always keep all rows)",
-			"# See: https://github.com/jlevy/tbd/issues/99",
-			"**/mappings/ids.yml merge=union"
-		]);
+		const gitattributesResult = await ensureGitignorePatterns(join(projectDir, TBD_DIR, ".gitattributes"), ["# Protect ID mappings from merge deletion (always keep all rows)", "**/mappings/ids.yml merge=union"]);
 		if (gitattributesResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitattributes (merge protection)`);
 		else if (gitattributesResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitattributes (merge protection)`);
 		console.log("Checking integrations...");
@@ -108771,11 +108933,7 @@ Example:
 		]);
 		if (tbdGitignoreResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitignore`);
 		else if (tbdGitignoreResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitignore`);
-		const gitattributesResult = await ensureGitignorePatterns(join(cwd, TBD_DIR, ".gitattributes"), [
-			"# Protect ID mappings from merge deletion (always keep all rows)",
-			"# See: https://github.com/jlevy/tbd/issues/99",
-			"**/mappings/ids.yml merge=union"
-		]);
+		const gitattributesResult = await ensureGitignorePatterns(join(cwd, TBD_DIR, ".gitattributes"), ["# Protect ID mappings from merge deletion (always keep all rows)", "**/mappings/ids.yml merge=union"]);
 		if (gitattributesResult.created) console.log(`  ${colors.success("✓")} Created .tbd/.gitattributes (merge protection)`);
 		else if (gitattributesResult.added.length > 0) console.log(`  ${colors.success("✓")} Updated .tbd/.gitattributes (merge protection)`);
 		try {
@@ -109150,7 +109308,7 @@ const workspaceCommand = new Command("workspace").description("Manage workspaces
 function createProgram() {
 	const program = new Command().name("tbd").description("Git-native issue tracking for AI agents and humans").version(VERSION, "--version", "Show version number").helpOption("--help", "Display help for command").showHelpAfterError("(add --help for additional information)");
 	configureColoredHelp(program);
-	program.option("--dry-run", "Show what would be done without making changes").option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--json", "Output as JSON").option("--color <when>", "Colorize output: auto, always, never", "auto").option("--non-interactive", "Disable all prompts, fail if input required").option("--yes", "Assume yes to confirmation prompts").option("--no-sync", "Skip automatic sync after write operations").option("--debug", "Show internal IDs alongside public IDs for debugging");
+	program.option("--dry-run", "Show what would be done without making changes").option("--verbose", "Enable verbose output").option("--quiet", "Suppress non-essential output").option("--json", "Output as JSON").option("--color <when>", "Colorize output: auto, always, never", "auto").option("--no-sync", "Skip automatic sync after write operations").option("--debug", "Show internal IDs alongside public IDs for debugging");
 	program.commandsGroup("Documentation:");
 	program.addCommand(readmeCommand);
 	program.addCommand(primeCommand);