@payconductor/houndsman 0.8.0 → 0.11.0

package/src/tests/baseline.test.ts

@@ -28,6 +28,7 @@ import {
 import { defineHoundsmanConfig } from "../core/config";
 import { defaultOptions, finalize, prepare, reviewContext } from "../core/orchestrator";
 import { displayPath } from "../core/paths";
+import { RESUME_MAX_CHARS } from "../core/renderers/resume-renderer";
 import {
 	type MergedFinding,
 	renderDomainReport,
@@ -434,7 +435,9 @@ describe("baseline — artefatos de prepare/finalize", () => {
 			}
 			const resume = storage.readArtifact(review.id, "review-resume.md");
 			expect(resume?.kind).toBe("resume");
-			expect((resume?.content ?? "").length).toBeLessThanOrEqual(2500);
+			expect(resume?.content).toContain("## Pontos técnicos");
+			expect(resume?.content).toContain("Remoções");
+			expect((resume?.content ?? "").length).toBeLessThanOrEqual(RESUME_MAX_CHARS);
 			expect(
 				normalize(JSON.stringify(storage.readFindings(review.id), null, 2)),
 			).toMatchSnapshot("state.json");

package/src/tests/harness-agent.test.ts

@@ -119,4 +119,23 @@ describe("ReviewAgent", () => {
 		expect(result.status).toBe("failed");
 		expect(result.error).toContain("429");
 	});
+
+	test("repassa providerOptions da config em toda chamada", async () => {
+		const provider = investigatingProvider();
+		const reporter = new SilentReporter();
+		const agent = new ReviewAgent(
+			fakeAgentDeps(provider, {
+				context: fakeAgentContext({ repoRoot: dir }),
+				reporter,
+				providerOptions: { deepseek: { thinking: { type: "disabled" } } },
+			}),
+		);
+		await agent.run();
+		expect(provider.requests.length).toBeGreaterThan(0);
+		for (const request of provider.requests) {
+			expect(request.providerOptions).toEqual({
+				deepseek: { thinking: { type: "disabled" } },
+			});
+		}
+	});
 });

package/src/tests/review-resume.test.ts

@@ -1,6 +1,6 @@
 /**
- * Resumo final (`review-resume.md`) — conteúdo de negócio + pontos técnicos,
- * determinístico e limitado a `RESUME_MAX_CHARS`.
+ * Resumo final (`review-resume.md`) — conteúdo de negócio + pontos técnicos
+ * estruturais, determinístico e limitado a `RESUME_MAX_CHARS`.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -10,6 +10,7 @@ import {
 	renderReviewResume,
 } from "../core/renderers/resume-renderer";
 import type { MergedFinding } from "../core/report-builder";
+import type { TechnicalSummary } from "../core/technical-summary";
 
 function finding(overrides: Partial<MergedFinding> = {}): MergedFinding {
 	return {
@@ -32,8 +33,24 @@ const classification: ResumeClassification = {
 	watchdogs: { alpha: ["src/a.ts"], beta: ["src/b.ts"] },
 };
 
+const technical: TechnicalSummary = {
+	source: "ai",
+	headSha: "abc123",
+	overview: "Novo service `bin-lookup` com provider e repository.",
+	highlights: [
+		{
+			area: "Contratos",
+			detail: "`BinLookupProvider` (src/bin-lookup/provider.ts)",
+		},
+		{
+			area: "Implementações",
+			detail: "`BinLookupService` (src/bin-lookup/service.ts)",
+		},
+	],
+};
+
 describe("renderReviewResume", () => {
-	test("une contexto de negócio e pontos técnicos", () => {
+	test("une contexto de negócio e pontos técnicos estruturais", () => {
 		const md = renderReviewResume({
 			branch: "feat/x",
 			date: "2026-10-17",
@@ -48,7 +65,7 @@ describe("renderReviewResume", () => {
 				finding({ severity: "blocking", message: "quebra o cadastro" }),
 				finding({ severity: "attention", file: "src/b.ts", line: undefined }),
 			],
-			nameOf: (id) => id.toUpperCase(),
+			technical,
 		});
 
 		expect(md).toContain("# Resumo da revisão — feat/x");
@@ -58,8 +75,11 @@ describe("renderReviewResume", () => {
 		expect(md).toContain("**Por quê:** Reduzir o esforço manual.");
 		expect(md).toContain("- Novo fluxo de cadastro.");
 		expect(md).not.toContain("## Números");
-		expect(md).toContain("`src/a.ts:1` — quebra o cadastro _(ALPHA)_");
-		expect(md).toContain("`src/b.ts` — mensagem _(ALPHA)_");
+		expect(md).toContain("## Pontos técnicos");
+		expect(md).toContain("Novo service `bin-lookup`");
+		expect(md).toContain("**Contratos** — `BinLookupProvider`");
+		expect(md).toContain("**Implementações** — `BinLookupService`");
+		expect(md).not.toContain("quebra o cadastro");
 		expect(md.length).toBeLessThanOrEqual(RESUME_MAX_CHARS);
 	});
 
@@ -72,7 +92,7 @@ describe("renderReviewResume", () => {
 
 		expect(md).toContain("Sem resumo de contexto da PR disponível.");
 		expect(md).toContain("✅ Aprovado");
-		expect(md).toContain("- Nenhum bloqueio ou ponto de atenção.");
+		expect(md).toContain("Sem mudanças estruturais detectadas nesta revisão.");
 	});
 
 	test("respeita o teto de caracteres", () => {
@@ -89,10 +109,18 @@ describe("renderReviewResume", () => {
 				available: true,
 				objective: "o".repeat(1000),
 				motivation: "m".repeat(1000),
-				changeSummary: ["a".repeat(200), "b".repeat(200)],
+				changeSummary: ["a".repeat(300), "b".repeat(300)],
 			},
 			classification,
 			findings,
+			technical: {
+				source: "deterministic",
+				overview: "v".repeat(600),
+				highlights: Array.from({ length: 10 }, (_, index) => ({
+					area: `Área ${index}`,
+					detail: "x".repeat(300),
+				})),
+			},
 		});
 
 		expect(md.length).toBeLessThanOrEqual(RESUME_MAX_CHARS);

package/src/tests/review-scope.test.ts

@@ -300,3 +300,70 @@ describe("prepare/finalize — mesmo commit", () => {
 		}
 	}, 30_000);
 });
+
+// ---------------------------------------------------------------------------
+// Run vazia
+// ---------------------------------------------------------------------------
+
+describe("prepare sem alterações", () => {
+	test("run recém-criada é descartada (sem run vazia na lista)", async () => {
+		const repo = makeRepo();
+		const originalCwd = process.cwd();
+		const originalHome = process.env.HOUNDSMAN_HOME;
+		let storage: SQLiteStorageProvider | null = null;
+
+		try {
+			process.env.HOUNDSMAN_HOME = join(repo.cwd, ".home");
+			process.chdir(repo.cwd);
+
+			storage = new SQLiteStorageProvider(join(repo.cwd, "houndsman.db"));
+			const record = storage.getOrCreateReview({
+				repo: resolveRepoIdentity(),
+				branch: "main",
+				slug: "main",
+			});
+			const opts = {
+				...defaultOptions(),
+				base: repo.head,
+				head: "HEAD",
+				noJev: true,
+			};
+
+			const result = await prepare(
+				opts,
+				"main",
+				fakeHoundsmanConfig,
+				reviewContext(storage, record),
+			);
+			expect(result.messages.join("\n")).toContain("nenhuma run criada");
+			expect(storage.getReview(record.id)).toBeNull();
+			expect(storage.listArtifacts(record.id)).toHaveLength(0);
+
+			// Run com artefatos anteriores (contexto) continua existindo.
+			const kept = storage.getOrCreateReview({
+				repo: resolveRepoIdentity(),
+				branch: "main",
+				slug: "main",
+			});
+			storage.writeArtifact(kept.id, {
+				name: "context.json",
+				kind: "context",
+				content: "{}\n",
+			});
+			await prepare(
+				opts,
+				"main",
+				fakeHoundsmanConfig,
+				reviewContext(storage, kept),
+			);
+			expect(storage.getReview(kept.id)?.status).toBe("review_done");
+			expect(storage.readArtifact(kept.id, "context.json")).not.toBeNull();
+		} finally {
+			storage?.close();
+			process.chdir(originalCwd);
+			if (originalHome === undefined) delete process.env.HOUNDSMAN_HOME;
+			else process.env.HOUNDSMAN_HOME = originalHome;
+			repo.cleanup();
+		}
+	}, 30_000);
+});

package/src/tests/review-scripts.test.ts

@@ -799,9 +799,9 @@ describe("context-summary", () => {
 				(_, i) => `item ${i} ${"z".repeat(300)}`,
 			),
 		});
-		expect(summary?.objective?.length).toBeLessThanOrEqual(200);
+		expect(summary?.objective?.length).toBeLessThanOrEqual(400);
 		expect(summary?.objective?.endsWith("…")).toBe(true);
-		expect(summary?.changeSummary).toHaveLength(4);
+		expect(summary?.changeSummary).toHaveLength(6);
 	});
 
 	test("renderReport coloca a seção de contexto quando presente", () => {

package/src/tests/server.test.ts

@@ -436,7 +436,19 @@ describe("server API", () => {
 		try {
 			const handler = createRequestHandler(env.config, env);
 			const shell = await get(handler, "/");
-			expect(await shell.text()).toContain('id="app"');
+			const html = await shell.text();
+			expect(html).toContain('id="app"');
+			expect(html).toContain("/assets/styles.css?v=");
+
+			// O CSS vive em `styles.css`, servido como arquivo real.
+			const css = await get(handler, "/assets/styles.css");
+			expect(css.status).toBe(200);
+			expect(css.headers.get("content-type")).toContain("text/css");
+			const styles = await css.text();
+			// Sidebar: rail vertical de seções + painel redimensionável.
+			expect(styles).toContain(".side-rail");
+			expect(styles).toContain("--side-width");
+			expect(styles).not.toContain(".side-tabs");
 
 			const bundle = await get(handler, "/assets/app.js");
 			expect(bundle.status).toBe(200);
@@ -458,6 +470,9 @@ describe("server API", () => {
 
 			const bundle = await get(handler, "/assets/app.js");
 			expect(bundle.headers.get("cache-control")).toContain("no-store");
+
+			const css = await get(handler, "/assets/styles.css");
+			expect(css.headers.get("cache-control")).toContain("no-store");
 		} finally {
 			env.cleanup();
 		}

package/src/tests/sidebar-sections.test.ts

@@ -0,0 +1,94 @@
+/**
+ * Navegação da sidebar: registry de seções e preferências de layout.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	DEFAULT_SIDEBAR_SECTION,
+	getSidebarSection,
+	resolveSidebarSectionId,
+	SIDEBAR_SECTIONS,
+	type SidebarSectionContext,
+} from "../server/client/sidebar-sections";
+import {
+	clampSidebarWidth,
+	readSidebarPrefs,
+	SIDEBAR_DEFAULT_WIDTH,
+	SIDEBAR_MAX_WIDTH,
+	SIDEBAR_MIN_WIDTH,
+} from "../server/client/utils/sidebar-prefs";
+import type { RunSummary } from "../server/client/utils/types";
+
+function makeRun(slug: string): RunSummary {
+	return {
+		slug,
+		branch: slug,
+		summary: {
+			total: 0,
+			present: 0,
+			byDecision: { pending: 0, execute: 0, ignore: 0 },
+			byExecState: { pending: 0, in_progress: 0, done: 0, stale: 0 },
+			bySeverity: { blocking: 0, attention: 0, suggestion: 0, nit: 0 },
+		},
+	};
+}
+
+function makeContext(runs: RunSummary[]): SidebarSectionContext {
+	return {
+		runs,
+		slug: null,
+		onSelect: () => undefined,
+		onRefreshRuns: () => undefined,
+		active: true,
+	};
+}
+
+describe("SIDEBAR_SECTIONS", () => {
+	test("expõe Execuções e PRs na ordem canônica", () => {
+		expect(SIDEBAR_SECTIONS.map((section) => section.id)).toEqual(["runs", "prs"]);
+		expect(DEFAULT_SIDEBAR_SECTION).toBe("runs");
+	});
+
+	test("cada seção tem identificação e conteúdo", () => {
+		const ids = new Set<string>();
+		for (const section of SIDEBAR_SECTIONS) {
+			expect(section.id).not.toBe("");
+			expect(ids.has(section.id)).toBe(false);
+			ids.add(section.id);
+			expect(section.label.length).toBeGreaterThan(0);
+			expect(section.title.length).toBeGreaterThan(0);
+			expect(typeof section.icon).toBe("function");
+			expect(typeof section.Content).toBe("function");
+		}
+	});
+
+	test("o badge de Execuções reflete a contagem de runs", () => {
+		const runs = SIDEBAR_SECTIONS.find((section) => section.id === "runs");
+		expect(runs?.badge?.(makeContext([]))).toBeNull();
+		expect(runs?.badge?.(makeContext([makeRun("a"), makeRun("b")]))).toBe(2);
+	});
+
+	test("resolve ids salvos e cai no default quando inválidos", () => {
+		expect(resolveSidebarSectionId("prs")).toBe("prs");
+		expect(resolveSidebarSectionId("desconhecida")).toBe(DEFAULT_SIDEBAR_SECTION);
+		expect(resolveSidebarSectionId(null)).toBe(DEFAULT_SIDEBAR_SECTION);
+		expect(getSidebarSection("desconhecida").id).toBe(DEFAULT_SIDEBAR_SECTION);
+	});
+});
+
+describe("preferências da sidebar", () => {
+	test("clampa a largura entre mínimo e máximo", () => {
+		expect(clampSidebarWidth(200)).toBe(SIDEBAR_MIN_WIDTH);
+		expect(clampSidebarWidth(900)).toBe(SIDEBAR_MAX_WIDTH);
+		expect(clampSidebarWidth(400)).toBe(400);
+		expect(clampSidebarWidth(Number.NaN)).toBe(SIDEBAR_DEFAULT_WIDTH);
+	});
+
+	test("lê defaults sem preferências salvas", () => {
+		const prefs = readSidebarPrefs();
+		expect(prefs.width).toBeGreaterThanOrEqual(SIDEBAR_MIN_WIDTH);
+		expect(prefs.width).toBeLessThanOrEqual(SIDEBAR_MAX_WIDTH);
+		expect(typeof prefs.collapsed).toBe("boolean");
+		if (prefs.section !== null) expect(typeof prefs.section).toBe("string");
+	});
+});

package/src/tests/technical-summary.test.ts

@@ -0,0 +1,176 @@
+/**
+ * Pontos técnicos estruturais do resumo final — builder determinístico e
+ * validação do artefato `technical-summary.json`.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { AstAnalysis, AstFacts, AstImpact } from "../core/ast/types";
+import { buildTechnicalSummary, parseTechnicalSummary } from "../core/technical-summary";
+
+const facts: AstFacts = {
+	language: "typescript",
+	symbols: [],
+	imports: [],
+	exports: [],
+	decorators: [],
+	hasSyntaxErrors: false,
+};
+
+function analysis(partial: Partial<AstAnalysis> = {}): AstAnalysis {
+	return {
+		facts,
+		delta: {
+			addedSymbols: [],
+			removedSymbols: [],
+			modifiedSymbols: [],
+			changedSignatures: [],
+			addedImports: [],
+			removedImports: [],
+			changedExports: [],
+		},
+		...partial,
+	};
+}
+
+const classification = {
+	files: {
+		"src/bin-lookup/service.ts": { status: "added" },
+		"src/bin-lookup/provider.ts": { status: "added" },
+	},
+	churn: {
+		"src/bin-lookup/service.ts": { additions: 10, deletions: 0 },
+		"src/bin-lookup/provider.ts": { additions: 5, deletions: 0 },
+	},
+} as const;
+
+describe("buildTechnicalSummary", () => {
+	test("extrai contratos, implementações, assinaturas e dependências do AST", () => {
+		const ast = new Map<string, AstAnalysis>([
+			[
+				"src/bin-lookup/service.ts",
+				analysis({
+					delta: {
+						addedSymbols: [
+							{
+								name: "BinLookupProvider",
+								kind: "interface",
+								exported: true,
+								startLine: 1,
+								endLine: 3,
+							},
+							{
+								name: "BinLookupService",
+								kind: "class",
+								exported: true,
+								startLine: 5,
+								endLine: 20,
+							},
+						],
+						removedSymbols: [],
+						modifiedSymbols: [],
+						changedSignatures: [
+							{
+								name: "lookup",
+								before: "(bin: string)",
+								after: "(bin: string, brand: string)",
+								exported: true,
+							},
+						],
+						addedImports: ["./provider", "axios"],
+						removedImports: [],
+						changedExports: [{ name: "legacy", change: "removed" }],
+					},
+				}),
+			],
+		]);
+
+		const summary = buildTechnicalSummary({
+			classification,
+			ast,
+			headSha: "abc",
+		});
+
+		expect(summary.source).toBe("deterministic");
+		expect(summary.headSha).toBe("abc");
+		const text = summary.highlights.map((item) => `${item.area}: ${item.detail}`);
+		expect(text.join("\n")).toContain("Contratos: `BinLookupProvider`");
+		expect(text.join("\n")).toContain("Implementações: `BinLookupService`");
+		expect(text.join("\n")).toContain("Assinaturas alteradas: `lookup`");
+		expect(text.join("\n")).toContain("Novas dependências: `axios`");
+		expect(text.join("\n")).not.toContain("./provider");
+		expect(text.join("\n")).toContain("Exports alterados: `legacy`");
+	});
+
+	test("sem AST, agrupa arquivos novos por diretório", () => {
+		const summary = buildTechnicalSummary({ classification });
+		expect(summary.highlights[0]).toEqual({
+			area: "Estrutura",
+			detail: "Novo diretório `src/bin-lookup` com 2 arquivo(s).",
+		});
+	});
+
+	test("registra remoções e impacto", () => {
+		const impact: AstImpact = {
+			importers: { "src/bin-lookup/service.ts": ["src/a.ts"] },
+			affectedFiles: ["src/a.ts"],
+			exportedChanges: [
+				{
+					file: "src/bin-lookup/service.ts",
+					symbol: "lookup",
+					change: "removed",
+				},
+			],
+		};
+		const summary = buildTechnicalSummary({
+			classification: {
+				files: {
+					"src/old.ts": { status: "deleted" },
+					"src/bin-lookup/service.ts": { status: "modified" },
+				},
+				churn: {},
+			},
+			impact,
+		});
+		const text = summary.highlights.map((item) => `${item.area}: ${item.detail}`);
+		expect(text.join("\n")).toContain("Remoções: `src/old.ts`");
+		expect(text.join("\n")).toContain("Impacto: 1 arquivo(s) importam os alterados");
+	});
+
+	test("não gera destaques quando não há mudança estrutural", () => {
+		const summary = buildTechnicalSummary({
+			classification: { files: {}, churn: {} },
+		});
+		expect(summary.highlights).toEqual([]);
+	});
+});
+
+describe("parseTechnicalSummary", () => {
+	test("aceita artefato válido e normaliza o source", () => {
+		const summary = parseTechnicalSummary({
+			source: "deterministic",
+			headSha: "abc",
+			overview: "Estrutura",
+			highlights: [{ area: "Contratos", detail: "`X`" }],
+		});
+		expect(summary?.source).toBe("deterministic");
+		expect(summary?.highlights[0].area).toBe("Contratos");
+	});
+
+	test("rejeita conteúdo vazio ou inválido", () => {
+		expect(parseTechnicalSummary(null)).toBeNull();
+		expect(parseTechnicalSummary({})).toBeNull();
+		expect(
+			parseTechnicalSummary({ highlights: [{ area: "", detail: "" }] }),
+		).toBeNull();
+	});
+
+	test("limita a seis destaques", () => {
+		const summary = parseTechnicalSummary({
+			highlights: Array.from({ length: 10 }, (_, index) => ({
+				area: `Área ${index}`,
+				detail: `Detalhe ${index}`,
+			})),
+		});
+		expect(summary?.highlights).toHaveLength(6);
+	});
+});

package/src/tests/worktree.test.ts

@@ -16,7 +16,7 @@ import {
 	writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { parseReviewArgs } from "../core/commands/review";
 import { HoundsmanEngine } from "../core/engine/houndsman-engine";
 import { resolveReviewWorkspace } from "../core/engine/review-workspace";
@@ -24,7 +24,12 @@ import { createGitRunner } from "../core/git-runner";
 import { defaultOptions } from "../core/orchestrator";
 import type { GhRunner } from "../core/services/gh-client";
 import { GitRepository } from "../core/services/git-repository";
-import { parseWorktreeList, WorktreeManager } from "../core/services/worktree-manager";
+import {
+	parseWorktreeList,
+	syncProjectLayer,
+	syncProjectLayerForRoot,
+	WorktreeManager,
+} from "../core/services/worktree-manager";
 import { SQLiteStorageProvider } from "../core/storage/sqlite/sqlite-storage";
 import { parseHuntArgs } from "../harness/hunt/hunt-options";
 import { fakeHoundsmanConfig } from "./fixtures/fake-project";
@@ -151,6 +156,106 @@ describe("parseWorktreeList", () => {
 	});
 });
 
+describe("nomes de diretório do worktree", () => {
+	const manager = new WorktreeManager(
+		new GitRepository(createGitRunner(process.cwd())),
+		{
+			repoKey: "remote:github.com/tradinglabs-io/pay.conductor",
+			repoRoot: process.cwd(),
+			baseDir: join(tmpdir(), "houndsman-worktrees"),
+		},
+	);
+
+	test("repo e branch são slugs curtos com hash", () => {
+		// MAX_PATH do Windows: cada segmento fica limitado a legível + hash8.
+		expect(basename(manager.baseDir).length).toBeLessThanOrEqual(24 + 9);
+		expect(basename(manager.pathFor("main"))).toMatch(/^main-[0-9a-f]{8}$/);
+
+		const long = manager.pathFor("feat/fetch-branch-balance-split-accounts");
+		const name = basename(long);
+		expect(name).toMatch(/^[\w.-]{1,20}-[0-9a-f]{8}$/);
+		expect(name.length).toBeLessThanOrEqual(20 + 9);
+		expect(long.startsWith(manager.baseDir)).toBe(true);
+	});
+
+	test("é determinístico e não colide em prefixos iguais", () => {
+		const branch = "feat/fetch-branch-balance-split-accounts";
+		expect(manager.pathFor(branch)).toBe(manager.pathFor(branch));
+		expect(manager.pathFor(branch)).not.toBe(
+			manager.pathFor("feat/fetch-branch-balance-split-other"),
+		);
+	});
+
+	test("branches só de caracteres inválidos caem no fallback", () => {
+		expect(basename(manager.pathFor("///"))).toMatch(/^branch-[0-9a-f]{8}$/);
+	});
+});
+
+describe("camada gerada no worktree", () => {
+	test("espelha `.houndsman/core` do clone principal e ignora origem ausente", () => {
+		const sandbox = makeSandbox();
+		try {
+			const worktree = join(sandbox.root, "wt-layer");
+			mkdirSync(worktree, { recursive: true });
+			mkdirSync(join(sandbox.repo, ".houndsman", "core"), { recursive: true });
+			writeFileSync(
+				join(sandbox.repo, ".houndsman", "core", "types.ts"),
+				"export {};\n",
+			);
+
+			expect(syncProjectLayer(sandbox.repo, worktree)).toBe(true);
+			expect(existsSync(join(worktree, ".houndsman", "core", "types.ts"))).toBe(
+				true,
+			);
+
+			// Sem camada na origem: no-op (fail-open).
+			const empty = join(sandbox.root, "empty");
+			mkdirSync(empty, { recursive: true });
+			expect(syncProjectLayer(empty, worktree)).toBe(false);
+		} finally {
+			sandbox.cleanup();
+		}
+	});
+
+	test("ensure copia a camada e o auto-reparo repõe num worktree existente", () => {
+		const sandbox = makeSandbox();
+		try {
+			mkdirSync(join(sandbox.repo, ".houndsman", "core"), { recursive: true });
+			writeFileSync(
+				join(sandbox.repo, ".houndsman", "core", "types.ts"),
+				"export {};\n",
+			);
+			const manager = new WorktreeManager(
+				new GitRepository(createGitRunner(sandbox.repo)),
+				{
+					repoKey: "path:fake",
+					repoRoot: sandbox.repo,
+					baseDir: sandbox.home,
+				},
+			);
+
+			const ensured = manager.ensure({
+				branch: "feature",
+				ref: sandbox.featureSha,
+			});
+			const layer = join(ensured.path, ".houndsman", "core", "types.ts");
+			expect(existsSync(layer)).toBe(true);
+
+			// Comando rodando no worktree (sem `--pr`) também se auto-repara.
+			rmSync(join(ensured.path, ".houndsman", "core"), {
+				recursive: true,
+				force: true,
+			});
+			expect(syncProjectLayerForRoot(ensured.path)).toBe(true);
+			expect(existsSync(layer)).toBe(true);
+
+			manager.remove("feature");
+		} finally {
+			sandbox.cleanup();
+		}
+	}, 20_000);
+});
+
 describe("WorktreeManager", () => {
 	test("cria detached, reusa o mesmo commit e remove", () => {
 		const sandbox = makeSandbox();
@@ -180,7 +285,7 @@ describe("WorktreeManager", () => {
 		} finally {
 			sandbox.cleanup();
 		}
-	});
+	}, 20_000);
 });
 
 describe("revisões paralelas em worktrees", () => {
@@ -263,7 +368,7 @@ describe("revisões paralelas em worktrees", () => {
 			else process.env.HOUNDSMAN_HOME = originalHome;
 			sandbox.cleanup();
 		}
-	});
+	}, 30_000);
 
 	test("duas PRs preparam em paralelo sem se contaminar", async () => {
 		const sandbox = makeSandbox();
@@ -365,5 +470,5 @@ describe("revisões paralelas em worktrees", () => {
 			else process.env.HOUNDSMAN_HOME = originalHome;
 			sandbox.cleanup();
 		}
-	});
+	}, 30_000);
 });