@payconductor/houndsman 0.6.0 → 0.8.0

package/src/skill/README.md

@@ -39,13 +39,20 @@ Um único skill (`/houndsman`), quatro capabilities (detalhadas em `hunt.md`, `t
 | 2. Revisar | *(subagentes)* | skill | `findings/<watchdog>.json` (um por watchdog) |
 | 3. Finalizar | `bun run houndsman --finalize` | skill | `review.md` |
 
+> **Alvo = PR** (ex.: “revise a PR 456”): troque os passos por `houndsman context --pr 456`,
+> `houndsman --pr 456` e `houndsman --pr 456 --finalize`. O prepare cria um **worktree**
+> detached em `<repo>/.houndsman/worktrees/<repo>/<branch>`; os briefs trazem
+> `**Worktree:**` e os subagentes devem ler essa árvore (nunca o clone principal).
+
 ## Comandos
 
 | Comando | Função |
 |---|---|
-| `houndsman context` | Passo 0 — contexto da PR via `gh` |
+| `houndsman context` | Passo 0 — contexto da PR via `gh` (`--pr <n>`/`--worktree <path>`) |
 | `houndsman` | Passo 1 — preparar (gera os briefs) |
-| `houndsman --finalize` | Passo 3 — gerar o relatório |
+| `houndsman --pr <n>` | Passo 1 em worktree dedicado (revisões paralelas) |
+| `houndsman --finalize` | Passo 3 — gerar o relatório (`--pr <n>` reusa o worktree) |
+| `houndsman worktree <ação>` | `list`/`add`/`remove`/`prune`/`path` dos worktrees |
 | `houndsman watchdog <id>` | Contexto de um watchdog (`--json`, `--rules`) |
 | `houndsman findings <sub>` | Triagem/correção dos findings (`list`/`set`/`done`/`sync`/`batch`/`verify`/...) |
 | `houndsman server` | UI local de triagem (Bun.serve + Preact) |
@@ -57,7 +64,8 @@ Um único skill (`/houndsman`), quatro capabilities (detalhadas em `hunt.md`, `t
 ### Flags
 
 `--config <path>` · `--base <branch>` (default `main`) · `--head <ref>` (default `HEAD`) ·
-`--branch <nome>` · `--clean` · `--full` · `--no-jev` · `--fail-on-blocking` (no `--finalize`).
+`--branch <nome>` · `--pr <n>` · `--worktree <path>` · `--clean` · `--full` · `--no-jev` ·
+`--fail-on-blocking` (no `--finalize`).
 
 ## Artefatos
 

package/src/skill/SKILL.md

@@ -1,7 +1,7 @@
 ---
 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 — {{projectName}}
@@ -26,16 +26,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`.

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. 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
 \`\`\`
 
-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.
+- 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": 
@@ -594,7 +664,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 +680,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

@@ -16,8 +16,8 @@ const project = new ProjectConfig(fakeHoundsmanConfig);
 
 describe("config de IA", () => {
 	test("modelo default do DeepSeek é 4.1 flash", () => {
-		expect(DEFAULT_AI_MODEL).toBe("deepseek-v4.1-flash");
-		expect(project.aiModel).toBe("deepseek-v4.1-flash");
+		expect(DEFAULT_AI_MODEL).toBe("deepseek-v4-pro");
+		expect(project.aiModel).toBe("deepseek-v4-pro");
 	});
 });
 

package/src/tests/cli.test.ts

@@ -152,10 +152,44 @@ describe("cli smoke — imports dinâmicos", () => {
 		}
 	});
 
+	test("findings submit filtra pela decisão (a executar)", () => {
+		const project = makeProject();
+		try {
+			const pending = runCli(project.cwd, [
+				"findings",
+				"submit",
+				"--dry-run",
+				"--json",
+				"--branch",
+				"main",
+				"--decision",
+				"pending",
+			]);
+			expect(pending.code).toBe(0);
+			expect(JSON.parse(pending.stdout).totals.candidates).toBe(1);
+
+			const execute = runCli(project.cwd, [
+				"findings",
+				"submit",
+				"--dry-run",
+				"--json",
+				"--branch",
+				"main",
+				"--decision",
+				"execute",
+			]);
+			expect(execute.code).toBe(0);
+			expect(JSON.parse(execute.stdout).totals.candidates).toBe(0);
+		} finally {
+			project.cleanup();
+		}
+	});
+
 	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/github-review.test.ts

@@ -294,6 +294,15 @@ describe("selectSubmitCandidates", () => {
 		expect(selectSubmitCandidates(state, { execStates: ["done"] })).toEqual([]);
 	});
 
+	test("filtra pela decisão (a executar vs ainda pendente)", () => {
+		const execute = selectSubmitCandidates(state, { decisions: ["execute"] });
+		expect(execute.map((c) => c.id)).toEqual(["a"]);
+		expect(execute[0].decision).toBe("execute");
+		expect(
+			selectSubmitCandidates(state, { decisions: ["pending"] }).map((c) => c.id),
+		).toEqual(["c"]);
+	});
+
 	test("marca sent/skip e respeita includeSent", () => {
 		const sent = stateWith([finding({ id: "a", commentId: 99 })]);
 		const [only] = selectSubmitCandidates(sent);

package/src/tests/server-editor.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from "bun:test";
+import {
+	editorFileLink,
+	jetbrainsFileLink,
+	vscodeFileLink,
+} from "../server/client/utils/format";
+import { detectEditor, resolveEditor } from "../server/editor";
+
+describe("detecção de editor", () => {
+	test("VS Code pelo TERM_PROGRAM", () => {
+		expect(detectEditor({ TERM_PROGRAM: "vscode" }, "/work/app")).toMatchObject({
+			kind: "vscode",
+			project: "app",
+		});
+	});
+
+	test("VS Code pelas variáveis VSCODE_*", () => {
+		expect(detectEditor({ VSCODE_PID: "123" }, "/work/app")).toMatchObject({
+			kind: "vscode",
+			project: "app",
+		});
+	});
+
+	test("JetBrains pelo terminal e produto do bundle", () => {
+		expect(
+			detectEditor(
+				{
+					TERMINAL_EMULATOR: "JetBrains-JediTerm",
+					__CFBundleIdentifier: "com.jetbrains.pycharm",
+				},
+				"/work/app",
+			),
+		).toEqual({ kind: "jetbrains", project: "app", product: "pycharm" });
+	});
+
+	test("JetBrains por *_INITIAL_DIRECTORY", () => {
+		expect(
+			detectEditor({ WEBSTORM_INITIAL_DIRECTORY: "/work/app" }, "/work/app"),
+		).toEqual({ kind: "jetbrains", project: "app", product: "webstorm" });
+	});
+
+	test("produto JetBrains ambíguo cai em idea", () => {
+		expect(
+			detectEditor({ TERMINAL_EMULATOR: "JetBrains-JediTerm" }, "/work/app"),
+		).toEqual({ kind: "jetbrains", project: "app", product: "idea" });
+	});
+
+	test("sem pistas → none", () => {
+		expect(detectEditor({}, "/work/app")).toEqual({
+			kind: "none",
+			project: "app",
+		});
+	});
+
+	test("resolveEditor força vscode/jetbrains/none", () => {
+		expect(resolveEditor("vscode", {}, "/work/app")).toMatchObject({
+			kind: "vscode",
+		});
+		expect(resolveEditor("jetbrains", {}, "/work/app")).toMatchObject({
+			kind: "jetbrains",
+			product: "idea",
+		});
+		expect(
+			resolveEditor("none", { TERM_PROGRAM: "vscode" }, "/work/app"),
+		).toMatchObject({ kind: "none" });
+		expect(resolveEditor("desconhecido", {}, "/work/app")).toMatchObject({
+			kind: "none",
+		});
+	});
+});
+
+describe("links de editor", () => {
+	test("VS Code normaliza o drive e mantém a linha", () => {
+		expect(vscodeFileLink("C:\\repo\\src\\a.ts", 12)).toBe(
+			"vscode://file/c:/repo/src/a.ts:12",
+		);
+	});
+
+	test("JetBrains monta navigate/reference", () => {
+		const link = jetbrainsFileLink("C:\\repo\\src\\a.ts", 12, "app", "webstorm");
+		expect(link).toContain(
+			"jetbrains://webstorm/navigate/reference?project=app&path=",
+		);
+		expect(link ? decodeURIComponent(link) : "").toContain("C:/repo/src/a.ts:12");
+	});
+
+	test("editorFileLink respeita o tipo detectado", () => {
+		expect(editorFileLink("/repo/a.ts", 3, { kind: "vscode", project: "app" })).toBe(
+			"vscode://file//repo/a.ts:3",
+		);
+		expect(
+			editorFileLink("/repo/a.ts", 3, {
+				kind: "jetbrains",
+				project: "app",
+				product: "goland",
+			}),
+		).toContain("jetbrains://goland/");
+		expect(editorFileLink("/repo/a.ts", 3, { kind: "none" })).toBeNull();
+	});
+});