@payconductor/houndsman 0.7.0 → 0.10.0

package/src/skill/hunt.md

@@ -4,16 +4,32 @@
 > (`.agents/skills/houndsman/SKILL.md` e `.claude/skills/houndsman/SKILL.md`).
 
 Revisão de PR: classificação de arquivos → revisão paralela por domínio → consolidação.
-Invocação: `/houndsman` (default) ou `/houndsman hunt`. O motor é o CLI **`houndsman`**;
-as regras do projeto ficam em `houndsman.config.ts` + `.houndsman/`.
+Invocação: `/houndsman` (default), `/houndsman hunt` ou `/houndsman hunt pr 456`.
+O motor é o CLI **`houndsman`**; as regras do projeto ficam em `houndsman.config.ts` +
+`.houndsman/`.
+
+## Alvo da revisão
+
+Traduza o pedido do usuário para flags **antes** de começar:
+
+| Pedido | Alvo | Flag |
+|---|---|---|
+| “revise a PR 456”, “#456”, URL `.../pull/456` | PR | `--pr 456` |
+| “revise a branch feature/x” | branch | `--branch feature/x` |
+| “revise esta PR / o que mudou” | branch atual | *(sem flag)* |
+
+> **Se o alvo é uma PR, use worktree.** Rode `houndsman --pr 456` (não `houndsman`), nunca faça
+> checkout no clone principal e use o caminho impresso na saída como raiz dos subagentes.
+> Isso permite revisar outras PRs em paralelo, cada uma na sua árvore.
 
 **Quando usar:** revisar PR antes de merge · code review de feature branch · validar
 mudanças antes de push.
 
 > **Harness nativo (opcional):** além deste skill, o CLI tem `houndsman hunt` — o mesmo
 > fluxo executado pelo próprio houndsman, com tools read-only, investigação por evidência
-> e `VERIFY` obrigatório. Use `houndsman hunt --dry-run` para inspecionar sem IA. Detalhes
-> em `docs/HARNESS.md`.
+> e `VERIFY` obrigatório. Use `houndsman hunt --dry-run` para inspecionar sem IA. Para uma
+> PR específica, `houndsman hunt --pr 456` roda no worktree automaticamente. Detalhes em
+> `docs/HARNESS.md`.
 
 ## Quem executa o quê
 
@@ -56,7 +72,8 @@ O contexto vem da **descrição da PR** via GitHub CLI (`gh`), quando disponíve
 Um subagente executa o CLI e resume:
 
 ```
-Você é o subagente de contexto do houndsman. Execute `houndsman context`;
+Você é o subagente de contexto do houndsman. Execute `houndsman context --pr 456`
+(ou `houndsman context --worktree <path>` se o prepare já criou o worktree);
 leia o `context-brief.md` indicado na saída; siga as instruções e grave
 `context-summary.json`. Retorne `objective`/`motivation`/`changeSummary` ou "indisponível".
 ```
@@ -72,9 +89,16 @@ leia o `context-brief.md` indicado na saída; siga as instruções e grave
 ## Passo 1 — Preparar (skill executa)
 
 ```bash
-houndsman --base main
+houndsman --pr 456          # alvo = PR (cria/reusa o worktree)
+houndsman --base main       # alvo = branch atual (clone principal)
 ```
 
+Quando o alvo é uma PR, o prepare consulta a PR via `gh`, busca `refs/pull/<n>/head`, cria o
+worktree **detached** em `<repo>/.houndsman/worktrees/<repo>/<branch>` e imprime o caminho.
+Cada brief passa a trazer `**Worktree:** <path>` — essa é a raiz que os subagentes devem ler.
+Guarde também a linha `PR #456 — <head> → <base>`: `<head>` é a branch a usar em
+`status ping`, `findings` e `verify`.
+
 Grava os artefatos no **storage global** (SQLite em `<HOUNDSMAN_HOME>/houndsman.db`) e o
 staging dos subagentes em `<HOUNDSMAN_HOME>/work/<reviewId>/`:
 
@@ -157,6 +181,7 @@ calls) — evita estourar limites de taxa quando há muitos watchdogs. O prompt
 ```
 Leia e execute o brief: <caminho absoluto impresso pelo prepare>/briefs/<watchdog-id>.md
 Você é o watchdog <watchdog-id> do {{projectName}}.
+Use como raiz de leitura o **Worktree:** indicado no brief (nunca o clone principal).
 ```
 
 Cada subagente grava o `outputPath` indicado no brief (schema `.houndsman/core/skill/OUTPUT-FORMAT.md`).
@@ -171,7 +196,8 @@ não são lidos: registre-os em `skipped`.
 ## Passo 3 — Finalizar (skill executa)
 
 ```bash
-houndsman --finalize
+houndsman --pr 456 --finalize     # alvo = PR (reusa o worktree gravado)
+houndsman --finalize              # alvo = branch atual
 ```
 
 Falha com mensagem clara se faltar algum `findings/<watchdog>.json` no staging. Quando todos existem:

package/src/tests/__snapshots__/baseline.test.ts.snap

@@ -200,8 +200,8 @@ exports[`baseline — camada gerada setup gera os mesmos arquivos e conteúdos 2
   ".agents/skills/houndsman/SKILL.md": 
 "---
 name: houndsman
-description: 'Revisa Pull Requests com watchdogs especializados por domínio de negócio e mantém essas regras alinhadas ao projeto. Use para revisar/code review de PR, atualizar as regras de revisão dos watchdogs e corrigir/verificar os findings da revisão. Capabilities: \`hunt\` (revisar a PR), \`train\` (atualizar regras), \`fix\` (corrigir achados), \`verify\` (violações resolvidas?).'
-argument-hint: 'Capability: hunt | train | fix | verify (default: hunt)'
+description: 'Revisa Pull Requests com watchdogs especializados por domínio de negócio e mantém essas regras alinhadas ao projeto. Use para revisar/code review de PR, atualizar as regras de revisão dos watchdogs e corrigir/verificar os findings da revisão. Quando o alvo é uma PR (#456, “PR 456” ou URL do GitHub), revisa em worktree isolado automaticamente. Capabilities: \`hunt\` (revisar a PR), \`train\` (atualizar regras), \`fix\` (corrigir achados), \`verify\` (violações resolvidas?).'
+argument-hint: 'Capability e alvo: hunt --pr 456 | hunt feature/x | train | fix | verify (default: hunt)'
 ---
 
 # houndsman — acme
@@ -226,16 +226,50 @@ especialista por domínio · **finding** = um achado da revisão · **Jev** = pr
 ## Invocação
 
 \`\`\`
-/houndsman              → hunt (default)
-/houndsman hunt         → revisar a Pull Request
-/houndsman train        → atualizar as regras dos watchdogs
-/houndsman fix          → corrigir os findings
-/houndsman verify       → conferir se as violações foram resolvidas
+/houndsman                          → hunt (default)
+/houndsman hunt                     → revisar a Pull Request
+/houndsman hunt, revise a pr 456    → hunt da PR 456 (worktree automático)
+/houndsman hunt feature/minha-branch → hunt da branch (clone atual)
+/houndsman train                    → atualizar as regras dos watchdogs
+/houndsman fix                      → corrigir os findings
+/houndsman verify                   → conferir se as violações foram resolvidas
 \`\`\`
 
-Um argumento extra é o alvo da capability (ex.: \`/houndsman hunt feature/minha-branch\`).
-Escolha a capability pelo que o usuário quer, leia o documento correspondente em
-\`.houndsman/core/skill/<capability>.md\` e siga-o.
+Um argumento extra é o alvo da capability. Escolha a capability pelo que o usuário quer,
+leia o documento correspondente em \`.houndsman/core/skill/<capability>.md\` e siga-o.
+
+### Alvo da revisão (PR × branch)
+
+Interprete o alvo em linguagem natural **antes** de rodar o CLI:
+
+| O usuário disse | Alvo | Flags |
+|---|---|---|
+| \`PR 456\`, \`#456\`, \`pull 456\`, \`456\` (número sozinho), \`https://github.com/org/repo/pull/456\` | PR | \`--pr 456\` |
+| \`feature/minha-branch\`, \`branch feature/x\` | branch | \`--branch feature/minha-branch\` |
+| nada | branch atual | *(sem flag)* |
+
+> **PR citada ⇒ worktree obrigatório.** Nunca rode \`houndsman\` “puro” para revisar uma PR que o
+> usuário nomeou: o prepare precisa criar o worktree dedicado. Também **nunca** faça
+> \`git checkout\` da PR no clone principal — é isso que permite revisar várias PRs ao mesmo
+> tempo.
+
+Sequência para uma PR (ex.: 456):
+
+\`\`\`bash
+houndsman context --pr 456
+houndsman --pr 456                 # cria/reusa o worktree e imprime o caminho
+# despache os briefs (cada um traz **Worktree:** <path>)
+houndsman --pr 456 --finalize
+\`\`\`
+
+- O worktree vive em \`<repo>/.houndsman/worktrees/<repo>/<branch>\` (detached no commit da PR)
+  e é reutilizado nas próximas execuções da mesma branch. Ele fica **dentro do workspace**
+  (e o staging também) para o agente ler/executar sem prompts de permissão.
+- Use \`--worktree <path>\` para aproveitar um worktree já existente.
+- O prepare imprime \`PR #456 — <head> → <base>\`; use \`<head>\` em \`status ping\`,
+  \`findings\` e \`verify\` (\`--branch <head>\`). A review guarda o worktree, então esses
+  comandos leem a árvore correta.
+- PR de fork também funciona: o CLI busca \`refs/pull/<n>/head\`.
 
 > **Depois de revisar (\`hunt\`), valide na UI:** \`bun run houndsman server --open\` — revise os
 > achados e marque os que devem ser executados (\`execute\`) antes de rodar \`fix\`.
@@ -251,8 +285,8 @@ Escolha a capability pelo que o usuário quer, leia o documento correspondente e
   ".claude/skills/houndsman/SKILL.md": 
 "---
 name: houndsman
-description: 'Revisa Pull Requests com watchdogs especializados por domínio de negócio e mantém essas regras alinhadas ao projeto. Use para revisar/code review de PR, atualizar as regras de revisão dos watchdogs e corrigir/verificar os findings da revisão. Capabilities: \`hunt\` (revisar a PR), \`train\` (atualizar regras), \`fix\` (corrigir achados), \`verify\` (violações resolvidas?).'
-argument-hint: 'Capability: hunt | train | fix | verify (default: hunt)'
+description: 'Revisa Pull Requests com watchdogs especializados por domínio de negócio e mantém essas regras alinhadas ao projeto. Use para revisar/code review de PR, atualizar as regras de revisão dos watchdogs e corrigir/verificar os findings da revisão. Quando o alvo é uma PR (#456, “PR 456” ou URL do GitHub), revisa em worktree isolado automaticamente. Capabilities: \`hunt\` (revisar a PR), \`train\` (atualizar regras), \`fix\` (corrigir achados), \`verify\` (violações resolvidas?).'
+argument-hint: 'Capability e alvo: hunt --pr 456 | hunt feature/x | train | fix | verify (default: hunt)'
 ---
 
 # houndsman — acme
@@ -277,16 +311,50 @@ especialista por domínio · **finding** = um achado da revisão · **Jev** = pr
 ## Invocação
 
 \`\`\`
-/houndsman              → hunt (default)
-/houndsman hunt         → revisar a Pull Request
-/houndsman train        → atualizar as regras dos watchdogs
-/houndsman fix          → corrigir os findings
-/houndsman verify       → conferir se as violações foram resolvidas
+/houndsman                          → hunt (default)
+/houndsman hunt                     → revisar a Pull Request
+/houndsman hunt, revise a pr 456    → hunt da PR 456 (worktree automático)
+/houndsman hunt feature/minha-branch → hunt da branch (clone atual)
+/houndsman train                    → atualizar as regras dos watchdogs
+/houndsman fix                      → corrigir os findings
+/houndsman verify                   → conferir se as violações foram resolvidas
 \`\`\`
 
-Um argumento extra é o alvo da capability (ex.: \`/houndsman hunt feature/minha-branch\`).
-Escolha a capability pelo que o usuário quer, leia o documento correspondente em
-\`.houndsman/core/skill/<capability>.md\` e siga-o.
+Um argumento extra é o alvo da capability. Escolha a capability pelo que o usuário quer,
+leia o documento correspondente em \`.houndsman/core/skill/<capability>.md\` e siga-o.
+
+### Alvo da revisão (PR × branch)
+
+Interprete o alvo em linguagem natural **antes** de rodar o CLI:
+
+| O usuário disse | Alvo | Flags |
+|---|---|---|
+| \`PR 456\`, \`#456\`, \`pull 456\`, \`456\` (número sozinho), \`https://github.com/org/repo/pull/456\` | PR | \`--pr 456\` |
+| \`feature/minha-branch\`, \`branch feature/x\` | branch | \`--branch feature/minha-branch\` |
+| nada | branch atual | *(sem flag)* |
+
+> **PR citada ⇒ worktree obrigatório.** Nunca rode \`houndsman\` “puro” para revisar uma PR que o
+> usuário nomeou: o prepare precisa criar o worktree dedicado. Também **nunca** faça
+> \`git checkout\` da PR no clone principal — é isso que permite revisar várias PRs ao mesmo
+> tempo.
+
+Sequência para uma PR (ex.: 456):
+
+\`\`\`bash
+houndsman context --pr 456
+houndsman --pr 456                 # cria/reusa o worktree e imprime o caminho
+# despache os briefs (cada um traz **Worktree:** <path>)
+houndsman --pr 456 --finalize
+\`\`\`
+
+- O worktree vive em \`<repo>/.houndsman/worktrees/<repo>/<branch>\` (detached no commit da PR)
+  e é reutilizado nas próximas execuções da mesma branch. Ele fica **dentro do workspace**
+  (e o staging também) para o agente ler/executar sem prompts de permissão.
+- Use \`--worktree <path>\` para aproveitar um worktree já existente.
+- O prepare imprime \`PR #456 — <head> → <base>\`; use \`<head>\` em \`status ping\`,
+  \`findings\` e \`verify\` (\`--branch <head>\`). A review guarda o worktree, então esses
+  comandos leem a árvore correta.
+- PR de fork também funciona: o CLI busca \`refs/pull/<n>/head\`.
 
 > **Depois de revisar (\`hunt\`), valide na UI:** \`bun run houndsman server --open\` — revise os
 > achados e marque os que devem ser executados (\`execute\`) antes de rodar \`fix\`.
@@ -300,10 +368,12 @@ Escolha a capability pelo que o usuário quer, leia o documento correspondente e
 "
 ,
   ".houndsman/.gitignore": 
-"# Diretórios gerados pelo houndsman — \`core/\` é regenerado por \`houndsman update\`
-# e \`.runs/\` guarda os artefatos de revisão.
+"# Diretórios gerados pelo houndsman — \`core/\` é regenerado por \`houndsman update\`.
+# \`work/\` e \`worktrees/\` são runtime de revisão (staging e worktrees).
 core/
 .runs/
+work/
+worktrees/
 "
 ,
   ".houndsman/core/types.ts": 
@@ -423,10 +493,14 @@ export type HoundsmanAst = {
 /** Providers suportados pela camada de IA. */
 export type AiProviderKind = "deepseek" | "openai" | "anthropic";
 
+/** Opções do AI SDK por provider (repassadas sem interpretação). */
+export type AiProviderOptions = Record<string, Record<string, unknown>>;
+
 /** Features de IA do fluxo normal (todas fail-open). */
 export type HoundsmanAiFeatures = {
 	context?: boolean;
 	brief?: boolean;
+	technical?: boolean;
 	classification?: boolean;
 	preAnalysis?: boolean;
 	verify?: boolean;
@@ -449,6 +523,7 @@ export type HoundsmanAi = {
 	maxSteps?: number;
 	maxOutputTokens?: number;
 	temperature?: number;
+	providerOptions?: AiProviderOptions;
 	timeoutMs?: number;
 	maxCallsPerReview?: number;
 	maxTokensPerReview?: number;
@@ -594,7 +669,7 @@ exports[`baseline — camada gerada setup gera os mesmos arquivos e conteúdos 3
   },
   {
     "file": ".houndsman/core/skill/README.md",
-    "sha256": "0c1514669d044033",
+    "sha256": "1738ef9c6d9ec919",
   },
   {
     "file": ".houndsman/core/skill/SETUP.md",
@@ -610,7 +685,7 @@ exports[`baseline — camada gerada setup gera os mesmos arquivos e conteúdos 3
   },
   {
     "file": ".houndsman/core/skill/hunt.md",
-    "sha256": "b55507d62d3c1fcd",
+    "sha256": "1cf68076325da4ab",
   },
   {
     "file": ".houndsman/core/skill/train.md",

package/src/tests/ai-core.test.ts

@@ -3,8 +3,11 @@
  */
 
 import { describe, expect, test } from "bun:test";
+import type { LanguageModel } from "ai";
 import { z } from "zod";
 import { AiClient, AiUsageBudget, AiUsageRecorder } from "../core/ai";
+import { buildGenerateTextArgs } from "../core/ai/ai-sdk-model-provider";
+import { temperatureApplies } from "../core/ai/provider-capabilities";
 import { defineHoundsmanConfig } from "../core/config";
 import { DEFAULT_AI_MODEL } from "../core/defaults";
 import { ProjectConfig } from "../core/project-config";
@@ -82,6 +85,74 @@ describe("AiClient", () => {
 	});
 });
 
+describe("temperature e providerOptions", () => {
+	test("DeepSeek V4 ignora temperature; thinking disabled reabilita", () => {
+		expect(temperatureApplies("deepseek", "deepseek-v4-pro", undefined)).toBe(false);
+		expect(
+			temperatureApplies("deepseek", "deepseek-v4-pro", {
+				deepseek: { thinking: { type: "disabled" } },
+			}),
+		).toBe(true);
+		expect(
+			temperatureApplies("deepseek", "deepseek-v4-pro", {
+				deepseek: { thinking: { type: "enabled" } },
+			}),
+		).toBe(false);
+		expect(temperatureApplies("deepseek", "deepseek-chat", undefined)).toBe(true);
+		expect(temperatureApplies("openai", "gpt-4o", undefined)).toBe(true);
+	});
+
+	test("adapter omite temperature ignorada e repassa providerOptions", () => {
+		const model = {} as LanguageModel;
+		const thinkingOff = buildGenerateTextArgs(
+			model,
+			{
+				prompt: "oi",
+				temperature: 0,
+				providerOptions: { deepseek: { thinking: { type: "disabled" } } },
+			},
+			"deepseek",
+			"deepseek-v4-pro",
+		);
+		expect(thinkingOff).toMatchObject({
+			temperature: 0,
+			providerOptions: { deepseek: { thinking: { type: "disabled" } } },
+		});
+
+		const defaultThinking = buildGenerateTextArgs(
+			model,
+			{ prompt: "oi", temperature: 0 },
+			"deepseek",
+			"deepseek-v4-pro",
+		);
+		expect(defaultThinking).not.toHaveProperty("temperature");
+
+		const openai = buildGenerateTextArgs(
+			model,
+			{ prompt: "oi", temperature: 0 },
+			"openai",
+			"gpt-4o",
+		);
+		expect(openai).toMatchObject({ temperature: 0 });
+	});
+
+	test("AiClient injeta providerOptions da config", async () => {
+		const configured = new ProjectConfig({
+			...fakeHoundsmanConfig,
+			ai: { providerOptions: { deepseek: { thinking: { type: "disabled" } } } },
+		});
+		const provider = new FakeModelProvider(() => ({ ok: true }));
+		const client = new AiClient({ project: configured, provider });
+		await client.generateObject("x", {
+			prompt: "oi",
+			outputSchema: z.object({ ok: z.boolean() }),
+		});
+		expect(provider.requests[0]?.providerOptions).toEqual({
+			deepseek: { thinking: { type: "disabled" } },
+		});
+	});
+});
+
 describe("AiUsageBudget / AiUsageRecorder", () => {
 	test("acumula uso e bloqueia no teto", () => {
 		const budget = new AiUsageBudget({ maxCalls: 2 });

package/src/tests/ai-features.test.ts

@@ -8,6 +8,7 @@ import { AiBriefEnricher } from "../core/ai/features/brief-enricher";
 import { AiClassifier } from "../core/ai/features/classifier";
 import { AiContextSummarizer } from "../core/ai/features/context-summarizer";
 import { AiPreAnalyzer } from "../core/ai/features/pre-analyzer";
+import { AiTechnicalSummarizer } from "../core/ai/features/technical-summarizer";
 import { AiVerifier } from "../core/ai/features/verifier";
 import { briefInstructions, briefPrompt } from "../core/ai/prompts/brief";
 import { renderBrief } from "../core/brief";
@@ -153,6 +154,41 @@ describe("AiClassifier", () => {
 	});
 });
 
+describe("AiTechnicalSummarizer", () => {
+	test("devolve os destaques estruturais do modelo", async () => {
+		const provider = new FakeModelProvider(() => ({
+			overview: "Novo módulo bin-lookup",
+			highlights: [{ area: "Contratos", detail: "`BinLookupProvider`" }],
+		}));
+		const summarizer = new AiTechnicalSummarizer(new AiClient({ project, provider }));
+		const summary = await summarizer.summarize({
+			branch: "main",
+			classification: {
+				files: { "src/bin-lookup/service.ts": { status: "added" } },
+				churn: { "src/bin-lookup/service.ts": { additions: 3, deletions: 0 } },
+			},
+			headSha: "abc",
+			domains: ["Alpha"],
+		});
+		expect(summary?.source).toBe("ai");
+		expect(summary?.headSha).toBe("abc");
+		expect(summary?.highlights[0].area).toBe("Contratos");
+	});
+
+	test("sem IA o resumo é nulo (fallback no chamador)", async () => {
+		const summarizer = new AiTechnicalSummarizer(
+			new AiClient({ project, provider: null }),
+		);
+		expect(summarizer.enabled).toBe(false);
+		expect(
+			await summarizer.summarize({
+				branch: "main",
+				classification: { files: {}, churn: {} },
+			}),
+		).toBeNull();
+	});
+});
+
 describe("AiVerifier", () => {
 	test("devolve confiança apenas para ids conhecidos", async () => {
 		const provider = new FakeModelProvider(() => ({

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/cli.test.ts

@@ -188,7 +188,8 @@ describe("cli smoke — imports dinâmicos", () => {
 	test("doctor valida a config (import lazy de registry-check)", () => {
 		const project = makeProject();
 		try {
-			const result = runCli(project.cwd, ["doctor"]);
+			// `--no-ping`: o teste cobre import lazy, não latência de rede.
+			const result = runCli(project.cwd, ["doctor", "--no-ping"]);
 			expect(result.code).toBe(0);
 			expect(result.stdout).toContain("Validando");
 		} finally {

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", () => {